@wells-nelson/data-storage 1.0.0 → 1.0.2

package/README.md

@@ -33,7 +33,9 @@ export const store = createSyncedStore<Docs, 'projects'>({
 		if (collection === 'task_links') return { ...row, id: `${row.from_id}:${row.to_id}` };
 		if (collection === 'notes') return { ...row, mentions: row.mentions.split(',').map(map).join(',') };
 		return row;
-	}
+	},
+	// Optional: report failed writes, sync errors and crashes (needs report_client_error, below).
+	reportErrors: { version } // from '$app/env'
 });
 ```
 
@@ -45,24 +47,66 @@ onMount(() => void store.init({ beforeReady: importDevSeed }));
 `store` holds:
 
 - `app`: `local` / `cloud` data sets (`DataSet`: the RxDB database plus a TanStack DB
-  collection per RxDB collection), `ready`, `fatal`.
+  collection per RxDB collection), `ready`, `fatal`, `writeError` (a local write that failed;
+  show it until dismissed) and `persisted` (whether the browser keeps the data for good).
 - `cloud`: `CloudSync`: session (Google, email link), replication, `pendingIds`, `hasPending`,
   `lastSync`, `online`, `active`, `error`, `rejectedWrite`, `roleOf`, `revokedIds`,
   `forceResync`, `signOut`.
 - `ops`: container operations (`createContainer`, `renameContainer`, `makeCloud`, `makeLocal`,
-  `deleteContainer`, `leaveContainer`, `keepRevokedCopy`, `removeRevoked`, `entries`) and the row
+  `deleteContainer`, `leaveContainer`, `keepRevokedCopy`, `removeRevoked`, `entries`,
+  `exportContainers`, `importContainers`) and the row
   helpers they're built from (`insertDoc`, `patch`, `removeDocs`, `docsWhere`, `touch`…).
-- `supabase`: lazy PKCE client and members API (`fetchMembers`, `inviteMember`, `setMemberRole`,
+- `supabase`: PKCE client (`loadClient()`; supabase-js is only downloaded when a session may exist or
+  the user signs in) and members API (`fetchMembers`, `inviteMember`, `setMemberRole`,
   `removeMember`, `leave`, `fetchMyMemberships`) with friendly error messages.
 - `tombstones`: hides deleted rows at once and keeps hiding them if a sync briefly restores
   them; pruned after a week.
 - `prefs`: `DevicePrefs` (default container, "already prompted", collapsed sections). Pass a
   subclass as `prefs` for app-specific ones and override `replaceContainer` to keep them in step.
+- `requestPersistence()`: asks the browser to keep the data (called on start; call it again from
+  a button). Sets `app.persisted`.
 - `resetDevice()`: teardown for a dev wipe.
 
-Without roles everyone is an owner. Table and RPC names default to `<noun>_members` and
+Without roles everyone is an owner.
+
+**Session key.** The session is stored under `<appKey>-auth` (`authStorageKey` to change it), so
+apps sharing an origin, e.g. two GitHub Pages project sites, don't share or end each other's
+sessions. A session stored under supabase-js's default key is moved to the new key once; the old key
+is removed, so a second app on the origin asks to sign in again.
+
+**Lazy loading.** `@supabase/supabase-js` and RxDB's Supabase replication are loaded with dynamic
+`import()`: signed-out users never download them. They load on start when a session is stored or
+the page is a sign-in redirect, and otherwise on sign-in.
+
+**Backups.** `ops.exportContainers([{ id, location }])` returns every row of those containers as a
+JSON-ready object (`format: 'wells-nelson-containers'`, the `appKey`, a version).
+`ops.importContainers(data)` checks a parsed file (format, app, every row against the schema)
+before writing anything, then adds each container as a new local-only container with fresh ids.
+`DeviceDataCard` in `@wells-nelson/interactions/account` is the UI.
+
+**Errors.** `persist()` (TanStack writes) and other quiet failures go through `reportError(kind,
+err)`; failed writes also set `app.writeError`. With `reportErrors`, the store sends each report
+(once per kind and message, at most 20 per page load) to the schema's `report_client_error`
+function with a plain `fetch`, so signed-out devices report too, and also catches uncaught errors
+and rejections. `setErrorReporter` swaps in another destination (e.g. Sentry). Table and RPC names default to `<noun>_members` and
 `get_<noun>_members`; override with e.g. `members: { membersRpc: 'get_list_collaborators' }`.
 
+## A schema other than `public`
+
+To keep an app's tables in their own Postgres schema (handy when several apps share one Supabase
+project), set `supabaseSchema` on the store and the same `schema` on the migration:
+
+```ts
+createSyncedStore({ ..., supabaseSchema: 'my_app' });
+generateMigration({ ..., schema: 'my_app' });
+```
+
+The migration creates the schema with the grants Supabase's API roles need (tables only for
+`authenticated`; `anon` only gets `report_client_error`). In the Supabase
+dashboard, add the schema under **Project Settings → Data API → Exposed schemas**; until then,
+the API can't see it. The store's client reads and writes that schema. It also fixes RxDB's
+realtime subscription, which otherwise always listens on `public`.
+
 ## SQL migration
 
 ```ts
