@syncular/client 0.30.15 → 0.30.16

package/README.md

@@ -821,10 +821,26 @@ committed import chunks; no write transaction spans that await.
 
 ## Preflight authority reads
 
-Pass `authorityReads: defineAuthorityReads([{ table, columns, scopes }])` at
+Import `defineAuthorityReads` from `@syncular/client/authority`. Pass
+`authorityReads: defineAuthorityReads([{ table, columns, scopes }])` at
 creation to enable the zero-argument `authoritySnapshot()`. It reads approved
 plain authority columns and accepted bases with revision and persisted scope
 coverage from one SQLite snapshot, including during security preflight.
 Unaccepted local intent remains separate. The read changes no keys, transport,
 subscriptions or lifecycle. See the [authority contract](../../docs/SPEC.md)
 and [native configuration](../tauri/README.md#authority-evidence-before-activation).
+
+Workers must opt in in their entry script:
+
+```ts
+import { defineAuthorityReads } from '@syncular/client/authority';
+import { startSyncWorker } from '@syncular/client/worker';
+
+startSyncWorker({ createAuthorityReads: defineAuthorityReads });
+```
+
+Pass the policy to `createSyncClientHandle({ authorityReads, ...config })` on
+the main thread. Declarations without the injected worker factory fail with
+`client.authority_read_forbidden` before opening storage. Ordinary workers
+keep `startSyncWorker()` and bundle no authority reader. No dynamic import
+changes the declared capability.

package/dist/index.d.ts

@@ -8,7 +8,7 @@
  * (`worker-host`) and the RPC protocol types are root exports — they
  * import no SQLite.
  */
-export { defineAuthorityReads, type AuthorityReadPolicy, type AuthorityReadDeclaration, type AuthoritySnapshot, } from './authority.js';
+export type { AuthorityReadPolicy, AuthorityReadDeclaration, AuthoritySnapshot, } from './authority.js';
 export * from './apply.js';
 export * from './availability.js';
 export * from './blob.js';

package/dist/index.js

@@ -1,14 +1,3 @@
-/**
- * @syncular/client is the TypeScript client protocol core.
- * SPEC.md is normative.
- *
- * Browser-safe root: database backends live behind subpath exports
- * (`./sqlite` for Node or Bun, `./wasm` for sqlite-wasm + OPFS); the
- * worker-side bootstrap lives behind `./worker`. The main-thread handle
- * (`worker-host`) and the RPC protocol types are root exports — they
- * import no SQLite.
- */
-export { defineAuthorityReads, } from './authority.js';
 export * from './apply.js';
 export * from './availability.js';
 export * from './blob.js';

package/dist/worker-entry.d.ts

@@ -1,7 +1,25 @@
+/**
+ * Worker-side bootstrap: constructs the WHOLE
+ * client core — SyncClient + transports + realtime + SQLite — inside the
+ * worker and serves the `worker-protocol` RPC over postMessage.
+ *
+ * Browsers get the defaults: opfs-sahpool persistence and the fetch/WS
+ * transports from `./http`, wired from `WorkerInitConfig.endpoints`.
+ * Tests inject a database factory (bun:sqlite) through `overrides` — the
+ * same bootstrap, the same RPC, a different SQLite.
+ *
+ * The §8.4 host loop lives HERE: wake-ups (hello/`sync` events, delta
+ * drops) coalesce into one intent-driven `syncUntilIdle` round in the worker;
+ * RPC-driven and auto-driven sync rounds serialize on one queue because
+ * the core owns exactly one loop.
+ */
+import type { defineAuthorityReads } from './authority.js';
 import type { ClientDatabase } from './database.js';
 import type { RealtimeConnector, SegmentDownloader, SyncTransport } from './transport.js';
 import { type WorkerInitConfig } from './worker-protocol.js';
 export interface SyncWorkerOverrides {
+    /** Explicit authority reader factory. Required when init declares authorityReads. */
+    readonly createAuthorityReads?: typeof defineAuthorityReads;
     /** Database factory indirection: tests inject bun:sqlite here. */
     readonly openDatabase?: (config: WorkerInitConfig) => Promise<ClientDatabase> | ClientDatabase;
     /** Retry deadline indirection for deterministic worker-host tests. */

package/dist/worker-entry.js

@@ -1,19 +1,3 @@
-/**
- * Worker-side bootstrap: constructs the WHOLE
- * client core — SyncClient + transports + realtime + SQLite — inside the
- * worker and serves the `worker-protocol` RPC over postMessage.
- *
- * Browsers get the defaults: opfs-sahpool persistence and the fetch/WS
- * transports from `./http`, wired from `WorkerInitConfig.endpoints`.
- * Tests inject a database factory (bun:sqlite) through `overrides` — the
- * same bootstrap, the same RPC, a different SQLite.
- *
- * The §8.4 host loop lives HERE: wake-ups (hello/`sync` events, delta
- * drops) coalesce into one intent-driven `syncUntilIdle` round in the worker;
- * RPC-driven and auto-driven sync rounds serialize on one queue because
- * the core owns exactly one loop.
- */
-import { defineAuthorityReads } from './authority.js';
 import { SyncClient } from './client.js';
 import { withClientDiagnosticsHost, } from './diagnostics.js';
 import { encryptionConfigFromKeyring } from './encryption.js';
@@ -160,6 +144,8 @@ export function startSyncWorker(overrides = {}) {
         return client;
     }
     async function init(config) {
+        if (config.authorityReads !== undefined && !overrides.createAuthorityReads)
+            throw new ClientSyncError('client.authority_read_forbidden', 'authorityReads requires startSyncWorker({ createAuthorityReads })');
         if (client !== undefined) {
             throw new ClientSyncError(WORKER_FAILED_CODE, 'the worker is already initialized');
         }
@@ -235,7 +221,9 @@ export function startSyncWorker(overrides = {}) {
                 ? { encryption: encryptionConfigFromKeyring(config.encryption) }
                 : {}),
             ...(config.authorityReads !== undefined
-                ? { authorityReads: defineAuthorityReads(config.authorityReads) }
+                ? {
+                    authorityReads: overrides.createAuthorityReads(config.authorityReads),
+                }
                 : {}),
             ...(config.securityPreflight !== undefined
                 ? { securityPreflight: config.securityPreflight }
@@ -300,8 +288,44 @@ export function startSyncWorker(overrides = {}) {
             consumeSyncIntent({ kind: 'interactive' });
         return { clientId: started.clientId };
     }
+    // Forward every argument to core methods, including authority's zero-argument check.
+    const coreMethods = [
+        'securityLifecycle',
+        'subscribe',
+        'unsubscribe',
+        'windowState',
+        'purgeLocalData',
+        'rebootstrapLocalData',
+        'previousVersionSnapshot',
+        'previousVersionAudit',
+        'previousVersionDiscard',
+        'query',
+        'authoritySnapshot',
+        'querySnapshot',
+        'statusSnapshot',
+        'conflicts',
+        'rejections',
+        'commitOutcome',
+        'commitOutcomes',
+        'resolveCommitOutcome',
+        'pendingCommits',
+        'subscriptions',
+        'subscription',
+        'connectRealtime',
+        'disconnectRealtime',
+        'setPresence',
+        'presence',
+        'uploadBlob',
+        'fetchBlob',
+    ];
     const api = {
-        securityLifecycle: () => requireClient().securityLifecycle(),
+        ...Object.fromEntries(coreMethods.map((method) => [
+            method,
+            (...args) => {
+                const running = requireClient();
+                return Reflect.apply(running[method], running, args);
+            },
+        ])),
         beginSecurityPreflight: async () => {
             if (backgroundTimer !== undefined)
                 clearTimeout(backgroundTimer);
@@ -317,12 +341,9 @@ export function startSyncWorker(overrides = {}) {
                     : {}),
             });
         },
-        subscribe: (input) => requireClient().subscribe(input),
-        unsubscribe: (id) => requireClient().unsubscribe(id),
         setWindow: async (base, units) => {
             await requireClient().setWindowCommand(base, units);
         },
-        windowState: (base) => requireClient().windowState(base),
         mutate: (mutations) => {
             return requireClient().mutateCommand(mutations).value;
         },
@@ -332,11 +353,6 @@ export function startSyncWorker(overrides = {}) {
             const result = requireClient().patchCommand(table, rowId, partial, options);
             return result.value;
         },
-        purgeLocalData: (input) => requireClient().purgeLocalData(input),
-        rebootstrapLocalData: (input) => requireClient().rebootstrapLocalData(input),
-        previousVersionSnapshot: (spec) => requireClient().previousVersionSnapshot(spec),
-        previousVersionAudit: () => requireClient().previousVersionAudit(),
-        previousVersionDiscard: () => requireClient().previousVersionDiscard(),
         sync: () => {
             const running = requireClient();
             return serializedSync(() => running.sync());
@@ -345,11 +361,7 @@ export function startSyncWorker(overrides = {}) {
             const running = requireClient();
             return serializedSync(() => running.syncUntilIdle(maxRounds));
         },
-        query: (sql, params) => requireClient().query(sql, params),
-        authoritySnapshot: () => requireClient().authoritySnapshot(),
-        querySnapshot: (spec) => requireClient().querySnapshot(spec),
         localRevision: () => requireClient().localRevision,
-        statusSnapshot: () => requireClient().statusSnapshot(),
         diagnosticsSnapshot: (request) => {
             const snapshot = requireClient().diagnosticsSnapshot(request);
             return withClientDiagnosticsHost(snapshot, {
@@ -359,20 +371,6 @@ export function startSyncWorker(overrides = {}) {
                 realtime: snapshot.host.realtime,
             });
         },
-        conflicts: () => requireClient().conflicts(),
-        rejections: () => requireClient().rejections(),
-        commitOutcome: (clientCommitId) => requireClient().commitOutcome(clientCommitId),
-        commitOutcomes: (query) => requireClient().commitOutcomes(query),
-        resolveCommitOutcome: (input) => requireClient().resolveCommitOutcome(input),
-        pendingCommits: () => requireClient().pendingCommits(),
-        subscriptions: () => requireClient().subscriptions(),
-        subscription: (id) => requireClient().subscription(id),
-        connectRealtime: () => requireClient().connectRealtime(),
-        disconnectRealtime: () => requireClient().disconnectRealtime(),
-        setPresence: (scopeKey, doc) => requireClient().setPresence(scopeKey, doc),
-        presence: (scopeKey) => requireClient().presence(scopeKey),
-        uploadBlob: (bytes, options) => requireClient().uploadBlob(bytes, options),
-        fetchBlob: (blobIdOrRef) => requireClient().fetchBlob(blobIdOrRef),
         setHeaders: (next) => {
             headers = next;
         },
@@ -425,8 +423,6 @@ export function startSyncWorker(overrides = {}) {
         'previousVersionDiscard',
     ]);
     async function dispatch(message) {
-        if (message.method === 'authoritySnapshot' && message.args.length)
-            throw new ClientSyncError('client.authority_read_forbidden', 'authoritySnapshot accepts no arguments');
         const method = api[message.method];
         const invoke = () => method.apply(api, message.args);
         if (syncChainMethods.has(message.method)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/client",
-  "version": "0.30.15",
+  "version": "0.30.16",
   "description": "Syncular TypeScript client core — offline-first sync over SQLite (WASM/OPFS, Bun, Node)",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -73,6 +73,14 @@
         "types": "./dist/worker-entry.d.ts",
         "default": "./dist/worker-entry.js"
       }
+    },
+    "./authority": {
+      "bun": "./src/authority.ts",
+      "browser": "./dist/authority.js",
+      "import": {
+        "types": "./dist/authority.d.ts",
+        "default": "./dist/authority.js"
+      }
     }
   },
   "files": [
@@ -89,10 +97,10 @@
   },
   "dependencies": {
     "@sqlite.org/sqlite-wasm": "^3.53.0-build1",
-    "@syncular/core": "0.30.15"
+    "@syncular/core": "0.30.16"
   },
   "devDependencies": {
-    "@syncular/server": "0.30.15",
+    "@syncular/server": "0.30.16",
     "playwright": "1.63.0",
     "@electric-sql/pglite": "^0.5.4"
   }

package/src/index.ts

@@ -8,11 +8,10 @@
  * (`worker-host`) and the RPC protocol types are root exports — they
  * import no SQLite.
  */
-export {
-  defineAuthorityReads,
-  type AuthorityReadPolicy,
-  type AuthorityReadDeclaration,
-  type AuthoritySnapshot,
+export type {
+  AuthorityReadPolicy,
+  AuthorityReadDeclaration,
+  AuthoritySnapshot,
 } from './authority';
 export * from './apply';
 export * from './availability';

package/src/worker-entry.ts

@@ -13,7 +13,7 @@
  * RPC-driven and auto-driven sync rounds serialize on one queue because
  * the core owns exactly one loop.
  */
-import { defineAuthorityReads } from './authority';
+import type { defineAuthorityReads } from './authority';
 import { SyncClient } from './client';
 import type { ClientDatabase } from './database';
 import {
@@ -52,6 +52,8 @@ import {
 } from './worker-protocol';
 
 export interface SyncWorkerOverrides {
+  /** Explicit authority reader factory. Required when init declares authorityReads. */
+  readonly createAuthorityReads?: typeof defineAuthorityReads;
   /** Database factory indirection: tests inject bun:sqlite here. */
   readonly openDatabase?: (
     config: WorkerInitConfig,
@@ -239,6 +241,11 @@ export function startSyncWorker(overrides: SyncWorkerOverrides = {}): void {
   }
 
   async function init(config: WorkerInitConfig): Promise<WorkerInitResult> {
+    if (config.authorityReads !== undefined && !overrides.createAuthorityReads)
+      throw new ClientSyncError(
+        'client.authority_read_forbidden',
+        'authorityReads requires startSyncWorker({ createAuthorityReads })',
+      );
     if (client !== undefined) {
       throw new ClientSyncError(
         WORKER_FAILED_CODE,
@@ -325,7 +332,11 @@ export function startSyncWorker(overrides: SyncWorkerOverrides = {}): void {
         ? { encryption: encryptionConfigFromKeyring(config.encryption) }
         : {}),
       ...(config.authorityReads !== undefined
-        ? { authorityReads: defineAuthorityReads(config.authorityReads) }
+        ? {
+            authorityReads: overrides.createAuthorityReads!(
+              config.authorityReads,
+            ),
+          }
         : {}),
       ...(config.securityPreflight !== undefined
         ? { securityPreflight: config.securityPreflight }
@@ -393,8 +404,46 @@ export function startSyncWorker(overrides: SyncWorkerOverrides = {}): void {
     return { clientId: started.clientId };
   }
 
+  // Forward every argument to core methods, including authority's zero-argument check.
+  const coreMethods = [
+    'securityLifecycle',
+    'subscribe',
+    'unsubscribe',
+    'windowState',
+    'purgeLocalData',
+    'rebootstrapLocalData',
+    'previousVersionSnapshot',
+    'previousVersionAudit',
+    'previousVersionDiscard',
+    'query',
+    'authoritySnapshot',
+    'querySnapshot',
+    'statusSnapshot',
+    'conflicts',
+    'rejections',
+    'commitOutcome',
+    'commitOutcomes',
+    'resolveCommitOutcome',
+    'pendingCommits',
+    'subscriptions',
+    'subscription',
+    'connectRealtime',
+    'disconnectRealtime',
+    'setPresence',
+    'presence',
+    'uploadBlob',
+    'fetchBlob',
+  ] as const satisfies readonly (keyof WorkerApi & keyof SyncClient)[];
   const api: WorkerApi = {
-    securityLifecycle: () => requireClient().securityLifecycle(),
+    ...(Object.fromEntries(
+      coreMethods.map((method) => [
+        method,
+        (...args: unknown[]) => {
+          const running = requireClient();
+          return Reflect.apply(running[method], running, args);
+        },
+      ]),
+    ) as Pick<WorkerApi, (typeof coreMethods)[number]>),
     beginSecurityPreflight: async () => {
       if (backgroundTimer !== undefined) clearTimeout(backgroundTimer);
       backgroundTimer = undefined;
@@ -409,12 +458,9 @@ export function startSyncWorker(overrides: SyncWorkerOverrides = {}): void {
           : {}),
       });
     },
-    subscribe: (input) => requireClient().subscribe(input),
-    unsubscribe: (id) => requireClient().unsubscribe(id),
     setWindow: async (base, units) => {
       await requireClient().setWindowCommand(base, units);
     },
-    windowState: (base) => requireClient().windowState(base),
     mutate: (mutations) => {
       return requireClient().mutateCommand(mutations).value;
     },
@@ -429,13 +475,6 @@ export function startSyncWorker(overrides: SyncWorkerOverrides = {}): void {
       );
       return result.value;
     },
-    purgeLocalData: (input) => requireClient().purgeLocalData(input),
-    rebootstrapLocalData: (input) =>
-      requireClient().rebootstrapLocalData(input),
-    previousVersionSnapshot: (spec) =>
-      requireClient().previousVersionSnapshot(spec),
-    previousVersionAudit: () => requireClient().previousVersionAudit(),
-    previousVersionDiscard: () => requireClient().previousVersionDiscard(),
     sync: () => {
       const running = requireClient();
       return serializedSync(() => running.sync());
@@ -444,11 +483,7 @@ export function startSyncWorker(overrides: SyncWorkerOverrides = {}): void {
       const running = requireClient();
       return serializedSync(() => running.syncUntilIdle(maxRounds));
     },
-    query: (sql, params) => requireClient().query(sql, params),
-    authoritySnapshot: () => requireClient().authoritySnapshot(),
-    querySnapshot: (spec) => requireClient().querySnapshot(spec),
     localRevision: () => requireClient().localRevision,
-    statusSnapshot: () => requireClient().statusSnapshot(),
     diagnosticsSnapshot: (request) => {
       const snapshot = requireClient().diagnosticsSnapshot(request);
       return withClientDiagnosticsHost(snapshot, {
@@ -458,22 +493,6 @@ export function startSyncWorker(overrides: SyncWorkerOverrides = {}): void {
         realtime: snapshot.host.realtime,
       });
     },
-    conflicts: () => requireClient().conflicts(),
-    rejections: () => requireClient().rejections(),
-    commitOutcome: (clientCommitId) =>
-      requireClient().commitOutcome(clientCommitId),
-    commitOutcomes: (query) => requireClient().commitOutcomes(query),
-    resolveCommitOutcome: (input) =>
-      requireClient().resolveCommitOutcome(input),
-    pendingCommits: () => requireClient().pendingCommits(),
-    subscriptions: () => requireClient().subscriptions(),
-    subscription: (id) => requireClient().subscription(id),
-    connectRealtime: () => requireClient().connectRealtime(),
-    disconnectRealtime: () => requireClient().disconnectRealtime(),
-    setPresence: (scopeKey, doc) => requireClient().setPresence(scopeKey, doc),
-    presence: (scopeKey) => requireClient().presence(scopeKey),
-    uploadBlob: (bytes, options) => requireClient().uploadBlob(bytes, options),
-    fetchBlob: (blobIdOrRef) => requireClient().fetchBlob(blobIdOrRef),
     setHeaders: (next) => {
       headers = next;
     },
@@ -525,11 +544,6 @@ export function startSyncWorker(overrides: SyncWorkerOverrides = {}): void {
   ]);
 
   async function dispatch(message: WorkerCallMessage): Promise<unknown> {
-    if (message.method === 'authoritySnapshot' && message.args.length)
-      throw new ClientSyncError(
-        'client.authority_read_forbidden',
-        'authoritySnapshot accepts no arguments',
-      );
     const method = api[message.method] as (...args: unknown[]) => unknown;
     const invoke = () => method.apply(api, message.args as unknown[]);
     if (syncChainMethods.has(message.method)) {