enlace 0.0.1-beta.13 → 0.0.1-beta.15

package/README.md

@@ -11,7 +11,7 @@ npm install enlace
 ## Quick Start
 
 ```typescript
-import { createEnlaceHookReact } from "enlace/hook";
+import { enlaceHookReact } from "enlace/hook";
 import { Endpoint } from "enlace";
 
 // Define your API error type
@@ -30,7 +30,7 @@ type ApiSchema = {
 };
 
 // Pass global error type as second generic
-const useAPI = createEnlaceHookReact<ApiSchema, ApiError>(
+const useAPI = enlaceHookReact<ApiSchema, ApiError>(
   "https://api.example.com"
 );
 ```
@@ -41,13 +41,13 @@ Defining a schema is **recommended** for full type safety, but **optional**. You
 
 ```typescript
 // Without schema (untyped, but still works!)
-const useAPI = createEnlaceHookReact("https://api.example.com");
-const { data } = useAPI((api) => api.any.path.you.want.get());
+const useAPI = enlaceHookReact("https://api.example.com");
+const { data } = useAPI((api) => api.any.path.you.want.$get());
 ```
 
 ```typescript
 // With schema (recommended for type safety)
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com");
+const useAPI = enlaceHookReact<ApiSchema>("https://api.example.com");
 ```
 
 ### Schema Structure
@@ -77,12 +77,12 @@ type ApiSchema = {
 };
 
 // Pass global error type - applies to all endpoints
-const api = createEnlace<ApiSchema, ApiError>("https://api.example.com");
+const api = enlace<ApiSchema, ApiError>("https://api.example.com");
 
 // Usage
-api.users.get(); // GET /users
-api.users[123].get(); // GET /users/123
-api.users[123].profile.get(); // GET /users/123/profile
+api.users.$get(); // GET /users
+api.users[123].$get(); // GET /users/123
+api.users[123].profile.$get(); // GET /users/123/profile
 ```
 
 ### Endpoint Types
@@ -124,8 +124,8 @@ type ApiSchema = {
 };
 
 // Usage - query params are fully typed
-const { data } = useAPI((api) => api.users.get({ query: { page: 1, limit: 10 } }));
-// api.users.get({ query: { foo: "bar" } }); // ✗ Error: 'foo' does not exist
+const { data } = useAPI((api) => api.users.$get({ query: { page: 1, limit: 10 } }));
+// api.users.$get({ query: { foo: "bar" } }); // ✗ Error: 'foo' does not exist
 ```
 
 #### `EndpointWithFormData<TData, TFormData, TError?>`
@@ -145,7 +145,7 @@ type ApiSchema = {
 };
 
 // Usage - formData is automatically converted to FormData