@@ -77,4 +121,19 @@ const sql = generateMigration({
 });
 ```
 
+What it sets up besides the tables:
+
+- `current_email()` returns the signed-in user's email only once it's confirmed (read from
+  `auth.users`), so an unverified sign-up can't claim invites made to that email.
+- RLS on every table; nothing for `anon` except `report_client_error`. Functions are revoked from
+  `public` and `anon` and granted to `authenticated`.
+- Nothing new (rows, members) goes into a deleted container (`is_<noun>_live`); containers can only
+  be created by users with an email. With roles, the last-owner trigger locks the container row, so
+  two owners demoting each other at once can't both succeed; viewers see only the owners and
+  themselves.
+- The members RPC's `active` means "signed in since being invited" (only owners see it, with roles),
+  so it never reveals whether an email has an account.
+- `client_errors` and `report_client_error(...)`: write-only error reports, capped at 300 an hour and
+  kept 30 days.
+
 The sandbox's Data storage page runs this store in the browser and shows the migration.

package/dist/app.svelte.d.ts

@@ -9,5 +9,13 @@ export declare class AppState<D extends DocMap> {
     cloud: DataSet<D> | null;
     ready: boolean;
     fatal: string | null;
+    /** A local write that failed (e.g. storage full). Show it until dismissed. */
+    writeError: string | null;
+    /**
+     * Whether the browser keeps this site's data until the user clears it (`true`), or may evict
+     * it under storage pressure or, in Safari, after 7 days without a visit (`false`). Null until
+     * known, or where the browser can't say.
+     */
+    persisted: boolean | null;
     dataSet(location: Location): DataSet<D>;
 }

package/dist/app.svelte.js

@@ -7,6 +7,14 @@ export class AppState {
     cloud = $state.raw(null);
     ready = $state(false);
     fatal = $state(null);
+    /** A local write that failed (e.g. storage full). Show it until dismissed. */
+    writeError = $state(null);
+    /**
+     * Whether the browser keeps this site's data until the user clears it (`true`), or may evict
+     * it under storage pressure or, in Safari, after 7 days without a visit (`false`). Null until
+     * known, or where the browser can't say.
+     */
+    persisted = $state(null);
     dataSet(location) {
         const ds = location === 'local' ? this.local : this.cloud;
         if (!ds)

package/dist/cloud.svelte.d.ts

@@ -1,11 +1,15 @@
 import type { User } from '@supabase/supabase-js';
 import type { AppState } from './app.svelte.js';
 import { type StorageFactory } from './database.js';
-import type { SupabaseApi } from './supabase.js';
+import { type SupabaseApi } from './supabase.js';
 import { type DocMap, type Role, type StoreSchema } from './types.js';
 /** Push errors caused by the server refusing the write (RLS, triggers), not by connectivity. */
 export declare function isRejection(err: unknown): boolean;
-export declare function errorMessage(err: unknown): string;
+/**
+ * A replication or API error as one line for the UI. With `schema`, a schema the Supabase API
+ * doesn't expose is reported as the setting to change.
+ */
+export declare function errorMessage(err: unknown, schema?: string): string;
 export interface CloudSyncOptions<D extends DocMap> {
     /** Prefix for database names and localStorage keys, e.g. 'demo'. */
     appKey: string;

package/dist/cloud.svelte.js

@@ -1,8 +1,9 @@
-import { replicateSupabase } from 'rxdb/plugins/replication-supabase';
 import { tick } from 'svelte';
 import { openDatabase } from './database.js';
 import { createDataSet, disposeDataSet } from './dataset.js';
+import { reportError } from './errors.js';
 import { Persisted } from './persisted.svelte.js';
+import { replicationClient, schemaNotExposed } from './supabase.js';
 import { containerIdOf } from './types.js';
 const emptyState = () => ({ pending: {}, blocked: [], revoked: [], roles: {}, lastSync: null });
 const MEMBERSHIP_CHECK_INTERVAL = 30_000;
@@ -15,10 +16,16 @@ export function isRejection(err) {
     // 42501: RLS violation; P0001: raised by a trigger (e.g. last owner); 23xxx: constraint violations.
     return !!code && (code === '42501' || code === 'P0001' || code.startsWith('23'));
 }
-export function errorMessage(err) {
+/**
+ * A replication or API error as one line for the UI. With `schema`, a schema the Supabase API
+ * doesn't expose is reported as the setting to change.
+ */
+export function errorMessage(err, schema) {
     if (err && typeof err === 'object') {
         const e = err;
-        return e.parameters?.errors?.[0]?.message ?? e.message ?? String(err);
+        const inner = e.parameters?.errors?.[0];
+        const unexposed = schema ? (schemaNotExposed(inner, schema) ?? schemaNotExposed(e, schema)) : null;
+        return unexposed ?? inner?.message ?? e.message ?? String(err);
     }
     return String(err);
 }
@@ -57,6 +64,7 @@ export class CloudSync {
     #lastMembershipCheck = 0;
     #signingOut = false;
     #queue = Promise.resolve();
+    #attached = null;
     constructor(options) {
         this.#appKey = options.appKey;
         this.#schema = options.schema;
@@ -119,7 +127,21 @@ export class CloudSync {
             });
             window.addEventListener('offline', () => (this.online = false));
         }
-        const sb = this.#sb.getClient();
+        // supabase-js (and the replication) only load when there may be a session: a stored one or
+        // a sign-in redirect. Otherwise they load when the user signs in.
+        if (this.#sb.mayHaveSession())
+            await this.#attach();
+    }
+    /** Load the client, restore its session and follow auth changes (once). */
+    #attach() {
+        this.#attached ??= this.#doAttach().catch((err) => {
+            this.#attached = null;
+            throw err;
+        });
+        return this.#attached;
+    }
+    async #doAttach() {
+        const sb = await this.#sb.loadClient();
         if (!sb)
             return;
         const { data } = await sb.auth.getSession();
@@ -160,11 +182,12 @@ export class CloudSync {
         this.user = user;
         this.sessionExpired = false;
         this.#app.cloud = createDataSet('cloud', db, this.#schema);
-        this.#startReplication(db);
+        await this.#startReplication(db);
         this.#scheduleSettle();
     }
-    #startReplication(db) {
-        const sb = this.#sb.getClient();
+    async #startReplication(db) {
+        const { replicateSupabase } = await import('rxdb/plugins/replication-supabase');
+        const sb = replicationClient(this.#sb.getClient(), this.#sb.schema);
         this.#schema.collections.forEach((name, index) => {
             const rep = replicateSupabase({
                 replicationIdentifier: `supabase-${name}`,
@@ -183,9 +206,12 @@ export class CloudSync {
             });
             this.#replications.push(rep);
             this.#subscriptions.push(rep.error$.subscribe((err) => {
-                this.error = errorMessage(err);
+                this.error = errorMessage(err, this.#sb.schema);
                 if (isRejection(err))
                     this.rejectedWrite = this.error;
+                // Offline failures are expected; anything else is worth knowing about.
+                if (isRejection(err) || this.online)
+                    reportError('sync', this.error, `${name} ${err.parameters?.direction ?? ''}`);
             }), rep.active$.subscribe((isActive) => {
                 if (isActive)
                     this.#activeReps.add(index);
@@ -307,7 +333,7 @@ export class CloudSync {
             });
         }
         catch (err) {
-            this.error = errorMessage(err);
+            this.error = errorMessage(err, this.#sb.schema);
         }
     }
     async forceResync() {
@@ -317,6 +343,7 @@ export class CloudSync {
         await this.checkMemberships(true);
     }
     async signInWithGoogle(redirectTo) {
+        await this.#attach();
         const sb = this.#sb.getClient();
         if (!sb)
             throw new Error('Cloud sync is not configured.');
@@ -326,6 +353,7 @@ export class CloudSync {
     }
     /** Email a magic sign-in link. The link has to be opened in this browser (PKCE). */
     async signInWithEmail(email, redirectTo) {
+        await this.#attach();
         const sb = this.#sb.getClient();
         if (!sb)
             throw new Error('Cloud sync is not configured.');

package/dist/containers.d.ts

@@ -29,6 +29,8 @@ export interface ContainerOpsOptions<D extends DocMap, C extends CollectionName<
         [N in CollectionName<D>]?: (keyof D[N] & string)[];
     };
     remap?: RemapHook<D>;
+    /** The store's appKey, written into exports and checked on import. */
+    appKey?: string;
 }
 /** A container as listed by the app (one entry even while it moves between data sets). */
 export interface ContainerEntry<T> {
@@ -36,10 +38,23 @@ export interface ContainerEntry<T> {
     location: Location;
     role: Role;
 }
-/** Persisting a TanStack DB transaction in the background, logging failures. */
+/**
+ * Persisting a TanStack DB transaction in the background. A failure is reported and shown
+ * (`app.writeError` through the store), not just logged.
+ */
 export declare function persist(tx: {
     when(state: 'settled'): Promise<unknown>;
 }): void;
+/** The file format of `exportContainers`. */
+export interface ContainerExport {
+    format: 'wells-nelson-containers';
+    version: 1;
+    /** The store's appKey: a file only imports into the app that wrote it. */
+    app: string;
+    exportedAt: string;
+    /** One entry per container: every row of it, by collection. */
+    containers: Record<string, Record<string, unknown>[]>[];
+}
 export declare const now: () => number;
 export declare const uid: () => `${string}-${string}-${string}-${string}-${string}`;
 export type ContainerOps<D extends DocMap, C extends CollectionName<D> = CollectionName<D>> = ReturnType<typeof createContainerOps<D, C>>;
@@ -64,6 +79,11 @@ export declare function createContainerOps<D extends DocMap, C extends Collectio
         containerId: string;
     };
     copyContainer: (from: DataSet<D>, to: DataSet<D>, containerId: string, newIds: boolean) => Promise<string>;
+    exportContainers: (items: {
+        id: string;
+        location: Location;
+    }[]) => Promise<ContainerExport>;
+    importContainers: (data: unknown) => Promise<string[]>;
     makeCloud: (containerId: string) => Promise<void>;
     makeLocal: (containerId: string) => Promise<string>;
     deleteContainer: (ds: DataSet<D>, containerId: string) => Promise<void>;

package/dist/containers.js

@@ -1,6 +1,10 @@
-/** Persisting a TanStack DB transaction in the background, logging failures. */
+import { writeFailed } from './errors.js';
+/**
+ * Persisting a TanStack DB transaction in the background. A failure is reported and shown
+ * (`app.writeError` through the store), not just logged.
+ */
 export function persist(tx) {
-    tx.when('settled').catch((err) => console.error('Failed to save change', err));
+    tx.when('settled').catch(writeFailed);
 }
 export const now = () => Date.now();
 export const uid = () => crypto.randomUUID();
@@ -142,6 +146,80 @@ export function createContainerOps(options) {
         await insertContainerDocs(to, rows);
         return cid;
     }
+    /**
+     * Every row of the given containers as one JSON-ready object (a backup the user keeps). Each
+     * container is read from the data set it lives in.
+     */
+    async function exportContainers(items) {
+        const containers = [];
+        for (const { id, location } of items) {
+            const docs = await readContainer(app.dataSet(location), id);
+            if (docs[container].length === 0)
+                continue;
+            containers.push(docs);
+        }
+        return {
+            format: 'wells-nelson-containers',
+            version: 1,
+            app: options.appKey ?? '',
+            exportedAt: new Date().toISOString(),
+            containers
+        };
+    }
+    /** Keep only the schema's fields, and only with the schema's types; anything else is not a backup. */
+    function cleanRow(name, row) {
+        const props = schema.schemas[name].properties;
+        if (!row || typeof row !== 'object')
+            throw new Error('This file is not a backup of this app.');
+        const out = {};
+        for (const [key, prop] of Object.entries(props)) {
+            const value = row[key];
+            const type = prop.type === 'number' ? 'number' : prop.type === 'boolean' ? 'boolean' : 'string';
+            if (typeof value !== type || (type === 'number' && !Number.isFinite(value))) {
+                throw new Error(`This backup has an invalid ${name} row (${key}).`);
+            }
+            out[key] = value;
+        }
+        return out;
+    }
+    /**
+     * Add every container of an `exportContainers` file to this device as new local-only
+     * containers (fresh ids, so importing twice makes two copies and nothing is overwritten).
+     * Returns the new container ids.
+     */
+    async function importContainers(data) {
+        const file = data;
+        if (!file || file.format !== 'wells-nelson-containers' || !Array.isArray(file.containers)) {
+            throw new Error('This file is not a backup of this app.');
+        }
+        if (file.version !== 1)
+            throw new Error('This backup was made by a newer version of the app. Update the app first.');
+        if (options.appKey && file.app !== options.appKey)
+            throw new Error('This backup is from a different app.');
+        // Check everything before writing anything.
+        const parsed = file.containers.map((entry) => {
+            const docs = {};
+            for (const name of collections) {
+                const rows = entry[name] ?? [];
+                if (!Array.isArray(rows))
+                    throw new Error('This file is not a backup of this app.');
+                docs[name] = rows.map((r) => cleanRow(name, r));
+            }
+            const head = docs[container][0];
+            if (docs[container].length !== 1 || !head)
+                throw new Error('This file is not a backup of this app.');
+            return { docs, id: head.id };
+        });
+        const local = app.dataSet('local');
+        const ids = [];
+        for (const { docs, id } of parsed) {
+            const { rows, containerId } = remapContainer(docs, id, true);
+            await insertContainerDocs(local, rows);
+            prefs.markPrompted([containerId]);
+            ids.push(containerId);
+        }
+        return ids;
+    }
     /** Remove a cloud container from this device only; nothing is deleted on Supabase. */
     async function purgeCloudContainer(containerId) {
         const ds = app.dataSet('cloud');
@@ -272,6 +350,8 @@ export function createContainerOps(options) {
         insertContainerDocs,
         remapContainer,
         copyContainer,
+        exportContainers,
+        importContainers,
         makeCloud,
         makeLocal,
         deleteContainer,

package/dist/errors.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Client error reporting. Library code calls `reportError` where something fails without the
+ * user necessarily noticing (a local write, sync, device prefs); the store installs a reporter
+ * that sends each report to the app's Supabase project (see `remoteReporter`). Reports are
+ * de-duplicated by kind and message and capped per page load.
+ */
+export type ErrorKind = 'write' | 'sync' | 'prefs' | 'unhandled' | (string & {});
+export interface ErrorReport {
+    kind: ErrorKind;
+    message: string;
+    /** Extra context, e.g. a stack trace. */
+    detail?: string;
+}
+export type ErrorReporter = (report: ErrorReport) => void;
+/** Where reports go (null to stop reporting). */
+export declare function setErrorReporter(next: ErrorReporter | null): void;
+/** Forget what was reported (tests). */
+export declare function resetErrorReports(): void;
+export declare function describeError(err: unknown): {
+    message: string;
+    detail?: string;
+};
+/** Report an error once per kind and message (and at most 20 per page load). Never throws. */
+export declare function reportError(kind: ErrorKind, err: unknown, detail?: string): void;
+/** Called with a message whenever a local write fails (see `persist`). Returns an unsubscribe. */
+export declare function onWriteError(listener: (message: string) => void): () => undefined;
+/** A local write failed: tell listeners (the store shows it) and report it. */
+export declare function writeFailed(err: unknown): void;
+export interface RemoteReporterOptions {
+    supabaseUrl: string;
+    supabaseAnonKey: string;
+    /** Postgres schema holding `report_client_error` (see the generated migration). */
+    schema: string;
+    /** App name stored with each report, e.g. the store's appKey. */
+    app: string;
+    /** The deployed version, stored with each report. */
+    version?: string;
+}
+/**
+ * Sends reports to the `report_client_error` function of the app's Supabase schema with a plain
+ * `fetch` (no supabase-js needed, so signed-out devices report too). Only the path of the page
+ * is sent, never its query or any user data beyond the error itself.
+ */
+export declare function remoteReporter(options: RemoteReporterOptions): ErrorReporter;

package/dist/errors.js

@@ -0,0 +1,101 @@
+/**
+ * Client error reporting. Library code calls `reportError` where something fails without the
+ * user necessarily noticing (a local write, sync, device prefs); the store installs a reporter
+ * that sends each report to the app's Supabase project (see `remoteReporter`). Reports are
+ * de-duplicated by kind and message and capped per page load.
+ */
+const MAX_REPORTS = 20;
+let reporter = null;
+let sent = 0;
+const seen = new Set();
+const writeListeners = new Set();
+/** Where reports go (null to stop reporting). */
+export function setErrorReporter(next) {
+    reporter = next;
+}
+/** Forget what was reported (tests). */
+export function resetErrorReports() {
+    sent = 0;
+    seen.clear();
+}
+export function describeError(err) {
+    if (err instanceof Error)
+        return { message: err.message || err.name, detail: err.stack };
+    if (err && typeof err === 'object') {
+        const e = err;
+        if (typeof e.message === 'string')
+            return { message: e.message, detail: safeJson(err) };
+        return { message: safeJson(err) ?? String(err) };
+    }
+    return { message: String(err) };
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Report an error once per kind and message (and at most 20 per page load). Never throws. */
+export function reportError(kind, err, detail) {
+    const described = describeError(err);
+    const key = `${kind}:${described.message}`;
+    if (seen.has(key) || sent >= MAX_REPORTS)
+        return;
+    seen.add(key);
+    if (!reporter)
+        return;
+    sent++;
+    try {
+        reporter({ kind, message: described.message, detail: detail ?? described.detail });
+    }
+    catch {
+        /* reporting must never break the app */
+    }
+}
+/** Called with a message whenever a local write fails (see `persist`). Returns an unsubscribe. */
+export function onWriteError(listener) {
+    writeListeners.add(listener);
+    return () => void writeListeners.delete(listener);
+}
+/** A local write failed: tell listeners (the store shows it) and report it. */
+export function writeFailed(err) {
+    console.error('Failed to save change', err);
+    reportError('write', err);
+    const { message } = describeError(err);
+    for (const listener of writeListeners)
+        listener(message);
+}
+/**
+ * Sends reports to the `report_client_error` function of the app's Supabase schema with a plain
+ * `fetch` (no supabase-js needed, so signed-out devices report too). Only the path of the page
+ * is sent, never its query or any user data beyond the error itself.
+ */
+export function remoteReporter(options) {
+    const url = `${options.supabaseUrl.replace(/\/$/, '')}/rest/v1/rpc/report_client_error`;
+    return ({ kind, message, detail }) => {
+        if (typeof fetch === 'undefined')
+            return;
+        void fetch(url, {
+            method: 'POST',
+            keepalive: true,
+            headers: {
+                apikey: options.supabaseAnonKey,
+                Authorization: `Bearer ${options.supabaseAnonKey}`,
+                'Content-Type': 'application/json',
+                'Content-Profile': options.schema
+            },
+            body: JSON.stringify({
+                p_app: options.app,
+                p_version: options.version ?? '',
+                p_kind: kind,
+                p_message: message.slice(0, 500),
+                p_detail: (detail ?? '').slice(0, 4000),
+                p_path: typeof location === 'undefined' ? '' : location.pathname
+            })
+        }).catch(() => {
+            /* offline or not set up: drop it */
+        });
+    };
+}

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 export { AppState } from './app.svelte.js';
 export { CloudSync, errorMessage, isRejection, type CloudSyncOptions } from './cloud.svelte.js';
-export { createContainerOps, now, persist, uid, type ContainerDocs, type ContainerEntry, type ContainerOps, type ContainerOpsOptions, type RemapHook } from './containers.js';
+export { createContainerOps, now, type ContainerExport, persist, uid, type ContainerDocs, type ContainerEntry, type ContainerOps, type ContainerOpsOptions, type RemapHook } from './containers.js';
 export { docsEqual, lastWriteWins, openDatabase, setStorageFactory, type Collections, type Database, type OpenDatabaseOptions, type StorageFactory } from './database.js';
 export { createDataSet, disposeDataSet, type DataSet, type TSCollection } from './dataset.js';
 export { envConfig, type EnvConfig } from './env.js';
+export { describeError, onWriteError, remoteReporter, reportError, resetErrorReports, setErrorReporter, writeFailed, type ErrorKind, type ErrorReport, type ErrorReporter, type RemoteReporterOptions } from './errors.js';
 export { Persisted } from './persisted.svelte.js';
 export { DevicePrefs, defaultPrefsKeys, type DevicePrefsKeys } from './prefs.svelte.js';
 export { field, flatSchema, type FieldSpec } from './schema.js';
 export { createSyncedStore, type SyncedStore, type SyncedStoreConfig } from './store.js';
-export { createSupabaseApi, friendlyError, type Member, type MembersConfig, type SupabaseApi } from './supabase.js';
+export { adoptSession, createSupabaseApi, defaultStorageKey, friendlyError, replicationClient, schemaNotExposed, type Member, type MembersConfig, type SupabaseApi, type SupabaseOptions } from './supabase.js';
 export { Tombstones } from './tombstones.svelte.js';
 export { containerIdOf, type CollectionName, type DocBase, type DocMap, type Location, type Nouns, type Role, type StoreSchema } from './types.js';

package/dist/index.js

@@ -4,10 +4,11 @@ export { createContainerOps, now, persist, uid } from './containers.js';
 export { docsEqual, lastWriteWins, openDatabase, setStorageFactory } from './database.js';
 export { createDataSet, disposeDataSet } from './dataset.js';
 export { envConfig } from './env.js';
+export { describeError, onWriteError, remoteReporter, reportError, resetErrorReports, setErrorReporter, writeFailed } from './errors.js';
 export { Persisted } from './persisted.svelte.js';
 export { DevicePrefs, defaultPrefsKeys } from './prefs.svelte.js';
 export { field, flatSchema } from './schema.js';
 export { createSyncedStore } from './store.js';
-export { createSupabaseApi, friendlyError } from './supabase.js';
+export { adoptSession, createSupabaseApi, defaultStorageKey, friendlyError, replicationClient, schemaNotExposed } from './supabase.js';
 export { Tombstones } from './tombstones.svelte.js';
 export { containerIdOf } from './types.js';

package/dist/persisted.svelte.d.ts

@@ -1,4 +1,7 @@
-/** Reactive value mirrored to localStorage. Storage failures (private mode, quota) are ignored. */
+/**
+ * Reactive value mirrored to localStorage. Storage failures (private mode, quota) don't break the
+ * app; a failed write is reported once.
+ */
 export declare class Persisted<T> {
     #private;
     constructor(key: string, initial: T);

package/dist/persisted.svelte.js

@@ -1,4 +1,8 @@
-/** Reactive value mirrored to localStorage. Storage failures (private mode, quota) are ignored. */
+import { reportError } from './errors.js';
+/**
+ * Reactive value mirrored to localStorage. Storage failures (private mode, quota) don't break the
+ * app; a failed write is reported once.
+ */
 export class Persisted {
     #key;
     #value = $state();
@@ -31,8 +35,8 @@ export class Persisted {
         try {
             localStorage.setItem(key, JSON.stringify(value));
         }
-        catch {
-            /* ignore */
+        catch (err) {
+            reportError('prefs', err);
         }
     }
     static remove(key) {

package/dist/sql.d.ts

@@ -1,9 +1,11 @@
 /**
  * Generates the Supabase migration for an app's tables: `_deleted` / `_modified` replication
- * columns with their trigger and checkpoint index, `current_email()`, a membership table with
- * an `is_<noun>_member` helper and RLS on every table, the creator-becomes-member trigger, the
- * "touch rows on new share" trigger, the members RPC (active / pending) and the realtime
- * publication. With `roles`, members are viewer / editor / owner and the last owner is protected.
+ * columns with their trigger and checkpoint index, `current_email()` (confirmed emails only), a
+ * membership table with an `is_<noun>_member` helper and RLS on every table, the
+ * creator-becomes-member trigger, the "touch rows on new share" trigger, the members RPC
+ * (active / pending), a write-only `client_errors` table with its `report_client_error`
+ * function, and the realtime publication. With `roles`, members are viewer / editor / owner and
+ * the last owner is protected. Signed-out callers (`anon`) get nothing but `report_client_error`.
  *
  * Pure string building: no database or Svelte dependency, so it runs from a plain Node script.
  */
@@ -32,6 +34,12 @@ export interface MigrationConfig {
     roles?: boolean;
     membersTable?: string;
     membersRpc?: string;
+    /**
+     * Postgres schema for every table, type and function (default 'public'). Any other schema is
+     * created with the grants Supabase needs; also expose it in the project's Data API settings and
+     * pass the same name as `supabaseSchema` to the store.
+     */
+    schema?: string;
 }
 /**
  * Turn RxDB flat schemas into migration tables. `refs` fields (and the container field) become