syncorejs 0.2.2 → 0.2.3

package/dist/_vendor/next/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","names":[],"sources":["../src/config.ts"],"sourcesContent":["const WORKER_NAME = \"syncore-worker\";\n\nfunction joinAppWorkerPath(dir: string) {\n  return `${dir.replace(/[\\\\/]$/, \"\")}/app/syncore.worker`;\n}\n\n/**\n * Wrap a Next config with the settings Syncore needs for SQL.js and worker assets.\n *\n * This enables async WebAssembly support and, for non-exported apps, adds a\n * long-lived cache header for `sql-wasm.wasm`. It also configures webpack to\n * bundle the syncore worker as a separate entry point.\n */\nexport function withSyncoreNext<TConfig extends Record<string, unknown>>(\n  config: TConfig\n): TConfig {\n  const baseConfig = config as Record<string, unknown>;\n  const isStaticExport = baseConfig.output === \"export\";\n  const headers = (baseConfig.headers ?? []) as Array<Record<string, unknown>>;\n  const userWebpack =\n    typeof baseConfig.webpack === \"function\"\n      ? (baseConfig.webpack as (\n          config: Record<string, unknown>,\n          context: unknown\n        ) => Record<string, unknown>)\n      : undefined;\n  const userHeaders =\n    typeof baseConfig.headers === \"function\"\n      ? (baseConfig.headers as () =>\n          | Array<Record<string, unknown>>\n          | Promise<Array<Record<string, unknown>>>)\n      : undefined;\n  const syncoreHeaders = {\n    source: \"/sql-wasm.wasm\",\n    headers: [\n      {\n        key: \"Cache-Control\",\n        value: \"public, max-age=31536000, immutable\"\n      }\n    ]\n  };\n\n  const nextConfig: Record<string, unknown> = {\n    ...config,\n    webpack(currentConfig: Record<string, unknown>, context: unknown) {\n      const nextConfig = { ...currentConfig };\n      const experiments = (nextConfig.experiments ?? {}) as Record<\n        string,\n        unknown\n      >;\n      nextConfig.experiments = {\n        ...experiments,\n        asyncWebAssembly: true\n      };\n\n      type WebpackContext = {\n        dev?: boolean;\n        isServer: boolean;\n        nextRuntime?: string;\n        dir: string;\n      };\n      const ctx = context as WebpackContext | undefined;\n      if (\n        isStaticExport &&\n        ctx &&\n        !ctx.dev &&\n        !ctx.isServer &&\n        ctx.nextRuntime !== \"edge\"\n      ) {\n        const entry =\n          (nextConfig.entry as () => Promise<Record<string, unknown>>) ??\n          (async () => ({}));\n        const workerPath = joinAppWorkerPath(ctx.dir);\n        nextConfig.entry = async () => {\n          const entries = await entry();\n          return {\n            ...entries,\n            [WORKER_NAME]: {\n              import: workerPath,\n              filename: \"static/chunks/[name].js\"\n            }\n          };\n        };\n      }\n\n      if (userWebpack) {\n        return userWebpack(nextConfig, context);\n      }\n\n      return nextConfig;\n    }\n  };\n\n  if (!isStaticExport || userHeaders) {\n    nextConfig.headers = async () => {\n      const resolvedHeaders = userHeaders ? await userHeaders() : headers;\n      return isStaticExport\n        ? resolvedHeaders\n        : [...resolvedHeaders, syncoreHeaders];\n    };\n  }\n\n  return nextConfig as TConfig;\n}\n\nexport function getSyncoreWorkerUrl(): string {\n  return `/_next/static/chunks/${WORKER_NAME}.js`;\n}\n\n/**\n * Create the default worker URL used by the Next integration.\n */\nexport function createSyncoreNextWorkerUrl(\n  relativePath = \"./syncore.worker.js\"\n) {\n  return new URL(relativePath, import.meta.url);\n}\n"],"mappings":";AAAA,MAAM,cAAc;AAEpB,SAAS,kBAAkB,KAAa;AACtC,QAAO,GAAG,IAAI,QAAQ,UAAU,GAAG,CAAC;;;;;;;;;AAUtC,SAAgB,gBACd,QACS;CACT,MAAM,aAAa;CACnB,MAAM,iBAAiB,WAAW,WAAW;CAC7C,MAAM,UAAW,WAAW,WAAW,EAAE;CACzC,MAAM,cACJ,OAAO,WAAW,YAAY,aACzB,WAAW,UAIZ,KAAA;CACN,MAAM,cACJ,OAAO,WAAW,YAAY,aACzB,WAAW,UAGZ,KAAA;CACN,MAAM,iBAAiB;EACrB,QAAQ;EACR,SAAS,CACP;GACE,KAAK;GACL,OAAO;GACR,CACF;EACF;CAED,MAAM,aAAsC;EAC1C,GAAG;EACH,QAAQ,eAAwC,SAAkB;GAChE,MAAM,aAAa,EAAE,GAAG,eAAe;AAKvC,cAAW,cAAc;IACvB,GALmB,WAAW,eAAe,EAAE;IAM/C,kBAAkB;IACnB;GAQD,MAAM,MAAM;AACZ,OACE,kBACA,OACA,CAAC,IAAI,OACL,CAAC,IAAI,YACL,IAAI,gBAAgB,QACpB;IACA,MAAM,QACH,WAAW,UACX,aAAa,EAAE;IAClB,MAAM,aAAa,kBAAkB,IAAI,IAAI;AAC7C,eAAW,QAAQ,YAAY;AAE7B,YAAO;MACL,GAFc,MAAM,OAAO;OAG1B,cAAc;OACb,QAAQ;OACR,UAAU;OACX;MACF;;;AAIL,OAAI,YACF,QAAO,YAAY,YAAY,QAAQ;AAGzC,UAAO;;EAEV;AAED,KAAI,CAAC,kBAAkB,YACrB,YAAW,UAAU,YAAY;EAC/B,MAAM,kBAAkB,cAAc,MAAM,aAAa,GAAG;AAC5D,SAAO,iBACH,kBACA,CAAC,GAAG,iBAAiB,eAAe;;AAI5C,QAAO;;AAGT,SAAgB,sBAA8B;AAC5C,QAAO,wBAAwB,YAAY;;;;;AAM7C,SAAgB,2BACd,eAAe,uBACf;AACA,QAAO,IAAI,IAAI,cAAc,OAAO,KAAK,IAAI"}
+{"version":3,"file":"config.js","names":[],"sources":["../src/config.ts"],"sourcesContent":["const WORKER_NAME = \"syncore-worker\";\n\nfunction joinAppWorkerPath(dir: string) {\n  return `${dir.replace(/[\\\\/]$/, \"\")}/app/syncore.worker`;\n}\n\n/**\n * Wrap a Next config with the settings Syncore needs for worker assets.\n *\n * This enables async WebAssembly support and configures webpack to bundle the\n * syncore worker as a separate entry point.\n */\nexport function withSyncoreNext<TConfig extends Record<string, unknown>>(\n  config: TConfig\n): TConfig {\n  const baseConfig = config as Record<string, unknown>;\n  const isStaticExport = baseConfig.output === \"export\";\n  const userWebpack =\n    typeof baseConfig.webpack === \"function\"\n      ? (baseConfig.webpack as (\n          config: Record<string, unknown>,\n          context: unknown\n        ) => Record<string, unknown>)\n      : undefined;\n  const userTranspilePackages = Array.isArray(baseConfig.transpilePackages)\n    ? baseConfig.transpilePackages\n    : [];\n  const internalScope = `${String.fromCharCode(64)}syncore/`;\n  const syncoreTranspilePackages = [\n    \"syncorejs\",\n    `${internalScope}core`,\n    `${internalScope}schema`,\n    `${internalScope}react`,\n    `${internalScope}platform-web`,\n    `${internalScope}next`\n  ];\n\n  const nextConfig: Record<string, unknown> = {\n    ...config,\n    transpilePackages: Array.from(\n      new Set([...userTranspilePackages, ...syncoreTranspilePackages])\n    ),\n    webpack(currentConfig: Record<string, unknown>, context: unknown) {\n      const nextConfig = { ...currentConfig };\n      const experiments = (nextConfig.experiments ?? {}) as Record<\n        string,\n        unknown\n      >;\n      nextConfig.experiments = {\n        ...experiments,\n        asyncWebAssembly: true\n      };\n      const resolve = (nextConfig.resolve ?? {}) as Record<string, unknown>;\n      nextConfig.resolve = {\n        ...resolve,\n        extensionAlias: {\n          ...((resolve.extensionAlias ?? {}) as Record<string, unknown>),\n          \".js\": [\".ts\", \".tsx\", \".js\"],\n          \".mjs\": [\".mts\", \".mjs\"]\n        }\n      };\n      const moduleConfig = (nextConfig.module ?? {}) as Record<string, unknown>;\n      const rules = Array.isArray(moduleConfig.rules) ? moduleConfig.rules : [];\n      nextConfig.module = {\n        ...moduleConfig,\n        rules: [\n          {\n            test: /\\.wasm$/,\n            type: \"asset/resource\"\n          },\n          ...rules\n        ]\n      };\n\n      type WebpackContext = {\n        dev?: boolean;\n        isServer: boolean;\n        nextRuntime?: string;\n        dir: string;\n      };\n      const ctx = context as WebpackContext | undefined;\n      if (\n        isStaticExport &&\n        ctx &&\n        !ctx.dev &&\n        !ctx.isServer &&\n        ctx.nextRuntime !== \"edge\"\n      ) {\n        const entry =\n          (nextConfig.entry as () => Promise<Record<string, unknown>>) ??\n          (async () => ({}));\n        const workerPath = joinAppWorkerPath(ctx.dir);\n        nextConfig.entry = async () => {\n          const entries = await entry();\n          return {\n            ...entries,\n            [WORKER_NAME]: {\n              import: workerPath,\n              filename: \"static/chunks/[name].js\"\n            }\n          };\n        };\n      }\n\n      if (userWebpack) {\n        return userWebpack(nextConfig, context);\n      }\n\n      return nextConfig;\n    }\n  };\n\n  return nextConfig as TConfig;\n}\n\nexport function getSyncoreWorkerUrl(): string {\n  return `/_next/static/chunks/${WORKER_NAME}.js`;\n}\n\n/**\n * Create the default worker URL used by the Next integration.\n */\nexport function createSyncoreNextWorkerUrl(\n  relativePath = \"./syncore.worker.js\"\n) {\n  return new URL(relativePath, import.meta.url);\n}\n"],"mappings":";AAAA,MAAM,cAAc;AAEpB,SAAS,kBAAkB,KAAa;CACtC,OAAO,GAAG,IAAI,QAAQ,UAAU,EAAE,EAAE;AACtC;;;;;;;AAQA,SAAgB,gBACd,QACS;CACT,MAAM,aAAa;CACnB,MAAM,iBAAiB,WAAW,WAAW;CAC7C,MAAM,cACJ,OAAO,WAAW,YAAY,aACzB,WAAW,UAIZ,KAAA;CACN,MAAM,wBAAwB,MAAM,QAAQ,WAAW,iBAAiB,IACpE,WAAW,oBACX,CAAC;CACL,MAAM,gBAAgB,GAAG,OAAO,aAAa,EAAE,EAAE;CACjD,MAAM,2BAA2B;EAC/B;EACA,GAAG,cAAc;EACjB,GAAG,cAAc;EACjB,GAAG,cAAc;EACjB,GAAG,cAAc;EACjB,GAAG,cAAc;CACnB;CA6EA,OAAO;EA1EL,GAAG;EACH,mBAAmB,MAAM,KACvB,IAAI,IAAI,CAAC,GAAG,uBAAuB,GAAG,wBAAwB,CAAC,CACjE;EACA,QAAQ,eAAwC,SAAkB;GAChE,MAAM,aAAa,EAAE,GAAG,cAAc;GAKtC,WAAW,cAAc;IACvB,GALmB,WAAW,eAAe,CAAC;IAM9C,kBAAkB;GACpB;GACA,MAAM,UAAW,WAAW,WAAW,CAAC;GACxC,WAAW,UAAU;IACnB,GAAG;IACH,gBAAgB;KACd,GAAK,QAAQ,kBAAkB,CAAC;KAChC,OAAO;MAAC;MAAO;MAAQ;KAAK;KAC5B,QAAQ,CAAC,QAAQ,MAAM;IACzB;GACF;GACA,MAAM,eAAgB,WAAW,UAAU,CAAC;GAC5C,MAAM,QAAQ,MAAM,QAAQ,aAAa,KAAK,IAAI,aAAa,QAAQ,CAAC;GACxE,WAAW,SAAS;IAClB,GAAG;IACH,OAAO,CACL;KACE,MAAM;KACN,MAAM;IACR,GACA,GAAG,KACL;GACF;GAQA,MAAM,MAAM;GACZ,IACE,kBACA,OACA,CAAC,IAAI,OACL,CAAC,IAAI,YACL,IAAI,gBAAgB,QACpB;IACA,MAAM,QACH,WAAW,UACX,aAAa,CAAC;IACjB,MAAM,aAAa,kBAAkB,IAAI,GAAG;IAC5C,WAAW,QAAQ,YAAY;KAE7B,OAAO;MACL,GAAG,MAFiB,MAAM;OAGzB,cAAc;OACb,QAAQ;OACR,UAAU;MACZ;KACF;IACF;GACF;GAEA,IAAI,aACF,OAAO,YAAY,YAAY,OAAO;GAGxC,OAAO;EACT;CAGc;AAClB;AAEA,SAAgB,sBAA8B;CAC5C,OAAO,wBAAwB,YAAY;AAC7C;;;;AAKA,SAAgB,2BACd,eAAe,uBACf;CACA,OAAO,IAAI,IAAI,cAAc,OAAO,KAAK,GAAG;AAC9C"}