-const { trigger } = useAPI((api) => api.uploads.post);
+const { trigger } = useAPI((api) => api.uploads.$post);
 trigger({
   formData: {
     file: selectedFile,        // File object
@@ -197,9 +197,9 @@ type ApiSchema = {
 type ApiError = { message: string; code: number };
 
 // Second generic sets default error type for all endpoints
-const api = createEnlace<ApiSchema, ApiError>("https://api.example.com");
-// const useAPI = createEnlaceHookReact<ApiSchema, ApiError>("...");
-// const useAPI = createEnlaceHookNext<ApiSchema, ApiError>("...");
+const api = enlace<ApiSchema, ApiError>("https://api.example.com");
+// const useAPI = enlaceHookReact<ApiSchema, ApiError>("...");
+// const useAPI = enlaceHookNext<ApiSchema, ApiError>("...");
 ```
 
 ## React Hooks
@@ -211,7 +211,7 @@ For GET requests that fetch data automatically:
 ```typescript
 function Posts({ page, limit }: { page: number; limit: number }) {
   const { data, loading, error } = useAPI((api) =>
-    api.posts.get({ query: { page, limit, published: true } })
+    api.posts.$get({ query: { page, limit, published: true } })
   );
 
   if (loading) return <div>Loading...</div>;
@@ -242,7 +242,7 @@ Skip fetching with the `enabled` option:
 function ProductForm({ id }: { id: string | "new" }) {
   // Skip fetching when creating a new product
   const { data, loading } = useAPI(
-    (api) => api.products[id].get(),
+    (api) => api.products[id].$get(),
     { enabled: id !== "new" }
   );
 
@@ -255,7 +255,7 @@ function ProductForm({ id }: { id: string | "new" }) {
 ```typescript
 // Also useful when waiting for a dependency
 function UserPosts({ userId }: { userId: string | undefined }) {
-  const { data } = useAPI((api) => api.users[userId!].posts.get(), {
+  const { data } = useAPI((api) => api.users[userId!].posts.$get(), {
     enabled: userId !== undefined,
   });
 }
@@ -264,11 +264,79 @@ function UserPosts({ userId }: { userId: string | undefined }) {
 ```typescript
 function Post({ id }: { id: number }) {
   // Automatically re-fetches when `id` or query values change
-  const { data } = useAPI((api) => api.posts[id].get({ query: { include: "author" } }));
+  const { data } = useAPI((api) => api.posts[id].$get({ query: { include: "author" } }));
   return <div>{data?.title}</div>;
 }
 ```
 
+### Polling
+
+Automatically refetch data at intervals using the `pollingInterval` option. Polling uses sequential timing — the interval starts counting **after** the previous request completes, preventing request pile-up:
+
+```typescript
+function Notifications() {
+  const { data } = useAPI(
+    (api) => api.notifications.$get(),
+    { pollingInterval: 5000 } // Refetch every 5 seconds after previous request completes
+  );
+
+  return <NotificationList notifications={data} />;
+}
+```
+
+**Behavior:**
+
+- Polling starts after the initial fetch completes
+- Next poll is scheduled only after the current request finishes (success or error)
+- Continues polling even on errors (retry behavior)
+- Stops when component unmounts or `enabled` becomes `false`
+- Resets when component remounts
+
+**Dynamic polling with function:**
+
+Use a function to conditionally poll based on the response data or error:
+
+```typescript
+function OrderStatus({ orderId }: { orderId: string }) {
+  const { data } = useAPI(
+    (api) => api.orders[orderId].$get(),
+    {
+      // Poll every 2s while pending, stop when completed
+      pollingInterval: (order) => order?.status === "pending" ? 2000 : false,
+    }
+  );
+
+  return <div>Status: {data?.status}</div>;
+}
+```
+
+The function receives `(data, error)` and should return:
+- `number`: Interval in milliseconds
+- `false`: Stop polling
+
+```typescript
+// Poll faster when there's an error (retry), slower otherwise
+{ pollingInterval: (data, error) => error ? 1000 : 10000 }
+
+// Stop polling once data meets a condition
+{ pollingInterval: (order) => order?.status === "completed" ? false : 3000 }
+```
+
+**Combined with conditional fetching:**
+
+```typescript
+function OrderStatus({ orderId }: { orderId: string | undefined }) {
+  const { data } = useAPI(
+    (api) => api.orders[orderId!].$get(),
+    {
+      enabled: !!orderId,
+      pollingInterval: 10000, // Poll every 10 seconds
+    }
+  );
+  // Polling only runs when orderId is defined
+}
+```
+
 ### Request Deduplication
 
 Multiple components requesting the same data will share a single network request:
@@ -276,12 +344,12 @@ Multiple components requesting the same data will share a single network request
 ```typescript
 // Both components render at the same time
 function PostTitle({ id }: { id: number }) {
-  const { data } = useAPI((api) => api.posts[id].get());
+  const { data } = useAPI((api) => api.posts[id].$get());
   return <h1>{data?.title}</h1>;
 }
 
 function PostBody({ id }: { id: number }) {
-  const { data } = useAPI((api) => api.posts[id].get());
+  const { data } = useAPI((api) => api.posts[id].$get());
   return <p>{data?.body}</p>;
 }
 
@@ -303,7 +371,7 @@ For mutations or lazy-loaded requests:
 
 ```typescript
 function DeleteButton({ id }: { id: number }) {
-  const { trigger, loading } = useAPI((api) => api.posts[id].delete);
+  const { trigger, loading } = useAPI((api) => api.posts[id].$delete);
 
   return (
     <button onClick={() => trigger()} disabled={loading}>
@@ -317,7 +385,7 @@ function DeleteButton({ id }: { id: number }) {
 
 ```typescript
 function CreatePost() {
-  const { trigger, loading, data } = useAPI((api) => api.posts.post);
+  const { trigger, loading, data } = useAPI((api) => api.posts.$post);
 
   const handleSubmit = async (title: string) => {
     const result = await trigger({ body: { title } });
@@ -337,7 +405,7 @@ Use `:paramName` syntax for dynamic IDs passed at trigger time:
 ```typescript
 function PostList({ posts }: { posts: Post[] }) {
   // Define once with :id placeholder
-  const { trigger, loading } = useAPI((api) => api.posts[":id"].delete);
+  const { trigger, loading } = useAPI((api) => api.posts[":id"].$delete);
 
   const handleDelete = (postId: number) => {
     // Pass the actual ID when triggering
@@ -363,7 +431,7 @@ function PostList({ posts }: { posts: Post[] }) {
 
 ```typescript
 const { trigger } = useAPI(
-  (api) => api.users[":userId"].posts[":postId"].delete
+  (api) => api.users[":userId"].posts[":postId"].$delete
 );
 
 trigger({ params: { userId: "1", postId: "42" } });
@@ -373,7 +441,7 @@ trigger({ params: { userId: "1", postId: "42" } });
 **With request body:**
 
 ```typescript
-const { trigger } = useAPI((api) => api.products[":id"].patch);
+const { trigger } = useAPI((api) => api.products[":id"].$patch);
 
 trigger({
   params: { id: "123" },
@@ -397,7 +465,7 @@ trigger({
 **Mutations automatically revalidate matching tags:**
 
 ```typescript
-const { trigger } = useAPI((api) => api.posts.post);
+const { trigger } = useAPI((api) => api.posts.$post);
 
 // POST /posts automatically revalidates 'posts' tag
 // All queries with 'posts' tag will refetch!
@@ -414,10 +482,10 @@ This means in most cases, **you don't need to specify any tags manually**. The c
 
 ```typescript
 // Component A: fetches posts (cached with tag 'posts')
-const { data } = useAPI((api) => api.posts.get());
+const { data } = useAPI((api) => api.posts.$get());
 
 // Component B: creates a post
-const { trigger } = useAPI((api) => api.posts.post);
+const { trigger } = useAPI((api) => api.posts.$post);
 trigger({ body: { title: "New" } });
 // → Automatically revalidates 'posts' tag
 // → Component A refetches automatically!
@@ -428,7 +496,7 @@ trigger({ body: { title: "New" } });
 Control how long cached data is considered fresh:
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>(
+const useAPI = enlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {},
   {
@@ -447,7 +515,7 @@ Override auto-generated tags when needed:
 
 ```typescript
 // Custom cache tags
-const { data } = useAPI((api) => api.posts.get({ tags: ["my-custom-tag"] }));
+const { data } = useAPI((api) => api.posts.$get({ tags: ["my-custom-tag"] }));
 
 // Custom revalidation tags
 trigger({
@@ -459,7 +527,7 @@ trigger({
 ### Disable Auto-Revalidation
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>(
+const useAPI = enlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {},
   {
@@ -472,7 +540,7 @@ const useAPI = createEnlaceHookReact<ApiSchema>(
 ## Hook Options
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>(
+const useAPI = enlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {
     // Default fetch options
@@ -493,17 +561,17 @@ Headers can be provided as a static value, sync function, or async function. Thi
 
 ```typescript
 // Static headers
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {
+const useAPI = enlaceHookReact<ApiSchema>("https://api.example.com", {
   headers: { Authorization: "Bearer token" },
 });
 
 // Sync function
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {
+const useAPI = enlaceHookReact<ApiSchema>("https://api.example.com", {
   headers: () => ({ Authorization: `Bearer ${getToken()}` }),
 });
 
 // Async function
-const useAPI = createEnlaceHookReact<ApiSchema>("https://api.example.com", {
+const useAPI = enlaceHookReact<ApiSchema>("https://api.example.com", {
   headers: async () => {
     const token = await getTokenFromStorage();
     return { Authorization: `Bearer ${token}` };
@@ -515,7 +583,7 @@ This also works for per-request headers:
 
 ```typescript
 const { data } = useAPI((api) =>
-  api.posts.get({
+  api.posts.$get({
     headers: async () => {
       const token = await refreshToken();
       return { Authorization: `Bearer ${token}` };
@@ -529,7 +597,7 @@ const { data } = useAPI((api) =>
 You can set up global `onSuccess` and `onError` callbacks that are called for every request:
 
 ```typescript
-const useAPI = createEnlaceHookReact<ApiSchema>(
+const useAPI = enlaceHookReact<ApiSchema>(
   "https://api.example.com",
   {
     headers: { Authorization: "Bearer token" },
@@ -580,12 +648,23 @@ type EnlaceErrorCallbackPayload<T> =
 
 ```typescript
 // Basic usage
-const result = useAPI((api) => api.posts.get());
+const result = useAPI((api) => api.posts.$get());
 
 // With options
 const result = useAPI(
-  (api) => api.posts.get(),
-  { enabled: true } // Skip fetching when false
+  (api) => api.posts.$get(),
+  {
+    enabled: true,        // Skip fetching when false
+    pollingInterval: 5000 // Refetch every 5s after previous request completes
+  }
+);
+
+// With dynamic polling
+const result = useAPI(
+  (api) => api.orders[id].$get(),
+  {
+    pollingInterval: (order) => order?.status === "pending" ? 2000 : false
+  }
 );
 
 type UseEnlaceQueryResult<TData, TError> = {
@@ -608,6 +687,18 @@ type UseEnlaceSelectorResult<TMethod> = {
 };
 ```
 
+### Query Options
+
+```typescript
+type UseEnlaceQueryOptions<TData, TError> = {
+  enabled?: boolean; // Skip fetching when false (default: true)
+  pollingInterval?: // Refetch interval after request completes
+    | number // Fixed interval in ms
+    | false // Disable polling
+    | ((data: TData | undefined, error: TError | undefined) => number | false); // Dynamic
+};
+```
+
 ### Request Options
 
 ```typescript
@@ -628,19 +719,19 @@ type RequestOptions = {
 
 ### Server Components
 
-Use `createEnlaceNext` from `enlace` for server components:
+Use `enlaceNext` from `enlace` for server components:
 
 ```typescript
-import { createEnlaceNext } from "enlace";
+import { enlaceNext } from "enlace";
 
 type ApiError = { message: string };
 
-const api = createEnlaceNext<ApiSchema, ApiError>("https://api.example.com", {}, {
+const api = enlaceNext<ApiSchema, ApiError>("https://api.example.com", {}, {
   autoGenerateTags: true,
 });
 
 export default async function Page() {
-  const { data } = await api.posts.get({
+  const { data } = await api.posts.$get({
     revalidate: 60, // ISR: revalidate every 60 seconds
   });
 
@@ -650,16 +741,16 @@ export default async function Page() {
 
 ### Client Components
 
-Use `createEnlaceHookNext` from `enlace/hook` for client components:
+Use `enlaceHookNext` from `enlace/hook` for client components:
 
 ```typescript
 "use client";
 
-import { createEnlaceHookNext } from "enlace/hook";
+import { enlaceHookNext } from "enlace/hook";
 
 type ApiError = { message: string };
 
-const useAPI = createEnlaceHookNext<ApiSchema, ApiError>(
+const useAPI = enlaceHookNext<ApiSchema, ApiError>(
   "https://api.example.com"
 );
 ```
@@ -686,12 +777,12 @@ export async function revalidateAction(tags: string[], paths: string[]) {
 
 ```typescript
 // useAPI.ts
-import { createEnlaceHookNext } from "enlace/hook";
+import { enlaceHookNext } from "enlace/hook";
 import { revalidateAction } from "./actions";
 
 type ApiError = { message: string };
 
-const useAPI = createEnlaceHookNext<ApiSchema, ApiError>(
+const useAPI = enlaceHookNext<ApiSchema, ApiError>(
   "/api",
   {},
   {
@@ -704,7 +795,7 @@ const useAPI = createEnlaceHookNext<ApiSchema, ApiError>(
 
 ```typescript
 function CreatePost() {
-  const { trigger } = useAPI((api) => api.posts.post);
+  const { trigger } = useAPI((api) => api.posts.$post);
 
   const handleCreate = () => {
     trigger({
@@ -721,7 +812,7 @@ function CreatePost() {
 For projects that primarily use client-side rendering with minimal SSR, you can disable server-side revalidation by default:
 
 ```typescript
-const useAPI = createEnlaceHookNext<ApiSchema, ApiError>(
+const useAPI = enlaceHookNext<ApiSchema, ApiError>(
   "/api",
   {},
   {
@@ -752,7 +843,7 @@ await trigger({ body: data, serverRevalidate: true });
 ### Next.js Request Options
 
 ```typescript
-api.posts.get({
+api.posts.$get({
   tags: ["posts"], // Next.js cache tags
   revalidate: 60, // ISR revalidation (seconds)
   revalidateTags: ["posts"], // Tags to invalidate after mutation
@@ -767,26 +858,26 @@ Works with Next.js API routes:
 
 ```typescript
 // Client component calling /api/posts
-const useAPI = createEnlaceHookNext<ApiSchema, ApiError>("/api");
+const useAPI = enlaceHookNext<ApiSchema, ApiError>("/api");
 ```
 
 ---
 
 ## API Reference
 
-### `createEnlaceHookReact<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
+### `enlaceHookReact<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
 
 Creates a React hook for making API calls.
 
-### `createEnlaceHookNext<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
+### `enlaceHookNext<TSchema, TDefaultError>(baseUrl, options?, hookOptions?)`
 
 Creates a Next.js hook with server revalidation support.
 
-### `createEnlace<TSchema, TDefaultError>(baseUrl, options?, callbacks?)`
+### `enlace<TSchema, TDefaultError>(baseUrl, options?, callbacks?)`
 
 Creates a typed API client (non-hook, for direct calls or server components).
 
-### `createEnlaceNext<TSchema, TDefaultError>(baseUrl, options?, nextOptions?)`
+### `enlaceNext<TSchema, TDefaultError>(baseUrl, options?, nextOptions?)`
 
 Creates a Next.js typed API client with caching support.
 

package/dist/hook/index.d.mts

@@ -19,14 +19,40 @@ type ReactRequestOptionsBase = {
      */
     params?: Record<string, string | number>;
 };
+/** Polling interval value: milliseconds to wait, or false to stop polling */
+type PollingIntervalValue = number | false;
+/** Function that determines polling interval based on current data/error state */
+type PollingIntervalFn<TData, TError> = (data: TData | undefined, error: TError | undefined) => PollingIntervalValue;
+/** Polling interval option: static value or dynamic function */
+type PollingInterval<TData = unknown, TError = unknown> = PollingIntervalValue | PollingIntervalFn<TData, TError>;
 /** Options for query mode hooks */
-type UseEnlaceQueryOptions = {
+type UseEnlaceQueryOptions<TData = unknown, TError = unknown> = {
     /**
      * Whether the query should execute.
      * Set to false to skip fetching (useful when ID is "new" or undefined).
      * @default true
      */
     enabled?: boolean;
+    /**
+     * Polling interval in milliseconds, or a function that returns the interval.
+     * When set, the query will refetch after this interval AFTER the previous request completes.
+     * Uses sequential polling (setTimeout after fetch completes), not interval-based.
+     *
+     * Can be:
+     * - `number`: Fixed interval in milliseconds
+     * - `false`: Disable polling
+     * - `(data, error) => number | false`: Dynamic interval based on response
+     *
+     * @example
+     * // Fixed interval
+     * { pollingInterval: 5000 }
+     *
+     * // Conditional polling based on data
+     * { pollingInterval: (order) => order?.status === 'pending' ? 2000 : false }
+     *
+     * @default undefined (no polling)
+     */
+    pollingInterval?: PollingInterval<TData, TError>;
 };
 type ApiClient<TSchema, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TDefaultError, TOptions>;
 type QueryFn<TSchema, TData, TError, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TDefaultError, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
@@ -64,7 +90,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-/** Options for createEnlaceHookReact factory */
+/** Options for enlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -81,10 +107,10 @@ type EnlaceHookOptions = {
     /** Callback called on error responses (HTTP errors or network failures) */
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
-/** Hook type returned by createEnlaceHookReact */
+/** Hook type returned by enlaceHookReact */
 type EnlaceHook<TSchema, TDefaultError = unknown> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions<TData, TError>): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -92,16 +118,16 @@ type EnlaceHook<TSchema, TDefaultError = unknown> = {
  * Called at module level to create a reusable hook.
  *
  * @example
- * const useAPI = createEnlaceHookReact<ApiSchema>('https://api.com');
+ * const useAPI = enlaceHookReact<ApiSchema>('https://api.com');
  *
  * // Query mode - auto-fetch (auto-tracks changes, no deps array needed)
- * const { loading, data, error } = useAPI((api) => api.posts.get({ query: { userId } }));
+ * const { loading, data, error } = useAPI((api) => api.posts.$get({ query: { userId } }));
  *
  * // Selector mode - typed trigger for lazy calls
- * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
+ * const { trigger, loading, data, error } = useAPI((api) => api.posts.$delete);
  * onClick={() => trigger({ body: { id: 1 } })}
  */
-declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
+declare function enlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
 
 /**
  * Handler function called after successful mutations to trigger server-side revalidation.
@@ -109,14 +135,14 @@ declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknow
  * @param paths - URL paths to revalidate
  */
 type ServerRevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlaceNext) */
+/** Next.js-specific options (third argument for enlaceNext) */
 type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
      * @example
      * ```ts
-     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     * enlaceNext("http://localhost:3000/api/", {}, {
      *   serverRevalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
@@ -130,7 +156,7 @@ type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateT
      */
     skipServerRevalidation?: boolean;
 };
-/** Next.js hook options (third argument for createEnlaceHookNext) - extends React's EnlaceHookOptions */
+/** Next.js hook options (third argument for enlaceHookNext) - extends React's EnlaceHookOptions */
 type NextHookOptions = EnlaceHookOptions & Pick<NextOptions, "serverRevalidator" | "skipServerRevalidation">;
 /** Per-request options for Next.js fetch - extends React's base options */
 type NextRequestOptionsBase = ReactRequestOptionsBase & {
@@ -151,10 +177,10 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
 };
 type NextQueryFn<TSchema, TData, TError, TDefaultError = unknown> = QueryFn<TSchema, TData, TError, TDefaultError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod, TDefaultError = unknown> = SelectorFn<TSchema, TMethod, TDefaultError, NextRequestOptionsBase>;
-/** Hook type returned by createEnlaceHookNext */
+/** Hook type returned by enlaceHookNext */
 type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions<TData, TError>): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -162,17 +188,17 @@ type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
  * Uses Next.js-specific features like serverRevalidator for server-side cache invalidation.
  *
  * @example
- * const useAPI = createEnlaceHookNext<ApiSchema>('https://api.com', {}, {
+ * const useAPI = enlaceHookNext<ApiSchema>('https://api.com', {}, {
  *   serverRevalidator: (tags) => revalidateTagsAction(tags),
  *   staleTime: 5000,
  * });
  *
  * // Query mode - auto-fetch
- * const { loading, data, error } = useAPI((api) => api.posts.get());
+ * const { loading, data, error } = useAPI((api) => api.posts.$get());
  *
  * // Selector mode - trigger for mutations
- * const { trigger } = useAPI((api) => api.posts.delete);
+ * const { trigger } = useAPI((api) => api.posts.$delete);
  */
-declare function createEnlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
+declare function enlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
 
-export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, createEnlaceHookNext, createEnlaceHookReact };
+export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type PollingInterval, type PollingIntervalFn, type PollingIntervalValue, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, enlaceHookNext, enlaceHookReact };

package/dist/hook/index.d.ts

@@ -19,14 +19,40 @@ type ReactRequestOptionsBase = {
      */
     params?: Record<string, string | number>;
 };
+/** Polling interval value: milliseconds to wait, or false to stop polling */
+type PollingIntervalValue = number | false;
+/** Function that determines polling interval based on current data/error state */
+type PollingIntervalFn<TData, TError> = (data: TData | undefined, error: TError | undefined) => PollingIntervalValue;
+/** Polling interval option: static value or dynamic function */
+type PollingInterval<TData = unknown, TError = unknown> = PollingIntervalValue | PollingIntervalFn<TData, TError>;
 /** Options for query mode hooks */
-type UseEnlaceQueryOptions = {
+type UseEnlaceQueryOptions<TData = unknown, TError = unknown> = {
     /**
      * Whether the query should execute.
      * Set to false to skip fetching (useful when ID is "new" or undefined).
      * @default true
      */
     enabled?: boolean;
+    /**
+     * Polling interval in milliseconds, or a function that returns the interval.
+     * When set, the query will refetch after this interval AFTER the previous request completes.
+     * Uses sequential polling (setTimeout after fetch completes), not interval-based.
+     *
+     * Can be:
+     * - `number`: Fixed interval in milliseconds
+     * - `false`: Disable polling
+     * - `(data, error) => number | false`: Dynamic interval based on response
+     *
+     * @example
+     * // Fixed interval
+     * { pollingInterval: 5000 }
+     *
+     * // Conditional polling based on data
+     * { pollingInterval: (order) => order?.status === 'pending' ? 2000 : false }
+     *
+     * @default undefined (no polling)
+     */
+    pollingInterval?: PollingInterval<TData, TError>;
 };
 type ApiClient<TSchema, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = unknown extends TSchema ? WildcardClient<TOptions> : EnlaceClient<TSchema, TDefaultError, TOptions>;
 type QueryFn<TSchema, TData, TError, TDefaultError = unknown, TOptions = ReactRequestOptionsBase> = (api: ApiClient<TSchema, TDefaultError, TOptions>) => Promise<EnlaceResponse<TData, TError>>;
@@ -64,7 +90,7 @@ type UseEnlaceSelectorResult<TMethod> = {
     loading: boolean;
     fetching: boolean;
 } & HookResponseState<ExtractData<TMethod>, ExtractError<TMethod>>;
-/** Options for createEnlaceHookReact factory */
+/** Options for enlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -81,10 +107,10 @@ type EnlaceHookOptions = {
     /** Callback called on error responses (HTTP errors or network failures) */
     onError?: (payload: EnlaceErrorCallbackPayload<unknown>) => void;
 };
-/** Hook type returned by createEnlaceHookReact */
+/** Hook type returned by enlaceHookReact */
 type EnlaceHook<TSchema, TDefaultError = unknown> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: SelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: QueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions<TData, TError>): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -92,16 +118,16 @@ type EnlaceHook<TSchema, TDefaultError = unknown> = {
  * Called at module level to create a reusable hook.
  *
  * @example
- * const useAPI = createEnlaceHookReact<ApiSchema>('https://api.com');
+ * const useAPI = enlaceHookReact<ApiSchema>('https://api.com');
  *
  * // Query mode - auto-fetch (auto-tracks changes, no deps array needed)
- * const { loading, data, error } = useAPI((api) => api.posts.get({ query: { userId } }));
+ * const { loading, data, error } = useAPI((api) => api.posts.$get({ query: { userId } }));
  *
  * // Selector mode - typed trigger for lazy calls
- * const { trigger, loading, data, error } = useAPI((api) => api.posts.delete);
+ * const { trigger, loading, data, error } = useAPI((api) => api.posts.$delete);
  * onClick={() => trigger({ body: { id: 1 } })}
  */
-declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
+declare function enlaceHookReact<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: EnlaceHookOptions): EnlaceHook<TSchema, TDefaultError>;
 
 /**
  * Handler function called after successful mutations to trigger server-side revalidation.
@@ -109,14 +135,14 @@ declare function createEnlaceHookReact<TSchema = unknown, TDefaultError = unknow
  * @param paths - URL paths to revalidate
  */
 type ServerRevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlaceNext) */
+/** Next.js-specific options (third argument for enlaceNext) */
 type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
      * @example
      * ```ts
-     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     * enlaceNext("http://localhost:3000/api/", {}, {
      *   serverRevalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
@@ -130,7 +156,7 @@ type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateT
      */
     skipServerRevalidation?: boolean;
 };
-/** Next.js hook options (third argument for createEnlaceHookNext) - extends React's EnlaceHookOptions */
+/** Next.js hook options (third argument for enlaceHookNext) - extends React's EnlaceHookOptions */
 type NextHookOptions = EnlaceHookOptions & Pick<NextOptions, "serverRevalidator" | "skipServerRevalidation">;
 /** Per-request options for Next.js fetch - extends React's base options */
 type NextRequestOptionsBase = ReactRequestOptionsBase & {
@@ -151,10 +177,10 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
 };
 type NextQueryFn<TSchema, TData, TError, TDefaultError = unknown> = QueryFn<TSchema, TData, TError, TDefaultError, NextRequestOptionsBase>;
 type NextSelectorFn<TSchema, TMethod, TDefaultError = unknown> = SelectorFn<TSchema, TMethod, TDefaultError, NextRequestOptionsBase>;
-/** Hook type returned by createEnlaceHookNext */
+/** Hook type returned by enlaceHookNext */
 type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
     <TMethod extends (...args: any[]) => Promise<EnlaceResponse<unknown, unknown>>>(selector: NextSelectorFn<TSchema, TMethod, TDefaultError>): UseEnlaceSelectorResult<TMethod>;
-    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions): UseEnlaceQueryResult<TData, TError>;
+    <TData, TError>(queryFn: NextQueryFn<TSchema, TData, TError, TDefaultError>, options?: UseEnlaceQueryOptions<TData, TError>): UseEnlaceQueryResult<TData, TError>;
 };
 
 /**
@@ -162,17 +188,17 @@ type NextEnlaceHook<TSchema, TDefaultError = unknown> = {
  * Uses Next.js-specific features like serverRevalidator for server-side cache invalidation.
  *
  * @example
- * const useAPI = createEnlaceHookNext<ApiSchema>('https://api.com', {}, {
+ * const useAPI = enlaceHookNext<ApiSchema>('https://api.com', {}, {
  *   serverRevalidator: (tags) => revalidateTagsAction(tags),
  *   staleTime: 5000,
  * });
  *
  * // Query mode - auto-fetch
- * const { loading, data, error } = useAPI((api) => api.posts.get());
+ * const { loading, data, error } = useAPI((api) => api.posts.$get());
  *
  * // Selector mode - trigger for mutations
- * const { trigger } = useAPI((api) => api.posts.delete);
+ * const { trigger } = useAPI((api) => api.posts.$delete);
  */
-declare function createEnlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
+declare function enlaceHookNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions, hookOptions?: NextHookOptions): NextEnlaceHook<TSchema, TDefaultError>;
 
-export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, createEnlaceHookNext, createEnlaceHookReact };
+export { type ApiClient, type EnlaceHook, type EnlaceHookOptions, HTTP_METHODS, type HookState, type NextEnlaceHook, type NextHookOptions, type PollingInterval, type PollingIntervalFn, type PollingIntervalValue, type QueryFn, type ReactRequestOptionsBase, type SelectorFn, type TrackedCall, type UseEnlaceQueryOptions, type UseEnlaceQueryResult, type UseEnlaceSelectorResult, enlaceHookNext, enlaceHookReact };

package/dist/hook/index.js

@@ -23,12 +23,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var hook_exports = {};
 __export(hook_exports, {
   HTTP_METHODS: () => HTTP_METHODS,
-  createEnlaceHookNext: () => createEnlaceHookNext,
-  createEnlaceHookReact: () => createEnlaceHookReact
+  enlaceHookNext: () => enlaceHookNext,
+  enlaceHookReact: () => enlaceHookReact
 });
 module.exports = __toCommonJS(hook_exports);
 
-// src/react/createEnlaceHookReact.ts
+// src/react/enlaceHookReact.ts
 var import_enlace_core = require("enlace-core");
 
 // src/react/useQueryMode.ts
@@ -200,7 +200,7 @@ function resolvePath(path, params) {
   });
 }
 function useQueryMode(api, trackedCall, options) {
-  const { autoGenerateTags, staleTime, enabled } = options;
+  const { autoGenerateTags, staleTime, enabled, pollingInterval } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
   const resolvedPath = resolvePath(trackedCall.path, requestOptions?.params);
@@ -225,15 +225,41 @@ function useQueryMode(api, trackedCall, options) {
   );
   const mountedRef = (0, import_react.useRef)(true);
   const fetchRef = (0, import_react.useRef)(null);
+  const pollingTimeoutRef = (0, import_react.useRef)(null);
+  const pollingIntervalRef = (0, import_react.useRef)(pollingInterval);
+  pollingIntervalRef.current = pollingInterval;
   (0, import_react.useEffect)(() => {
     mountedRef.current = true;
     if (!enabled) {
       dispatch({ type: "RESET" });
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
       return () => {
         mountedRef.current = false;
       };
     }
     dispatch({ type: "RESET", state: getCacheState(true) });
+    const scheduleNextPoll = () => {
+      const currentPollingInterval = pollingIntervalRef.current;
+      if (!mountedRef.current || !enabled || currentPollingInterval === void 0) {
+        return;
+      }
+      const cached2 = getCache(queryKey);
+      const interval = typeof currentPollingInterval === "function" ? currentPollingInterval(cached2?.data, cached2?.error) : currentPollingInterval;
+      if (interval === false || interval <= 0) {
+        return;
+      }
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+      }
+      pollingTimeoutRef.current = setTimeout(() => {
+        if (mountedRef.current && enabled && fetchRef.current) {
+          fetchRef.current();
+        }
+      }, interval);
+    };
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -259,6 +285,8 @@ function useQueryMode(api, trackedCall, options) {
           timestamp: Date.now(),
           tags: queryTags
         });
+      }).finally(() => {
+        scheduleNextPoll();
       });
       setCache(queryKey, {
         promise: fetchPromise,
@@ -269,6 +297,7 @@ function useQueryMode(api, trackedCall, options) {
     const cached = getCache(queryKey);
     if (cached?.data !== void 0 && !isStale(queryKey, staleTime)) {
       dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      scheduleNextPoll();
     } else {
       doFetch();
     }
@@ -280,6 +309,10 @@ function useQueryMode(api, trackedCall, options) {
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
       unsubscribe();
     };
   }, [queryKey, enabled]);
@@ -394,8 +427,8 @@ function useSelectorMode(config) {
   };
 }
 
-// src/react/createEnlaceHookReact.ts
-function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/react/enlaceHookReact.ts
+function enlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
@@ -403,7 +436,7 @@ function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
     onSuccess,
     onError
   } = hookOptions;
-  const api = (0, import_enlace_core.createEnlace)(baseUrl, defaultOptions, {
+  const api = (0, import_enlace_core.enlace)(baseUrl, defaultOptions, {
     onSuccess,
     onError
   });
@@ -429,13 +462,18 @@ function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
     }
     if (!trackingResult.trackedCall) {
       throw new Error(
-        "useAPI query mode requires calling an HTTP method (get, post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.get())"
+        "useAPI query mode requires calling an HTTP method ($get, $post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.$get())"
       );
     }
     return useQueryMode(
       api,
       trackingResult.trackedCall,
-      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
     );
   }
   return useEnlaceHook;
@@ -492,7 +530,7 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
 }
 
 // src/next/index.ts
-function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+function enlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
   return (0, import_enlace_core3.createProxyHandler)(
     baseUrl,
@@ -502,15 +540,15 @@ function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   );
 }
 
-// src/next/createEnlaceHookNext.ts
-function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/next/enlaceHookNext.ts
+function enlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
     staleTime = 0,
     ...nextOptions
   } = hookOptions;
-  const api = createEnlaceNext(
+  const api = enlaceNext(
     baseUrl,
     defaultOptions,
     {
@@ -541,13 +579,18 @@ function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
     }
     if (!trackedCall) {
       throw new Error(
-        "useAPI query mode requires calling an HTTP method (get, post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.get())"
+        "useAPI query mode requires calling an HTTP method ($get, $post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.$get())"
       );
     }
     return useQueryMode(
       api,
       trackedCall,
-      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
     );
   }
   return useEnlaceHook;

package/dist/hook/index.mjs

@@ -1,9 +1,9 @@
 "use client";
 "use client";
 
-// src/react/createEnlaceHookReact.ts
+// src/react/enlaceHookReact.ts
 import {
-  createEnlace
+  enlace
 } from "enlace-core";
 
 // src/react/useQueryMode.ts
@@ -175,7 +175,7 @@ function resolvePath(path, params) {
   });
 }
 function useQueryMode(api, trackedCall, options) {
-  const { autoGenerateTags, staleTime, enabled } = options;
+  const { autoGenerateTags, staleTime, enabled, pollingInterval } = options;
   const queryKey = createQueryKey(trackedCall);
   const requestOptions = trackedCall.options;
   const resolvedPath = resolvePath(trackedCall.path, requestOptions?.params);
@@ -200,15 +200,41 @@ function useQueryMode(api, trackedCall, options) {
   );
   const mountedRef = useRef(true);
   const fetchRef = useRef(null);
+  const pollingTimeoutRef = useRef(null);
+  const pollingIntervalRef = useRef(pollingInterval);
+  pollingIntervalRef.current = pollingInterval;
   useEffect(() => {
     mountedRef.current = true;
     if (!enabled) {
       dispatch({ type: "RESET" });
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
       return () => {
         mountedRef.current = false;
       };
     }
     dispatch({ type: "RESET", state: getCacheState(true) });
+    const scheduleNextPoll = () => {
+      const currentPollingInterval = pollingIntervalRef.current;
+      if (!mountedRef.current || !enabled || currentPollingInterval === void 0) {
+        return;
+      }
+      const cached2 = getCache(queryKey);
+      const interval = typeof currentPollingInterval === "function" ? currentPollingInterval(cached2?.data, cached2?.error) : currentPollingInterval;
+      if (interval === false || interval <= 0) {
+        return;
+      }
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+      }
+      pollingTimeoutRef.current = setTimeout(() => {
+        if (mountedRef.current && enabled && fetchRef.current) {
+          fetchRef.current();
+        }
+      }, interval);
+    };
     const doFetch = () => {
       const cached2 = getCache(queryKey);
       if (cached2?.promise) {
@@ -234,6 +260,8 @@ function useQueryMode(api, trackedCall, options) {
           timestamp: Date.now(),
           tags: queryTags
         });
+      }).finally(() => {
+        scheduleNextPoll();
       });
       setCache(queryKey, {
         promise: fetchPromise,
@@ -244,6 +272,7 @@ function useQueryMode(api, trackedCall, options) {
     const cached = getCache(queryKey);
     if (cached?.data !== void 0 && !isStale(queryKey, staleTime)) {
       dispatch({ type: "SYNC_CACHE", state: getCacheState() });
+      scheduleNextPoll();
     } else {
       doFetch();
     }
@@ -255,6 +284,10 @@ function useQueryMode(api, trackedCall, options) {
     return () => {
       mountedRef.current = false;
       fetchRef.current = null;
+      if (pollingTimeoutRef.current) {
+        clearTimeout(pollingTimeoutRef.current);
+        pollingTimeoutRef.current = null;
+      }
       unsubscribe();
     };
   }, [queryKey, enabled]);
@@ -369,8 +402,8 @@ function useSelectorMode(config) {
   };
 }
 
-// src/react/createEnlaceHookReact.ts
-function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/react/enlaceHookReact.ts
+function enlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
@@ -378,7 +411,7 @@ function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
     onSuccess,
     onError
   } = hookOptions;
-  const api = createEnlace(baseUrl, defaultOptions, {
+  const api = enlace(baseUrl, defaultOptions, {
     onSuccess,
     onError
   });
@@ -404,13 +437,18 @@ function createEnlaceHookReact(baseUrl, defaultOptions = {}, hookOptions = {}) {
     }
     if (!trackingResult.trackedCall) {
       throw new Error(
-        "useAPI query mode requires calling an HTTP method (get, post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.get())"
+        "useAPI query mode requires calling an HTTP method ($get, $post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.$get())"
       );
     }
     return useQueryMode(
       api,
       trackingResult.trackedCall,
-      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
     );
   }
   return useEnlaceHook;
@@ -471,7 +509,7 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
 }
 
 // src/next/index.ts
-function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+function enlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
   return createProxyHandler(
     baseUrl,
@@ -481,15 +519,15 @@ function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   );
 }
 
-// src/next/createEnlaceHookNext.ts
-function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
+// src/next/enlaceHookNext.ts
+function enlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
   const {
     autoGenerateTags = true,
     autoRevalidateTags = true,
     staleTime = 0,
     ...nextOptions
   } = hookOptions;
-  const api = createEnlaceNext(
+  const api = enlaceNext(
     baseUrl,
     defaultOptions,
     {
@@ -520,19 +558,24 @@ function createEnlaceHookNext(baseUrl, defaultOptions = {}, hookOptions = {}) {
     }
     if (!trackedCall) {
       throw new Error(
-        "useAPI query mode requires calling an HTTP method (get, post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.get())"
+        "useAPI query mode requires calling an HTTP method ($get, $post, etc.). Did you mean to use selector mode? Example: useAPI((api) => api.posts.$get())"
       );
     }
     return useQueryMode(
       api,
       trackedCall,
-      { autoGenerateTags, staleTime, enabled: queryOptions?.enabled ?? true }
+      {
+        autoGenerateTags,
+        staleTime,
+        enabled: queryOptions?.enabled ?? true,
+        pollingInterval: queryOptions?.pollingInterval
+      }
     );
   }
   return useEnlaceHook;
 }
 export {
   HTTP_METHODS,
-  createEnlaceHookNext,
-  createEnlaceHookReact
+  enlaceHookNext,
+  enlaceHookReact
 };

package/dist/index.d.mts

@@ -20,7 +20,7 @@ type ReactRequestOptionsBase = {
      */
     params?: Record<string, string | number>;
 };
-/** Options for createEnlaceHookReact factory */
+/** Options for enlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -44,14 +44,14 @@ type EnlaceHookOptions = {
  * @param paths - URL paths to revalidate
  */
 type ServerRevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlaceNext) */
+/** Next.js-specific options (third argument for enlaceNext) */
 type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
      * @example
      * ```ts
-     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     * enlaceNext("http://localhost:3000/api/", {}, {
      *   serverRevalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
@@ -83,6 +83,6 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
     serverRevalidate?: boolean;
 };
 
-declare function createEnlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
+declare function enlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
 
-export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };
+export { type NextOptions, type NextRequestOptionsBase, enlaceNext };

package/dist/index.d.ts

@@ -20,7 +20,7 @@ type ReactRequestOptionsBase = {
      */
     params?: Record<string, string | number>;
 };
-/** Options for createEnlaceHookReact factory */
+/** Options for enlaceHookReact factory */
 type EnlaceHookOptions = {
     /**
      * Auto-generate cache tags from URL path for GET requests.
@@ -44,14 +44,14 @@ type EnlaceHookOptions = {
  * @param paths - URL paths to revalidate
  */
 type ServerRevalidateHandler = (tags: string[], paths: string[]) => void | Promise<void>;
-/** Next.js-specific options (third argument for createEnlaceNext) */
+/** Next.js-specific options (third argument for enlaceNext) */
 type NextOptions = Pick<EnlaceHookOptions, "autoGenerateTags" | "autoRevalidateTags"> & EnlaceCallbacks & {
     /**
      * Handler called after successful mutations to trigger server-side revalidation.
      * Receives auto-generated or manually specified tags and paths.
      * @example
      * ```ts
-     * createEnlaceNext("http://localhost:3000/api/", {}, {
+     * enlaceNext("http://localhost:3000/api/", {}, {
      *   serverRevalidator: (tags, paths) => revalidateServerAction(tags, paths)
      * });
      * ```
@@ -83,6 +83,6 @@ type NextRequestOptionsBase = ReactRequestOptionsBase & {
     serverRevalidate?: boolean;
 };
 
-declare function createEnlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
+declare function enlaceNext<TSchema = unknown, TDefaultError = unknown>(baseUrl: string, defaultOptions?: EnlaceOptions | null, nextOptions?: NextOptions): unknown extends TSchema ? WildcardClient<NextRequestOptionsBase> : EnlaceClient<TSchema, TDefaultError, NextRequestOptionsBase>;
 
-export { type NextOptions, type NextRequestOptionsBase, createEnlaceNext };
+export { type NextOptions, type NextRequestOptionsBase, enlaceNext };

package/dist/index.js

@@ -21,7 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  createEnlaceNext: () => createEnlaceNext
+  enlaceNext: () => enlaceNext
 });
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("enlace-core"), module.exports);
@@ -84,7 +84,7 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
 }
 
 // src/next/index.ts
-function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+function enlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
   return (0, import_enlace_core2.createProxyHandler)(
     baseUrl,

package/dist/index.mjs

@@ -63,7 +63,7 @@ async function executeNextFetch(baseUrl, path, method, combinedOptions, requestO
 }
 
 // src/next/index.ts
-function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
+function enlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   const combinedOptions = { ...defaultOptions, ...nextOptions };
   return createProxyHandler(
     baseUrl,
@@ -73,5 +73,5 @@ function createEnlaceNext(baseUrl, defaultOptions = {}, nextOptions = {}) {
   );
 }
 export {
-  createEnlaceNext
+  enlaceNext
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enlace",
-  "version": "0.0.1-beta.13",
+  "version": "0.0.1-beta.15",
   "license": "MIT",
   "files": [
     "dist"
@@ -18,7 +18,7 @@
     }
   },
   "dependencies": {
-    "enlace-core": "0.0.1-beta.8"
+    "enlace-core": "0.0.1-beta.10"
   },
   "peerDependencies": {
     "react": "^19"