package/dist/_vendor/next/index.d.ts

@@ -1,63 +1,141 @@
 import { createSyncoreNextWorkerUrl, getSyncoreWorkerUrl } from "./config.js";
 import { ManagedWebWorkerClient } from "../platform-web/index.d.ts";
 import { ReactNode } from "react";
-import * as react_jsx_runtime0 from "react/jsx-runtime";
 
 //#region src/index.d.ts
+/**
+ * Shared configuration options for the Syncore Next.js integration.
+ *
+ * Accepted by both {@link SyncoreNextProvider} and
+ * {@link registerSyncoreServiceWorker}.
+ */
 interface SyncoreNextOptions {
-  /** Optional service worker URL used to cache the application shell. */
+  /**
+   * URL of the Next PWA service worker. Defaults to `"/sw.js"` (the path
+   * emitted by `next-pwa` or `@ducanh2912/next-pwa`).
+   */
   serviceWorkerUrl?: string;
-  /** Optional URL for the `sql.js` wasm asset. */
-  wasmAssetUrl?: string;
-  /** Optional URL for the worker asset used by the local Syncore runtime. */
+  /**
+   * Public path to the compiled Syncore worker asset. Defaults to
+   * `"/syncore.worker.js"`. Override if your build tool emits the worker to a
+   * different path.
+   */
   workerAssetUrl?: string;
 }
 /**
- * The result of registering the Syncore service worker in a Next app.
+ * Handle returned by {@link registerSyncoreServiceWorker}.
  */
 interface SyncoreServiceWorkerRegistration {
   /** Unregister the installed service worker. */
   unregister(): Promise<boolean>;
-  /** Ask the browser to check for an updated service worker. */
+  /**
+   * Instruct the browser to check for a new service worker version. Useful
+   * for implementing an “Update available” prompt.
+   */
   update(): Promise<ServiceWorkerRegistration>;
 }
 /**
- * Register the Syncore service worker used by the Next integration.
+ * Register the Syncore PWA service worker in a Next.js app.
+ *
+ * Call this once at app startup (e.g. in your root layout’s `useEffect`, or in
+ * `instrumentation.ts` with `"use client"`). Returns `null` on the server or
+ * when the browser does not support service workers.
+ *
+ * ```ts
+ * // app/layout.tsx (client component)
+ * import { registerSyncoreServiceWorker } from "syncorejs/next";
+ *
+ * useEffect(() => {
+ *   registerSyncoreServiceWorker({ serviceWorkerUrl: "/sw.js" });
+ * }, []);
+ * ```
+ *
+ * @param options - Optional configuration. Defaults to `"/sw.js"`.
+ * @returns A {@link SyncoreServiceWorkerRegistration} handle, or `null` on
+ *   the server / when unsupported.
  */
 declare function registerSyncoreServiceWorker(options?: SyncoreNextOptions): Promise<SyncoreServiceWorkerRegistration | null>;
 /**
- * Resolve the public URL used by SQL.js to load its wasm file in a Next app.
- */
-declare function resolveSqlJsWasmUrl(options?: SyncoreNextOptions): string;
-/**
- * Create a worker-backed Syncore client for a Next app.
+ * Create a worker-backed Syncore client for a Next.js app.
+ *
+ * The client communicates with a Syncore runtime running inside a `Worker`.
+ * The worker runs the SQLite engine and all function handlers off the main
+ * thread so the UI stays responsive.
+ *
+ * In most cases you should use {@link SyncoreNextProvider} instead, which
+ * manages the client lifecycle automatically. Use `createNextSyncoreClient`
+ * directly only when you need to control the client lifecycle yourself (e.g.
+ * in testing harnesses or custom providers).
+ *
+ * ```ts
+ * const managedClient = createNextSyncoreClient({
+ *   workerAssetUrl: "/syncore.worker.js",
+ * });
+ *
+ * // Later:
+ * managedClient.dispose();
+ * ```
  */
 declare function createNextSyncoreClient(options: {
   /**
-   * Optional custom worker factory for tests or framework-specific worker
-   * bundling patterns such as Next App Router development.
+   * Custom worker factory function. Useful in tests (supply a `Worker` backed
+   * by a mock or in-process runtime) or when using Next’s App Router dev-mode
+   * bundling where `new Worker(new URL(...))` must be used inside the component.
    */
-  createWorker?: () => Worker; /** Optional explicit module URL for an already-public worker asset. */
-  workerUrl?: URL | string; /** Optional public worker asset path for production builds. */
+  createWorker?: () => Worker; /** Explicit module URL for an already-public worker script. */
+  workerUrl?: URL | string; /** Public asset path for the compiled worker file. Defaults to `"/syncore.worker.js"`. */
   workerAssetUrl?: string;
 }): ManagedWebWorkerClient;
 /**
- * Register a service worker while rendering a React subtree.
+ * React component that registers a PWA service worker as a side-effect.
+ *
+ * Renders its `children` immediately (no loading state) and registers the
+ * service worker asynchronously. Safe to render on the server — the
+ * registration effect only runs in browsers that support service workers.
+ *
+ * ```tsx
+ * <SyncoreServiceWorker serviceWorkerUrl="/sw.js" onRegistered={console.log}>
+ *   <App />
+ * </SyncoreServiceWorker>
+ * ```
  */
 declare function SyncoreServiceWorker({
   children,
   serviceWorkerUrl,
   onRegistered
 }: {
-  children: ReactNode;
-  serviceWorkerUrl?: string;
+  children: ReactNode; /** URL of the service worker script. Defaults to `"/sw.js"`. */
+  serviceWorkerUrl?: string; /** Called after the service worker is successfully registered. */
   onRegistered?: (registration: ServiceWorkerRegistration) => void;
 }): ReactNode;
 /**
- * Provides a worker-backed Syncore client to a Next React tree.
+ * Root provider that wires a worker-backed Syncore runtime into a Next.js
+ * React tree.
+ *
+ * Place this at the top of your App Router layout. It spawns the Syncore
+ * worker on mount, exposes the client via React context (accessible with
+ * `useSyncore()`), and optionally registers the PWA service worker.
+ *
+ * ```tsx
+ * // app/layout.tsx
+ * import { SyncoreNextProvider } from "syncorejs/next";
  *
- * This is the shortest recommended integration for App Router pages that run
- * fully local in the browser.
+ * export default function RootLayout({ children }) {
+ *   return (
+ *     <html>
+ *       <body>
+ *         <SyncoreNextProvider
+ *           createWorker={() => new Worker(
+ *             new URL("../syncore.worker.ts", import.meta.url)
+ *           )}
+ *         >
+ *           {children}
+ *         </SyncoreNextProvider>
+ *       </body>
+ *     </html>
+ *   );
+ * }
+ * ```
  */
 declare function SyncoreNextProvider({
   children,
@@ -68,13 +146,15 @@ declare function SyncoreNextProvider({
 }: {
   /** The React subtree that should receive the Syncore client. */children: ReactNode;
   /**
-   * Optional custom worker factory for tests or Next colocated worker modules.
+   * Factory function that creates the Syncore `Worker`. Required in Next App
+   * Router dev mode because `new Worker(new URL(..., import.meta.url))` must
+   * be called inside the module to be bundled correctly.
    */
-  createWorker?: () => Worker; /** Optional service worker URL used to cache the application shell. */
-  serviceWorkerUrl?: string; /** Optional explicit module URL for an already-public worker asset. */
-  workerUrl?: URL | string; /** Optional public worker asset path for production builds. */
+  createWorker?: () => Worker; /** URL of the PWA service worker script. Omit to skip service worker registration. */
+  serviceWorkerUrl?: string; /** Explicit module URL for an already-public worker asset. */
+  workerUrl?: URL | string; /** Public asset path for the compiled worker file. Defaults to `"/syncore.worker.js"`. */
   workerAssetUrl?: string;
-}): react_jsx_runtime0.JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 //#endregion
-export { SyncoreNextOptions, SyncoreNextProvider, SyncoreServiceWorker, SyncoreServiceWorkerRegistration, createNextSyncoreClient, createSyncoreNextWorkerUrl, getSyncoreWorkerUrl, registerSyncoreServiceWorker, resolveSqlJsWasmUrl };
+export { SyncoreNextOptions, SyncoreNextProvider, SyncoreServiceWorker, SyncoreServiceWorkerRegistration, createNextSyncoreClient, createSyncoreNextWorkerUrl, getSyncoreWorkerUrl, registerSyncoreServiceWorker };
 //# sourceMappingURL=index.d.ts.map

package/dist/_vendor/next/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;;;;;UAsBiB,kBAAA;;EAEf,gBAAA;EAFiC;EAKjC,YAAA;EALiC;EAQjC,cAAA;AAAA;;;;UAMe,gCAAA;EAAgC;EAE/C,UAAA,IAAc,OAAA;EAAA;EAGd,MAAA,IAAU,OAAA,CAAQ,yBAAA;AAAA;;;;iBAME,4BAAA,CACpB,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,gCAAA;;;;iBAkBK,mBAAA,CAAoB,OAAA,GAAU,kBAAA;;AApB9C;;iBA2BgB,uBAAA,CAAwB,OAAA;EA1B5B;;;;EA+BV,YAAA,SAAqB,MAAA,EA/BX;EAkCV,SAAA,GAAY,GAAA,WAjCX;EAoCD,cAAA;AAAA,IACE,sBAAA;;AAnBJ;;iBAmCgB,oBAAA,CAAA;EACd,QAAA;EACA,gBAAA;EACA;AAAA;EAEA,QAAA,EAAU,SAAA;EACV,gBAAA;EACA,YAAA,IAAgB,YAAA,EAAc,yBAAA;AAAA,IAC/B,SAAA;;;;;;;iBAsBe,mBAAA,CAAA;EACd,QAAA;EACA,YAAA;EACA,gBAAA;EACA,SAAA;EACA;AAAA;EA1DqB,gEA6DrB,QAAA,EAAU,SAAA;EA1DE;;;EA+DZ,YAAA,SAAqB,MAAA,EA3DG;EA8DxB,gBAAA,WA9Cc;EAiDd,SAAA,GAAY,GAAA;EAGZ,cAAA;AAAA,IACD,kBAAA,CAAA,GAAA,CAAA,OAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.tsx"],"mappings":";;;;;;AA4BA;;;;AAYgB;UAZC,kBAAA;EAkBgC;;;;EAb/C,gBAAA;EAqBiB;;;;;EAdjB,cAAc;AAAA;;AAc6B;AAuB7C;UA/BiB,gCAAA;;EAEf,UAAA,IAAc,OAAA;EA+BL;;;;EAzBT,MAAA,IAAU,OAAA,CAAQ,yBAAA;AAAA;;;;AAyBuB;AAoC3C;;;;;;;;;;;;;;;;iBAtCsB,4BAAA,CACpB,OAAA,GAAU,kBAAA,GACT,OAAA,CAAQ,gCAAA;AA2EX;;;;;;;;;;;;;;;;;;;;;AAAA,iBAvCgB,uBAAA,CAAwB,OAAA;EAgDtB;;;AACjB;AA6CD;EAxFE,YAAA,SAAqB,MAAA;EAGrB,SAAA,GAAY,GAAA,WAuFZ;EApFA,cAAA;AAAA,IACE,sBAAA;;;;;;;;;;;;;;iBA0BY,oBAAA,CAAA;EACd,QAAA;EACA,gBAAA;EACA;AAAA;EAEA,QAAA,EAAU,SAAA,EAuDV;EArDA,gBAAA,WAwDU;EAtDV,YAAA,IAAgB,YAAA,EAAc,yBAAA;AAAA,IAC/B,SAAA;;;;;;;;AAsEA;;;;;;;;;;;;;;;;;;;;;;iBAzBe,mBAAA,CAAA;EACd,QAAA;EACA,YAAA;EACA,gBAAA;EACA,SAAA;EACA;AAAA;kEAGA,QAAA,EAAU,SAAA;;;;;;EAOV,YAAA,SAAqB,MAAA;EAGrB,gBAAA;EAGA,SAAA,GAAY,GAAA;EAGZ,cAAA;AAAA,gCACD,GAAA,CAAA,OAAA"}

package/dist/_vendor/next/index.js

@@ -6,7 +6,24 @@ import { useEffect, useMemo, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/index.tsx
 /**
-* Register the Syncore service worker used by the Next integration.
+* Register the Syncore PWA service worker in a Next.js app.
+*
+* Call this once at app startup (e.g. in your root layout’s `useEffect`, or in
+* `instrumentation.ts` with `"use client"`). Returns `null` on the server or
+* when the browser does not support service workers.
+*
+* ```ts
+* // app/layout.tsx (client component)
+* import { registerSyncoreServiceWorker } from "syncorejs/next";
+*
+* useEffect(() => {
+*   registerSyncoreServiceWorker({ serviceWorkerUrl: "/sw.js" });
+* }, []);
+* ```
+*
+* @param options - Optional configuration. Defaults to `"/sw.js"`.
+* @returns A {@link SyncoreServiceWorkerRegistration} handle, or `null` on
+*   the server / when unsupported.
 */
 async function registerSyncoreServiceWorker(options) {
 	if (typeof window === "undefined" || !("serviceWorker" in navigator)) return null;
@@ -17,20 +34,42 @@ async function registerSyncoreServiceWorker(options) {
 	};
 }
 /**
-* Resolve the public URL used by SQL.js to load its wasm file in a Next app.
-*/
-function resolveSqlJsWasmUrl(options) {
-	return options?.wasmAssetUrl ?? "/sql-wasm.wasm";
-}
-/**
-* Create a worker-backed Syncore client for a Next app.
+* Create a worker-backed Syncore client for a Next.js app.
+*
+* The client communicates with a Syncore runtime running inside a `Worker`.
+* The worker runs the SQLite engine and all function handlers off the main
+* thread so the UI stays responsive.
+*
+* In most cases you should use {@link SyncoreNextProvider} instead, which
+* manages the client lifecycle automatically. Use `createNextSyncoreClient`
+* directly only when you need to control the client lifecycle yourself (e.g.
+* in testing harnesses or custom providers).
+*
+* ```ts
+* const managedClient = createNextSyncoreClient({
+*   workerAssetUrl: "/syncore.worker.js",
+* });
+*
+* // Later:
+* managedClient.dispose();
+* ```
 */
 function createNextSyncoreClient(options) {
 	if (options.createWorker) return createManagedWebWorkerClient({ createWorker: options.createWorker });
 	return createSyncoreWebWorkerClient({ workerUrl: options.workerUrl ?? options.workerAssetUrl ?? "/syncore.worker.js" });
 }
 /**
-* Register a service worker while rendering a React subtree.
+* React component that registers a PWA service worker as a side-effect.
+*
+* Renders its `children` immediately (no loading state) and registers the
+* service worker asynchronously. Safe to render on the server — the
+* registration effect only runs in browsers that support service workers.
+*
+* ```tsx
+* <SyncoreServiceWorker serviceWorkerUrl="/sw.js" onRegistered={console.log}>
+*   <App />
+* </SyncoreServiceWorker>
+* ```
 */
 function SyncoreServiceWorker({ children, serviceWorkerUrl, onRegistered }) {
 	useEffect(() => {
@@ -43,10 +82,33 @@ function SyncoreServiceWorker({ children, serviceWorkerUrl, onRegistered }) {
 	return children;
 }
 /**
-* Provides a worker-backed Syncore client to a Next React tree.
+* Root provider that wires a worker-backed Syncore runtime into a Next.js
+* React tree.
+*
+* Place this at the top of your App Router layout. It spawns the Syncore
+* worker on mount, exposes the client via React context (accessible with
+* `useSyncore()`), and optionally registers the PWA service worker.
+*
+* ```tsx
+* // app/layout.tsx
+* import { SyncoreNextProvider } from "syncorejs/next";
 *
-* This is the shortest recommended integration for App Router pages that run
-* fully local in the browser.
+* export default function RootLayout({ children }) {
+*   return (
+*     <html>
+*       <body>
+*         <SyncoreNextProvider
+*           createWorker={() => new Worker(
+*             new URL("../syncore.worker.ts", import.meta.url)
+*           )}
+*         >
+*           {children}
+*         </SyncoreNextProvider>
+*       </body>
+*     </html>
+*   );
+* }
+* ```
 */
 function SyncoreNextProvider({ children, createWorker, serviceWorkerUrl, workerUrl, workerAssetUrl }) {
 	const createWorkerRef = useRef(createWorker);
@@ -58,7 +120,6 @@ function SyncoreNextProvider({ children, createWorker, serviceWorkerUrl, workerU
 	}), []);
 	const [client, setClient] = useState(bootingClient);
 	useEffect(() => {
-		let disposed = false;
 		let managedClient;
 		setClient(bootingClient);
 		try {
@@ -68,16 +129,15 @@ function SyncoreNextProvider({ children, createWorker, serviceWorkerUrl, workerU
 				...resolvedWorkerUrl ? { workerUrl: process.env.NODE_ENV === "production" ? getSyncoreWorkerUrl() : resolvedWorkerUrl } : {},
 				...workerAssetUrl ? { workerAssetUrl } : {}
 			});
-			if (!disposed) setClient(managedClient.client);
+			setClient(managedClient.client);
 		} catch (error) {
-			if (!disposed) setClient(createUnavailableSyncoreClient({
+			setClient(createUnavailableSyncoreClient({
 				kind: "unavailable",
 				reason: "worker-unavailable",
 				...error instanceof Error ? { error } : {}
 			}));
 		}
 		return () => {
-			disposed = true;
 			managedClient?.dispose();
 		};
 	}, [
@@ -94,6 +154,6 @@ function SyncoreNextProvider({ children, createWorker, serviceWorkerUrl, workerU
 	});
 }
 //#endregion
-export { SyncoreNextProvider, SyncoreServiceWorker, createNextSyncoreClient, createSyncoreNextWorkerUrl, getSyncoreWorkerUrl, registerSyncoreServiceWorker, resolveSqlJsWasmUrl };
+export { SyncoreNextProvider, SyncoreServiceWorker, createNextSyncoreClient, createSyncoreNextWorkerUrl, getSyncoreWorkerUrl, registerSyncoreServiceWorker };
 
 //# sourceMappingURL=index.js.map

package/dist/_vendor/next/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/index.tsx"],"sourcesContent":["import {\n  createUnavailableSyncoreClient,\n  type SyncoreClient\n} from \"@syncore/core\";\nimport {\n  createManagedWebWorkerClient,\n  createSyncoreWebWorkerClient,\n  type ManagedWebWorkerClient\n} from \"@syncore/platform-web\";\nimport { SyncoreProvider } from \"@syncore/react\";\nimport {\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type ReactNode\n} from \"react\";\nimport { getSyncoreWorkerUrl } from \"./config.js\";\n\nexport { getSyncoreWorkerUrl } from \"./config.js\";\nexport { createSyncoreNextWorkerUrl } from \"./config.js\";\n\nexport interface SyncoreNextOptions {\n  /** Optional service worker URL used to cache the application shell. */\n  serviceWorkerUrl?: string;\n\n  /** Optional URL for the `sql.js` wasm asset. */\n  wasmAssetUrl?: string;\n\n  /** Optional URL for the worker asset used by the local Syncore runtime. */\n  workerAssetUrl?: string;\n}\n\n/**\n * The result of registering the Syncore service worker in a Next app.\n */\nexport interface SyncoreServiceWorkerRegistration {\n  /** Unregister the installed service worker. */\n  unregister(): Promise<boolean>;\n\n  /** Ask the browser to check for an updated service worker. */\n  update(): Promise<ServiceWorkerRegistration>;\n}\n\n/**\n * Register the Syncore service worker used by the Next integration.\n */\nexport async function registerSyncoreServiceWorker(\n  options?: SyncoreNextOptions\n): Promise<SyncoreServiceWorkerRegistration | null> {\n  if (typeof window === \"undefined\" || !(\"serviceWorker\" in navigator)) {\n    return null;\n  }\n\n  const registration = await navigator.serviceWorker.register(\n    options?.serviceWorkerUrl ?? \"/sw.js\"\n  );\n\n  return {\n    unregister: () => registration.unregister(),\n    update: () => registration.update()\n  };\n}\n\n/**\n * Resolve the public URL used by SQL.js to load its wasm file in a Next app.\n */\nexport function resolveSqlJsWasmUrl(options?: SyncoreNextOptions): string {\n  return options?.wasmAssetUrl ?? \"/sql-wasm.wasm\";\n}\n\n/**\n * Create a worker-backed Syncore client for a Next app.\n */\nexport function createNextSyncoreClient(options: {\n  /**\n   * Optional custom worker factory for tests or framework-specific worker\n   * bundling patterns such as Next App Router development.\n   */\n  createWorker?: () => Worker;\n\n  /** Optional explicit module URL for an already-public worker asset. */\n  workerUrl?: URL | string;\n\n  /** Optional public worker asset path for production builds. */\n  workerAssetUrl?: string;\n}): ManagedWebWorkerClient {\n  if (options.createWorker) {\n    return createManagedWebWorkerClient({\n      createWorker: options.createWorker\n    });\n  }\n\n  return createSyncoreWebWorkerClient({\n    workerUrl:\n      options.workerUrl ?? options.workerAssetUrl ?? \"/syncore.worker.js\"\n  });\n}\n\n/**\n * Register a service worker while rendering a React subtree.\n */\nexport function SyncoreServiceWorker({\n  children,\n  serviceWorkerUrl,\n  onRegistered\n}: {\n  children: ReactNode;\n  serviceWorkerUrl?: string;\n  onRegistered?: (registration: ServiceWorkerRegistration) => void;\n}) {\n  useEffect(() => {\n    void (async () => {\n      if (typeof window === \"undefined\" || !(\"serviceWorker\" in navigator)) {\n        return;\n      }\n      const registration = await navigator.serviceWorker.register(\n        serviceWorkerUrl ?? \"/sw.js\"\n      );\n      onRegistered?.(registration);\n    })();\n  }, [onRegistered, serviceWorkerUrl]);\n\n  return children;\n}\n\n/**\n * Provides a worker-backed Syncore client to a Next React tree.\n *\n * This is the shortest recommended integration for App Router pages that run\n * fully local in the browser.\n */\nexport function SyncoreNextProvider({\n  children,\n  createWorker,\n  serviceWorkerUrl,\n  workerUrl,\n  workerAssetUrl\n}: {\n  /** The React subtree that should receive the Syncore client. */\n  children: ReactNode;\n\n  /**\n   * Optional custom worker factory for tests or Next colocated worker modules.\n   */\n  createWorker?: () => Worker;\n\n  /** Optional service worker URL used to cache the application shell. */\n  serviceWorkerUrl?: string;\n\n  /** Optional explicit module URL for an already-public worker asset. */\n  workerUrl?: URL | string;\n\n  /** Optional public worker asset path for production builds. */\n  workerAssetUrl?: string;\n}) {\n  const createWorkerRef = useRef(createWorker);\n  createWorkerRef.current = createWorker;\n  const resolvedWorkerUrl =\n    typeof workerUrl === \"string\" ? workerUrl : workerUrl?.toString();\n  const bootingClient = useMemo(\n    () =>\n      createUnavailableSyncoreClient({\n        kind: \"starting\",\n        reason: \"booting\"\n      }),\n    []\n  );\n  const [client, setClient] = useState<SyncoreClient>(bootingClient);\n\n  useEffect(() => {\n    let disposed = false;\n    let managedClient: ManagedWebWorkerClient | undefined;\n\n    setClient(bootingClient);\n\n    try {\n      const workerFactory = createWorkerRef.current;\n      managedClient = createNextSyncoreClient({\n        ...(workerFactory\n          ? {\n              createWorker: () => workerFactory()\n            }\n          : {}),\n        ...(resolvedWorkerUrl\n          ? {\n              workerUrl:\n                process.env.NODE_ENV === \"production\"\n                  ? getSyncoreWorkerUrl()\n                  : resolvedWorkerUrl\n            }\n          : {}),\n        ...(workerAssetUrl ? { workerAssetUrl } : {})\n      });\n      if (!disposed) {\n        setClient(managedClient.client);\n      }\n    } catch (error) {\n      if (!disposed) {\n        setClient(\n          createUnavailableSyncoreClient({\n            kind: \"unavailable\",\n            reason: \"worker-unavailable\",\n            ...(error instanceof Error ? { error } : {})\n          })\n        );\n      }\n    }\n\n    return () => {\n      disposed = true;\n      managedClient?.dispose();\n    };\n  }, [bootingClient, resolvedWorkerUrl, workerAssetUrl]);\n\n  return (\n    <SyncoreServiceWorker {...(serviceWorkerUrl ? { serviceWorkerUrl } : {})}>\n      <SyncoreProvider client={client}>{children}</SyncoreProvider>\n    </SyncoreServiceWorker>\n  );\n}\n"],"mappings":";;;;;;;;;;AA+CA,eAAsB,6BACpB,SACkD;AAClD,KAAI,OAAO,WAAW,eAAe,EAAE,mBAAmB,WACxD,QAAO;CAGT,MAAM,eAAe,MAAM,UAAU,cAAc,SACjD,SAAS,oBAAoB,SAC9B;AAED,QAAO;EACL,kBAAkB,aAAa,YAAY;EAC3C,cAAc,aAAa,QAAQ;EACpC;;;;;AAMH,SAAgB,oBAAoB,SAAsC;AACxE,QAAO,SAAS,gBAAgB;;;;;AAMlC,SAAgB,wBAAwB,SAYb;AACzB,KAAI,QAAQ,aACV,QAAO,6BAA6B,EAClC,cAAc,QAAQ,cACvB,CAAC;AAGJ,QAAO,6BAA6B,EAClC,WACE,QAAQ,aAAa,QAAQ,kBAAkB,sBAClD,CAAC;;;;;AAMJ,SAAgB,qBAAqB,EACnC,UACA,kBACA,gBAKC;AACD,iBAAgB;AACd,GAAM,YAAY;AAChB,OAAI,OAAO,WAAW,eAAe,EAAE,mBAAmB,WACxD;GAEF,MAAM,eAAe,MAAM,UAAU,cAAc,SACjD,oBAAoB,SACrB;AACD,kBAAe,aAAa;MAC1B;IACH,CAAC,cAAc,iBAAiB,CAAC;AAEpC,QAAO;;;;;;;;AAST,SAAgB,oBAAoB,EAClC,UACA,cACA,kBACA,WACA,kBAkBC;CACD,MAAM,kBAAkB,OAAO,aAAa;AAC5C,iBAAgB,UAAU;CAC1B,MAAM,oBACJ,OAAO,cAAc,WAAW,YAAY,WAAW,UAAU;CACnE,MAAM,gBAAgB,cAElB,+BAA+B;EAC7B,MAAM;EACN,QAAQ;EACT,CAAC,EACJ,EAAE,CACH;CACD,MAAM,CAAC,QAAQ,aAAa,SAAwB,cAAc;AAElE,iBAAgB;EACd,IAAI,WAAW;EACf,IAAI;AAEJ,YAAU,cAAc;AAExB,MAAI;GACF,MAAM,gBAAgB,gBAAgB;AACtC,mBAAgB,wBAAwB;IACtC,GAAI,gBACA,EACE,oBAAoB,eAAe,EACpC,GACD,EAAE;IACN,GAAI,oBACA,EACE,WACE,QAAQ,IAAI,aAAa,eACrB,qBAAqB,GACrB,mBACP,GACD,EAAE;IACN,GAAI,iBAAiB,EAAE,gBAAgB,GAAG,EAAE;IAC7C,CAAC;AACF,OAAI,CAAC,SACH,WAAU,cAAc,OAAO;WAE1B,OAAO;AACd,OAAI,CAAC,SACH,WACE,+BAA+B;IAC7B,MAAM;IACN,QAAQ;IACR,GAAI,iBAAiB,QAAQ,EAAE,OAAO,GAAG,EAAE;IAC5C,CAAC,CACH;;AAIL,eAAa;AACX,cAAW;AACX,kBAAe,SAAS;;IAEzB;EAAC;EAAe;EAAmB;EAAe,CAAC;AAEtD,QACE,oBAAC,sBAAD;EAAsB,GAAK,mBAAmB,EAAE,kBAAkB,GAAG,EAAE;YACrE,oBAAC,iBAAD;GAAyB;GAAS;GAA2B,CAAA;EACxC,CAAA"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.tsx"],"sourcesContent":["import {\n  createUnavailableSyncoreClient,\n  type SyncoreClient\n} from \"@syncore/core\";\nimport {\n  createManagedWebWorkerClient,\n  createSyncoreWebWorkerClient,\n  type ManagedWebWorkerClient\n} from \"@syncore/platform-web\";\nimport { SyncoreProvider } from \"@syncore/react\";\nimport {\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type ReactNode\n} from \"react\";\nimport { getSyncoreWorkerUrl } from \"./config.js\";\n\nexport { getSyncoreWorkerUrl } from \"./config.js\";\nexport { createSyncoreNextWorkerUrl } from \"./config.js\";\n\n/**\n * Shared configuration options for the Syncore Next.js integration.\n *\n * Accepted by both {@link SyncoreNextProvider} and\n * {@link registerSyncoreServiceWorker}.\n */\nexport interface SyncoreNextOptions {\n  /**\n   * URL of the Next PWA service worker. Defaults to `\"/sw.js\"` (the path\n   * emitted by `next-pwa` or `@ducanh2912/next-pwa`).\n   */\n  serviceWorkerUrl?: string;\n\n  /**\n   * Public path to the compiled Syncore worker asset. Defaults to\n   * `\"/syncore.worker.js\"`. Override if your build tool emits the worker to a\n   * different path.\n   */\n  workerAssetUrl?: string;\n}\n\n/**\n * Handle returned by {@link registerSyncoreServiceWorker}.\n */\nexport interface SyncoreServiceWorkerRegistration {\n  /** Unregister the installed service worker. */\n  unregister(): Promise<boolean>;\n\n  /**\n   * Instruct the browser to check for a new service worker version. Useful\n   * for implementing an “Update available” prompt.\n   */\n  update(): Promise<ServiceWorkerRegistration>;\n}\n\n/**\n * Register the Syncore PWA service worker in a Next.js app.\n *\n * Call this once at app startup (e.g. in your root layout’s `useEffect`, or in\n * `instrumentation.ts` with `\"use client\"`). Returns `null` on the server or\n * when the browser does not support service workers.\n *\n * ```ts\n * // app/layout.tsx (client component)\n * import { registerSyncoreServiceWorker } from \"syncorejs/next\";\n *\n * useEffect(() => {\n *   registerSyncoreServiceWorker({ serviceWorkerUrl: \"/sw.js\" });\n * }, []);\n * ```\n *\n * @param options - Optional configuration. Defaults to `\"/sw.js\"`.\n * @returns A {@link SyncoreServiceWorkerRegistration} handle, or `null` on\n *   the server / when unsupported.\n */\nexport async function registerSyncoreServiceWorker(\n  options?: SyncoreNextOptions\n): Promise<SyncoreServiceWorkerRegistration | null> {\n  if (typeof window === \"undefined\" || !(\"serviceWorker\" in navigator)) {\n    return null;\n  }\n\n  const registration = await navigator.serviceWorker.register(\n    options?.serviceWorkerUrl ?? \"/sw.js\"\n  );\n\n  return {\n    unregister: () => registration.unregister(),\n    update: () => registration.update()\n  };\n}\n\n/**\n * Create a worker-backed Syncore client for a Next.js app.\n *\n * The client communicates with a Syncore runtime running inside a `Worker`.\n * The worker runs the SQLite engine and all function handlers off the main\n * thread so the UI stays responsive.\n *\n * In most cases you should use {@link SyncoreNextProvider} instead, which\n * manages the client lifecycle automatically. Use `createNextSyncoreClient`\n * directly only when you need to control the client lifecycle yourself (e.g.\n * in testing harnesses or custom providers).\n *\n * ```ts\n * const managedClient = createNextSyncoreClient({\n *   workerAssetUrl: \"/syncore.worker.js\",\n * });\n *\n * // Later:\n * managedClient.dispose();\n * ```\n */\nexport function createNextSyncoreClient(options: {\n  /**\n   * Custom worker factory function. Useful in tests (supply a `Worker` backed\n   * by a mock or in-process runtime) or when using Next’s App Router dev-mode\n   * bundling where `new Worker(new URL(...))` must be used inside the component.\n   */\n  createWorker?: () => Worker;\n\n  /** Explicit module URL for an already-public worker script. */\n  workerUrl?: URL | string;\n\n  /** Public asset path for the compiled worker file. Defaults to `\"/syncore.worker.js\"`. */\n  workerAssetUrl?: string;\n}): ManagedWebWorkerClient {\n  if (options.createWorker) {\n    return createManagedWebWorkerClient({\n      createWorker: options.createWorker\n    });\n  }\n\n  return createSyncoreWebWorkerClient({\n    workerUrl:\n      options.workerUrl ?? options.workerAssetUrl ?? \"/syncore.worker.js\"\n  });\n}\n\n/**\n * React component that registers a PWA service worker as a side-effect.\n *\n * Renders its `children` immediately (no loading state) and registers the\n * service worker asynchronously. Safe to render on the server — the\n * registration effect only runs in browsers that support service workers.\n *\n * ```tsx\n * <SyncoreServiceWorker serviceWorkerUrl=\"/sw.js\" onRegistered={console.log}>\n *   <App />\n * </SyncoreServiceWorker>\n * ```\n */\nexport function SyncoreServiceWorker({\n  children,\n  serviceWorkerUrl,\n  onRegistered\n}: {\n  children: ReactNode;\n  /** URL of the service worker script. Defaults to `\"/sw.js\"`. */\n  serviceWorkerUrl?: string;\n  /** Called after the service worker is successfully registered. */\n  onRegistered?: (registration: ServiceWorkerRegistration) => void;\n}) {\n  useEffect(() => {\n    void (async () => {\n      if (typeof window === \"undefined\" || !(\"serviceWorker\" in navigator)) {\n        return;\n      }\n      const registration = await navigator.serviceWorker.register(\n        serviceWorkerUrl ?? \"/sw.js\"\n      );\n      onRegistered?.(registration);\n    })();\n  }, [onRegistered, serviceWorkerUrl]);\n\n  return children;\n}\n\n/**\n * Root provider that wires a worker-backed Syncore runtime into a Next.js\n * React tree.\n *\n * Place this at the top of your App Router layout. It spawns the Syncore\n * worker on mount, exposes the client via React context (accessible with\n * `useSyncore()`), and optionally registers the PWA service worker.\n *\n * ```tsx\n * // app/layout.tsx\n * import { SyncoreNextProvider } from \"syncorejs/next\";\n *\n * export default function RootLayout({ children }) {\n *   return (\n *     <html>\n *       <body>\n *         <SyncoreNextProvider\n *           createWorker={() => new Worker(\n *             new URL(\"../syncore.worker.ts\", import.meta.url)\n *           )}\n *         >\n *           {children}\n *         </SyncoreNextProvider>\n *       </body>\n *     </html>\n *   );\n * }\n * ```\n */\nexport function SyncoreNextProvider({\n  children,\n  createWorker,\n  serviceWorkerUrl,\n  workerUrl,\n  workerAssetUrl\n}: {\n  /** The React subtree that should receive the Syncore client. */\n  children: ReactNode;\n\n  /**\n   * Factory function that creates the Syncore `Worker`. Required in Next App\n   * Router dev mode because `new Worker(new URL(..., import.meta.url))` must\n   * be called inside the module to be bundled correctly.\n   */\n  createWorker?: () => Worker;\n\n  /** URL of the PWA service worker script. Omit to skip service worker registration. */\n  serviceWorkerUrl?: string;\n\n  /** Explicit module URL for an already-public worker asset. */\n  workerUrl?: URL | string;\n\n  /** Public asset path for the compiled worker file. Defaults to `\"/syncore.worker.js\"`. */\n  workerAssetUrl?: string;\n}) {\n  const createWorkerRef = useRef(createWorker);\n  createWorkerRef.current = createWorker;\n  const resolvedWorkerUrl =\n    typeof workerUrl === \"string\" ? workerUrl : workerUrl?.toString();\n  const bootingClient = useMemo(\n    () =>\n      createUnavailableSyncoreClient({\n        kind: \"starting\",\n        reason: \"booting\"\n      }),\n    []\n  );\n  const [client, setClient] = useState<SyncoreClient>(bootingClient);\n\n  useEffect(() => {\n    let managedClient: ManagedWebWorkerClient | undefined;\n\n    setClient(bootingClient);\n\n    try {\n      const workerFactory = createWorkerRef.current;\n      managedClient = createNextSyncoreClient({\n        ...(workerFactory\n          ? {\n              createWorker: () => workerFactory()\n            }\n          : {}),\n        ...(resolvedWorkerUrl\n          ? {\n              workerUrl:\n                process.env.NODE_ENV === \"production\"\n                  ? getSyncoreWorkerUrl()\n                  : resolvedWorkerUrl\n            }\n          : {}),\n        ...(workerAssetUrl ? { workerAssetUrl } : {})\n      });\n      setClient(managedClient.client);\n    } catch (error) {\n      setClient(\n        createUnavailableSyncoreClient({\n          kind: \"unavailable\",\n          reason: \"worker-unavailable\",\n          ...(error instanceof Error ? { error } : {})\n        })\n      );\n    }\n\n    return () => {\n      managedClient?.dispose();\n    };\n  }, [bootingClient, resolvedWorkerUrl, workerAssetUrl]);\n\n  return (\n    <SyncoreServiceWorker {...(serviceWorkerUrl ? { serviceWorkerUrl } : {})}>\n      <SyncoreProvider client={client}>{children}</SyncoreProvider>\n    </SyncoreServiceWorker>\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EA,eAAsB,6BACpB,SACkD;CAClD,IAAI,OAAO,WAAW,eAAe,EAAE,mBAAmB,YACxD,OAAO;CAGT,MAAM,eAAe,MAAM,UAAU,cAAc,SACjD,SAAS,oBAAoB,QAC/B;CAEA,OAAO;EACL,kBAAkB,aAAa,WAAW;EAC1C,cAAc,aAAa,OAAO;CACpC;AACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,wBAAwB,SAab;CACzB,IAAI,QAAQ,cACV,OAAO,6BAA6B,EAClC,cAAc,QAAQ,aACxB,CAAC;CAGH,OAAO,6BAA6B,EAClC,WACE,QAAQ,aAAa,QAAQ,kBAAkB,qBACnD,CAAC;AACH;;;;;;;;;;;;;;AAeA,SAAgB,qBAAqB,EACnC,UACA,kBACA,gBAOC;CACD,gBAAgB;EACd,CAAM,YAAY;GAChB,IAAI,OAAO,WAAW,eAAe,EAAE,mBAAmB,YACxD;GAEF,MAAM,eAAe,MAAM,UAAU,cAAc,SACjD,oBAAoB,QACtB;GACA,eAAe,YAAY;EAC7B,GAAG;CACL,GAAG,CAAC,cAAc,gBAAgB,CAAC;CAEnC,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,oBAAoB,EAClC,UACA,cACA,kBACA,WACA,kBAoBC;CACD,MAAM,kBAAkB,OAAO,YAAY;CAC3C,gBAAgB,UAAU;CAC1B,MAAM,oBACJ,OAAO,cAAc,WAAW,YAAY,WAAW,SAAS;CAClE,MAAM,gBAAgB,cAElB,+BAA+B;EAC7B,MAAM;EACN,QAAQ;CACV,CAAC,GACH,CAAC,CACH;CACA,MAAM,CAAC,QAAQ,aAAa,SAAwB,aAAa;CAEjE,gBAAgB;EACd,IAAI;EAEJ,UAAU,aAAa;EAEvB,IAAI;GACF,MAAM,gBAAgB,gBAAgB;GACtC,gBAAgB,wBAAwB;IACtC,GAAI,gBACA,EACE,oBAAoB,cAAc,EACpC,IACA,CAAC;IACL,GAAI,oBACA,EACE,WACE,QAAQ,IAAI,aAAa,eACrB,oBAAoB,IACpB,kBACR,IACA,CAAC;IACL,GAAI,iBAAiB,EAAE,eAAe,IAAI,CAAC;GAC7C,CAAC;GACD,UAAU,cAAc,MAAM;EAChC,SAAS,OAAO;GACd,UACE,+BAA+B;IAC7B,MAAM;IACN,QAAQ;IACR,GAAI,iBAAiB,QAAQ,EAAE,MAAM,IAAI,CAAC;GAC5C,CAAC,CACH;EACF;EAEA,aAAa;GACX,eAAe,QAAQ;EACzB;CACF,GAAG;EAAC;EAAe;EAAmB;CAAc,CAAC;CAErD,OACE,oBAAC,sBAAD;EAAsB,GAAK,mBAAmB,EAAE,iBAAiB,IAAI,CAAC;YACpE,oBAAC,iBAAD;GAAyB;GAAS;EAA0B,CAAA;CACxC,CAAA;AAE1B"}

package/dist/_vendor/platform-expo/index.d.ts

@@ -1,68 +1,187 @@
 import { SQLiteDatabase } from "expo-sqlite";
-import * as _syncore_core0 from "../core/index.d.mts";
 import { DevtoolsSink, SchedulerOptions, StorageObject, StorageWriteInput, SyncoreCapabilities, SyncoreDataModel, SyncoreExternalChangeApplier, SyncoreExternalChangeSignal, SyncoreRuntime, SyncoreRuntimeOptions, SyncoreSqlDriver, SyncoreStorageAdapter } from "../core/index.d.mts";
 
 //#region src/index.d.ts
 type ExpoSyncoreSchema<TSchema extends SyncoreDataModel = SyncoreDataModel> = TSchema;
 /**
- * Options for constructing an Expo Syncore runtime.
+ * Options for {@link createExpoSyncoreRuntime}.
  *
- * Use this when you want Syncore to persist locally with `expo-sqlite` and the
- * Expo file system.
+ * On native (iOS/Android) Syncore uses `expo-sqlite` and `expo-file-system`
+ * automatically. When the same app is served on web (via `expo-router` or
+ * Metro’s web bundler) it falls back to the SQL.js + OPFS web stack instead.
+ *
+ * At minimum supply `schema` and `functions`. Everything else has platform
+ * defaults.
+ *
+ * ```ts
+ * const runtime = createExpoSyncoreRuntime({
+ *   schema,
+ *   functions,
+ *   databaseName: "app.db",
+ *   storageDirectoryName: "app-storage",
+ * });
+ * await runtime.start();
+ * ```
  */
 interface CreateExpoRuntimeOptions<TSchema extends ExpoSyncoreSchema = ExpoSyncoreSchema> {
-  /** The schema for the local Syncore app. */
+  /** The data model that defines the available tables and indexes. */
   schema: TSchema;
-  /** The generated function registry for the local Syncore app. */
+  /**
+   * The registered function map. Use the `functions` export from
+   * `syncore/_generated/functions.ts`.
+   */
   functions: SyncoreRuntimeOptions<TSchema>["functions"];
-  /** Optional resolved installed components for the local Syncore app. */
+  /**
+   * Resolved Syncore component instances. Only required when your app
+   * installs Syncore component packages.
+   */
   components?: SyncoreRuntimeOptions<TSchema>["components"];
-  /** Optional platform capabilities exposed to function handlers. */
+  /**
+   * Platform capabilities injected into `ctx.capabilities` inside function
+   * handlers.
+   */
   capabilities?: SyncoreCapabilities;
-  /** Optional custom SQL driver. Defaults to `expo-sqlite`. */
+  /**
+   * Custom SQL driver. Defaults to an `ExpoSqliteDriver` backed by
+   * `expo-sqlite`.
+   */
   driver?: SyncoreSqlDriver;
-  /** Optional custom file/blob storage adapter. */
+  /** Custom file/blob storage adapter. Defaults to `ExpoFileStorageAdapter`. */
   storage?: SyncoreStorageAdapter;
-  /** The SQLite database filename to open locally. */
+  /**
+   * SQLite database filename (e.g. `"app.db"`). Defaults to `"syncore.db"`.
+   * The file is created inside the app-local documents directory on device.
+   */
   databaseName?: string;
-  /** Optional directory for the SQLite database file. */
+  /**
+   * Absolute path to the directory where the SQLite file is stored.
+   * Defaults to `expo-sqlite`’s `defaultDatabaseDirectory`.
+   */
   databaseDirectory?: string;
-  /** Directory name used for local file/blob storage. */
+  /**
+   * Name of the sub-directory inside the app’s documents folder used for
+   * blob/file storage. Defaults to `"syncore-storage"`.
+   */
   storageDirectoryName?: string;
-  /** Optional runtime platform label shown in devtools snapshots. */
+  /**
+   * Platform label reported to devtools. Defaults to `"expo"`. Override to
+   * `"expo-web"` when running on web.
+   */
   platform?: string;
-  /** Optional devtools sink used during development. */
+  /**
+   * Devtools event sink. Omit to disable devtools. On-device devtools
+   * connections require pointing to your development machine’s IP address.
+   */
   devtools?: DevtoolsSink;
-  /** Optional scheduler configuration for jobs and recurring work. */
+  /** Scheduler configuration for background and recurring jobs. */
   scheduler?: SchedulerOptions;
-  /** Optional shared signal used to synchronize browser instances. */
+  /**
+   * External change signal used to keep multiple in-process instances in sync.
+   * On web, defaults to a `BroadcastChannel`-based signal automatically.
+   */
   externalChangeSignal?: SyncoreExternalChangeSignal;
-  /** Optional applier used to reconcile browser-side external changes. */
+  /**
+   * External change applier used when change events arrive from other tabs or
+   * processes. On web with `ExpoSqliteDriver`, defaults to
+   * `ExpoWebExternalChangeApplier` automatically.
+   */
   externalChangeApplier?: SyncoreExternalChangeApplier;
+  /**
+   * Direct URL to the SQL.js `.wasm` binary. Only needed when the app runs on
+   * web and the default CDN URL is unreachable.
+   */
+  wasmUrl?: string;
+  /**
+   * Resolver for SQL.js support files (`.wasm`, `.worker.js`). Equivalent to
+   * the `locateFile` option in `initSqlJs()`. Only used on web.
+   */
+  locateFile?: (fileName: string) => string;
 }
 /**
- * A reusable bootstrap that lazily creates, starts, and stops an Expo Syncore runtime.
+ * A reusable, lazily-started Expo Syncore runtime handle.
+ *
+ * Created by {@link createExpoSyncoreBootstrap}. The bootstrap defers actual
+ * runtime startup until the first call to `getClient()` and keeps a single
+ * instance alive across React Navigation reloads.
+ *
+ * ```ts
+ * const bootstrap = createExpoSyncoreBootstrap({ schema, functions });
+ *
+ * // In your root component:
+ * const client = await bootstrap.getClient();
+ * ```
  */
 interface ExpoSyncoreBootstrap<TSchema extends ExpoSyncoreSchema = ExpoSyncoreSchema> {
-  /** Synchronous access is unavailable; use `getClient()` instead. */
+  /** @deprecated Access the runtime via `getClient()` instead. */
   getRuntime(): never;
-  /** Start the runtime if needed and return a ready client. */
+  /**
+   * Start the runtime on first call, then return the same client on subsequent
+   * calls. Safe to call from multiple places concurrently.
+   */
   getClient(): Promise<ReturnType<SyncoreRuntime<TSchema>["createClient"]>>;
-  /** Stop the current runtime instance if one exists. */
+  /** Stop the running runtime instance if one is active. */
   stop(): Promise<void>;
-  /** Fully discard the runtime so the next call recreates it. */
+  /**
+   * Stop and discard the current runtime so the next `getClient()` call
+   * creates a fresh one. Useful after a full app reset or database migration.
+   */
   reset(): Promise<void>;
 }
 /**
- * Create an Expo Syncore runtime backed by `expo-sqlite` and local file storage.
+ * Create a Syncore runtime for Expo (React Native and Expo web) backed by
+ * `expo-sqlite` on native platforms and SQL.js on web.
+ *
+ * Returns an unstarted {@link SyncoreRuntime}. Call `await runtime.start()`
+ * before using the client:
+ *
+ * ```ts
+ * import { createExpoSyncoreRuntime } from "syncorejs/expo";
+ * import schema from "./syncore/schema";
+ * import { functions } from "./syncore/_generated/functions";
+ *
+ * const runtime = createExpoSyncoreRuntime({ schema, functions });
+ * await runtime.start();
+ * const client = runtime.createClient();
+ * ```
+ *
+ * For managed lifecycle in React components, prefer
+ * {@link createExpoSyncoreBootstrap} instead.
  */
 declare function createExpoSyncoreRuntime<TSchema extends ExpoSyncoreSchema>(options: CreateExpoRuntimeOptions<TSchema>): SyncoreRuntime<TSchema>;
 /**
- * Create a same-process Syncore client from a started Expo runtime.
+ * Create a same-process Syncore client directly from a started Expo runtime.
+ *
+ * Prefer this in scripts or non-component code. For React component trees,
+ * use {@link createExpoSyncoreBootstrap} instead to get automatic lifecycle
+ * management.
+ *
+ * ```ts
+ * const client = createExpoSyncoreClient(runtime);
+ * await client.mutation(api.todos.create, { text: "Buy milk" });
+ * ```
  */
-declare function createExpoSyncoreClient<TSchema extends ExpoSyncoreSchema>(runtime: SyncoreRuntime<TSchema>): _syncore_core0.SyncoreClient;
+declare function createExpoSyncoreClient<TSchema extends ExpoSyncoreSchema>(runtime: SyncoreRuntime<TSchema>): import("../core/index.d.mts").SyncoreClient;
 /**
- * Create a reusable Expo bootstrap that lazily starts the local runtime.
+ * Create a reusable Expo bootstrap that lazily starts the local runtime the
+ * first time a client is requested.
+ *
+ * The bootstrap keeps a single runtime instance alive across component
+ * remounts and safely handles concurrent `getClient()` calls.
+ *
+ * ```ts
+ * // app/_layout.tsx
+ * import { createExpoSyncoreBootstrap } from "syncorejs/expo";
+ * import schema from "../syncore/schema";
+ * import { functions } from "../syncore/_generated/functions";
+ *
+ * export const syncoreBootstrap = createExpoSyncoreBootstrap({
+ *   schema,
+ *   functions,
+ * });
+ *
+ * // Later in SyncoreProvider:
+ * const client = await syncoreBootstrap.getClient();
+ * ```
  */
 declare function createExpoSyncoreBootstrap<TSchema extends ExpoSyncoreSchema>(options: CreateExpoRuntimeOptions<TSchema>): ExpoSyncoreBootstrap<TSchema>;
 /**