silosdk 0.0.0 → 0.0.1

package/dist/local/commit.mjs

@@ -0,0 +1,349 @@
+import { useConfig } from "./config.mjs";
+import { getQueryStoreInstance } from "./view.mjs";
+import { isAssetValue, isResolvedAsset, resolvePendingAsset } from "./storage.mjs";
+import { useSQLiteContext } from "expo-sqlite";
+import { nanoid } from "nanoid/non-secure";
+
+//#region src/local/commit.ts
+function isCrudOp(op) {
+	return op.kind === "add" || op.kind === "update" || op.kind === "remove";
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectResolvedAssetKeys(value, out) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectResolvedAssetKeys(item, out);
+		return;
+	}
+	if (!isObject(value)) return;
+	if (isResolvedAsset(value)) {
+		out.add(value.key);
+		return;
+	}
+	for (const nested of Object.values(value)) collectResolvedAssetKeys(nested, out);
+}
+function buildAssetCleanupTasks(oldValue, newValue, scope) {
+	const oldKeys = /* @__PURE__ */ new Set();
+	const newKeys = /* @__PURE__ */ new Set();
+	collectResolvedAssetKeys(oldValue, oldKeys);
+	collectResolvedAssetKeys(newValue, newKeys);
+	const tasks = [];
+	for (const key of oldKeys) if (!newKeys.has(key)) tasks.push({
+		key,
+		scope
+	});
+	return tasks;
+}
+async function resolveAssetsDeep(value, scope, url, getToken) {
+	if (Array.isArray(value)) {
+		const out$1 = [];
+		for (const item of value) out$1.push(await resolveAssetsDeep(item, scope, url, getToken));
+		return out$1;
+	}
+	if (!isObject(value)) return value;
+	if (isAssetValue(value)) return resolvePendingAsset(value, scope, url, getToken);
+	const out = {};
+	for (const [k, v] of Object.entries(value)) out[k] = await resolveAssetsDeep(v, scope, url, getToken);
+	return out;
+}
+async function resolveAssetsInOps(ops, url, getToken) {
+	const resolved = [];
+	for (const op of ops) {
+		if (!isCrudOp(op)) {
+			resolved.push(op);
+			continue;
+		}
+		if (op.kind === "remove") {
+			resolved.push(op);
+			continue;
+		}
+		const scope = op.scope ?? "private";
+		if (op.kind === "add") {
+			const value$1 = await resolveAssetsDeep(op.value, scope, url, getToken);
+			resolved.push({
+				...op,
+				value: value$1
+			});
+			continue;
+		}
+		const value = await resolveAssetsDeep(op.value, scope, url, getToken);
+		resolved.push({
+			...op,
+			value
+		});
+	}
+	return resolved;
+}
+async function getExistingRowData(db, viewName, id) {
+	const row = await db.getFirstAsync(`SELECT data FROM views WHERE id = ? AND view = ?`, [id, viewName]);
+	if (!row?.data) return null;
+	try {
+		return JSON.parse(row.data);
+	} catch {
+		return null;
+	}
+}
+function mergeForUpdate(existing, patch) {
+	if (!isObject(existing)) return patch;
+	if (!isObject(patch)) return existing;
+	return {
+		...existing,
+		...patch
+	};
+}
+async function planAssetCleanupFromOps(db, ops) {
+	const tasks = [];
+	for (const op of ops) {
+		if (!isCrudOp(op)) continue;
+		const scope = op.scope ?? "private";
+		if (op.kind === "remove") {
+			const existing = await getExistingRowData(db, op.view.name, op.id);
+			tasks.push(...buildAssetCleanupTasks(existing, null, scope));
+			continue;
+		}
+		if (op.kind === "update") {
+			const existing = await getExistingRowData(db, op.view.name, op.id);
+			const merged = mergeForUpdate(existing, op.value);
+			tasks.push(...buildAssetCleanupTasks(existing, merged, scope));
+			continue;
+		}
+	}
+	return tasks;
+}
+async function performAssetCleanup(tasks, url, getToken) {
+	if (!url || tasks.length === 0) return;
+	const unique = /* @__PURE__ */ new Map();
+	for (const t of tasks) unique.set(`${t.scope}:${t.key}`, t);
+	const headers = {};
+	if (getToken) {
+		const token = await getToken();
+		if (token) headers.Authorization = `Bearer ${token}`;
+	}
+	await Promise.all(Array.from(unique.values()).map(async ({ key }) => {
+		const res = await fetch(`${url}/storage/${encodeURIComponent(key)}`, {
+			method: "DELETE",
+			headers
+		});
+		if (![
+			204,
+			404,
+			401,
+			403
+		].includes(res.status)) console.warn(`[silosdk] asset cleanup failed for key ${key}: ${res.status}`);
+	}));
+}
+function useCommit() {
+	const db = useSQLiteContext();
+	const config = useConfig();
+	const { subscribers, syncAdapter } = config;
+	const ops = [];
+	const touchedViews = /* @__PURE__ */ new Set();
+	function view(v, idOrOpts, opts) {
+		const id = typeof idOrOpts === "string" ? idOrOpts : void 0;
+		const scope = (typeof idOrOpts === "object" ? idOrOpts?.scope : opts?.scope) ?? "private";
+		if (id) return {
+			update: (value) => {
+				touchedViews.add(v);
+				ops.push({
+					kind: "update",
+					view: v,
+					id,
+					value,
+					scope
+				});
+			},
+			remove: () => {
+				touchedViews.add(v);
+				ops.push({
+					kind: "remove",
+					view: v,
+					id,
+					scope
+				});
+			},
+			child: (subview) => ({
+				add: (cid) => {
+					touchedViews.add(v);
+					touchedViews.add(subview);
+					ops.push({
+						kind: "link",
+						parent: {
+							view: v,
+							id
+						},
+						child: {
+							view: subview,
+							id: cid
+						},
+						scope
+					});
+				},
+				remove: (cid) => {
+					touchedViews.add(v);
+					touchedViews.add(subview);
+					ops.push({
+						kind: "unlink",
+						parent: {
+							view: v,
+							id
+						},
+						child: {
+							view: subview,
+							id: cid
+						},
+						scope
+					});
+				}
+			})
+		};
+		return { add: (value) => {
+			touchedViews.add(v);
+			const id$1 = nanoid();
+			ops.push({
+				kind: "add",
+				view: v,
+				id: id$1,
+				value,
+				scope
+			});
+			return id$1;
+		} };
+	}
+	return async (handler) => {
+		await handler({ view });
+		const resolvedOps = await resolveAssetsInOps(ops, config.url, config.getToken);
+		const cleanupTasks = await planAssetCleanupFromOps(db, resolvedOps);
+		const privateOps = resolvedOps.filter((op) => (op.scope ?? "private") === "private");
+		const publicOps = resolvedOps.filter((op) => op.scope === "public");
+		const syncOps = privateOps.length > 0 ? await applyOpsToSqlite(db, privateOps) : [];
+		for (const sub of subscribers) for (const coll of touchedViews) if (coll.scope !== "public" && sub[0].includes(coll.name)) {
+			sub[1].update();
+			break;
+		}
+		if (syncAdapter && syncOps.length > 0) await syncAdapter.send({ ops: syncOps });
+		if (publicOps.length > 0) {
+			const qs = getQueryStoreInstance();
+			const url = config.url;
+			const getToken = config.getToken;
+			const publicViewNames = new Set(publicOps.map((op) => op.kind === "link" || op.kind === "unlink" ? op.parent.view.name : op.view.name));
+			qs.invalidate(publicViewNames);
+			if (url) {
+				const byView = /* @__PURE__ */ new Map();
+				for (const op of publicOps) {
+					const viewName = op.kind === "link" || op.kind === "unlink" ? op.parent.view.name : op.view.name;
+					const existing = byView.get(viewName) ?? [];
+					existing.push(op);
+					byView.set(viewName, existing);
+				}
+				const headers = { "Content-Type": "application/json" };
+				if (getToken) headers["Authorization"] = `Bearer ${await getToken()}`;
+				await Promise.all(Array.from(byView.entries()).map(async ([viewName, viewOps]) => {
+					const res = await fetch(`${url}/public/${viewName}`, {
+						method: "POST",
+						headers,
+						body: JSON.stringify({ ops: viewOps })
+					});
+					if (!res.ok) {
+						qs.invalidate(new Set([viewName]));
+						throw new Error(`Public write to ${viewName} failed: ${res.status}`);
+					}
+				}));
+			}
+		}
+		await performAssetCleanup(cleanupTasks, config.url, config.getToken);
+	};
+}
+async function applyOpsToSqlite(db, ops) {
+	const syncOps = [];
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	await db.withTransactionAsync(async () => {
+		for (const op of ops) {
+			if (op.kind === "add" && !!op.value) {
+				const version = 1;
+				await db.runAsync(`INSERT INTO views (id, view, data, createdAt, updatedAt, version) VALUES (?, ?, ?, ?, ?, ?);`, [
+					op.id,
+					op.view.name,
+					JSON.stringify(op.value),
+					timestamp,
+					timestamp,
+					version
+				]);
+				syncOps.push({
+					...op,
+					version,
+					timestamp
+				});
+			}
+			if (op.kind === "update" && !!op.id && !!op.value) {
+				await db.runAsync(`UPDATE views
+             SET data = jsonb_patch(data, ?), updatedAt = ?, version = version + 1
+             WHERE id = ? AND view = ?;`, [
+					JSON.stringify(op.value),
+					timestamp,
+					op.id,
+					op.view.name
+				]);
+				const result = await db.getFirstAsync(`SELECT version, data FROM views WHERE id = ? AND view = ?`, [op.id, op.view.name]);
+				const version = result?.version ?? 1;
+				const fullData = result?.data ? JSON.parse(result.data) : op.value;
+				syncOps.push({
+					...op,
+					value: fullData,
+					version,
+					timestamp
+				});
+			}
+			if (op.kind === "remove" && !!op.id) {
+				const version = ((await db.getFirstAsync(`SELECT version FROM views WHERE id = ? AND view = ?`, [op.id, op.view.name]))?.version ?? 0) + 1;
+				await db.runAsync(`DELETE FROM views WHERE id = ? AND view = ?;`, [op.id, op.view.name]);
+				await db.runAsync(`DELETE FROM relations
+                WHERE (parent = ? AND pid = ?)
+                   OR (child = ? AND cid = ?);`, [
+					op.view.name,
+					op.id,
+					op.view.name,
+					op.id
+				]);
+				syncOps.push({
+					...op,
+					version,
+					timestamp
+				});
+			}
+			if (op.kind === "link") {
+				await db.runAsync(`INSERT INTO relations (parent, pid, child, cid) VALUES (?, ?, ?, ?);`, [
+					op.parent.view.name,
+					op.parent.id,
+					op.child.view.name,
+					op.child.id
+				]);
+				syncOps.push({
+					...op,
+					version: 0,
+					timestamp
+				});
+			}
+			if (op.kind === "unlink") {
+				await db.runAsync(`DELETE FROM relations WHERE parent = ? AND pid = ? AND child = ? AND cid = ?;`, [
+					op.parent.view.name,
+					op.parent.id,
+					op.child.view.name,
+					op.child.id
+				]);
+				syncOps.push({
+					...op,
+					version: 0,
+					timestamp
+				});
+			}
+		}
+	}).catch((err) => {
+		console.error(err);
+		throw err;
+	});
+	return syncOps;
+}
+
+//#endregion
+export { useCommit };

package/dist/local/config.cjs

@@ -0,0 +1,17 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let react = require("react");
+
+//#region src/local/config.ts
+const Context = (0, react.createContext)({
+	subscribers: /* @__PURE__ */ new Map(),
+	authReadyPromise: Promise.resolve()
+});
+function useConfig() {
+	const ctx = (0, react.useContext)(Context);
+	if (!ctx) throw new Error("silosdk <Provider> is missing above this component");
+	return ctx;
+}
+
+//#endregion
+exports.Context = Context;
+exports.useConfig = useConfig;

package/dist/local/config.mjs

@@ -0,0 +1,15 @@
+import { createContext, useContext } from "react";
+
+//#region src/local/config.ts
+const Context = createContext({
+	subscribers: /* @__PURE__ */ new Map(),
+	authReadyPromise: Promise.resolve()
+});
+function useConfig() {
+	const ctx = useContext(Context);
+	if (!ctx) throw new Error("silosdk <Provider> is missing above this component");
+	return ctx;
+}
+
+//#endregion
+export { Context, useConfig };

package/dist/local/index.cjs

@@ -0,0 +1,16 @@
+const require_schema_index = require('../schema/index.cjs');
+const require_cloudflare = require('./adapters/cloudflare.cjs');
+const require_view = require('./view.cjs');
+const require_auth_context = require('./auth-context.cjs');
+const require_provider = require('./provider.cjs');
+const require_storage = require('./storage.cjs');
+const require_commit = require('./commit.cjs');
+
+exports.CloudflareSyncAdapter = require_cloudflare.CloudflareSyncAdapter;
+exports.Provider = require_provider.Provider;
+exports.useAssetUrl = require_storage.useAssetUrl;
+exports.useAuth = require_auth_context.useAuth;
+exports.useCommit = require_commit.useCommit;
+exports.useListView = require_view.useListView;
+exports.useView = require_view.useView;
+exports.view = require_schema_index.view;

package/dist/local/index.d.cts

@@ -0,0 +1,10 @@
+import { Provider } from "./provider.cjs";
+import { Infer, View, view } from "../schema/index.cjs";
+import { useListView, useView } from "./view.cjs";
+import { MergeFn, SyncAdapter, SyncOp, SyncPayload } from "./sync.cjs";
+import { useCommit } from "./commit.cjs";
+import { AuthState, AuthUser } from "./auth.cjs";
+import { useAuth } from "./auth-context.cjs";
+import { useAssetUrl } from "./storage.cjs";
+import { CloudflareSyncAdapter } from "./adapters/cloudflare.cjs";
+export { type AuthState, type AuthUser, CloudflareSyncAdapter, type Infer, type MergeFn, Provider, type SyncAdapter, type SyncOp, type SyncPayload, type View, useAssetUrl, useAuth, useCommit, useListView, useView, view };

package/dist/local/index.d.mts

@@ -0,0 +1,10 @@
+import { Provider } from "./provider.mjs";
+import { Infer, View, view } from "../schema/index.mjs";
+import { useListView, useView } from "./view.mjs";
+import { MergeFn, SyncAdapter, SyncOp, SyncPayload } from "./sync.mjs";
+import { useCommit } from "./commit.mjs";
+import { AuthState, AuthUser } from "./auth.mjs";
+import { useAuth } from "./auth-context.mjs";
+import { useAssetUrl } from "./storage.mjs";
+import { CloudflareSyncAdapter } from "./adapters/cloudflare.mjs";
+export { type AuthState, type AuthUser, CloudflareSyncAdapter, type Infer, type MergeFn, Provider, type SyncAdapter, type SyncOp, type SyncPayload, type View, useAssetUrl, useAuth, useCommit, useListView, useView, view };

package/dist/local/index.mjs

@@ -0,0 +1,9 @@
+import { view } from "../schema/index.mjs";
+import { CloudflareSyncAdapter } from "./adapters/cloudflare.mjs";
+import { useListView, useView } from "./view.mjs";
+import { useAuth } from "./auth-context.mjs";
+import { Provider } from "./provider.mjs";
+import { useAssetUrl } from "./storage.mjs";
+import { useCommit } from "./commit.mjs";
+
+export { CloudflareSyncAdapter, Provider, useAssetUrl, useAuth, useCommit, useListView, useView, view };

package/dist/local/provider.cjs

@@ -0,0 +1,204 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_sync = require('./sync.cjs');
+const require_cloudflare = require('./adapters/cloudflare.cjs');
+const require_auth = require('./auth.cjs');
+const require_config = require('./config.cjs');
+const require_view = require('./view.cjs');
+const require_auth_context = require('./auth-context.cjs');
+let react = require("react");
+let expo_sqlite = require("expo-sqlite");
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/local/provider.tsx
+function Provider(props) {
+	const { config } = props;
+	const subscribers = (0, react.useRef)(/* @__PURE__ */ new Map()).current;
+	const url = config?.url;
+	const prodUrl = config?.prodUrl;
+	const [user, setUser] = (0, react.useState)(null);
+	const [isLoading, setIsLoading] = (0, react.useState)(true);
+	const [authReady, setAuthReady] = (0, react.useState)(false);
+	const tokenRef = (0, react.useRef)(null);
+	const authReadyPromiseRef = (0, react.useRef)(null);
+	const authReadyResolveRef = (0, react.useRef)(null);
+	if (!authReadyPromiseRef.current) authReadyPromiseRef.current = new Promise((resolve) => {
+		authReadyResolveRef.current = resolve;
+	});
+	const resolvedGetToken = config?.getToken ? config.getToken : config?.url ? () => require_auth.getStoredSessionToken(config?.url) : void 0;
+	const dbName = `${config?.name ?? "app"}.db`;
+	(0, react.useEffect)(() => {
+		require_auth.setAuthProdUrl(prodUrl ?? null);
+	}, [prodUrl]);
+	(0, react.useEffect)(() => {
+		if (!url) {
+			setIsLoading(false);
+			setAuthReady(true);
+			return;
+		}
+		(async () => {
+			try {
+				const token = await require_auth.getStoredSessionToken(url);
+				if (token) {
+					tokenRef.current = token;
+					const current = await require_auth.fetchCurrentUser(url, token);
+					if (current.user) setUser(current.user);
+					else {
+						await require_auth.clearStoredSessionToken(url);
+						tokenRef.current = null;
+					}
+				}
+			} catch (err) {
+				console.error("[silosdk] Auth init failed:", err);
+			} finally {
+				setIsLoading(false);
+				setAuthReady(true);
+			}
+		})();
+	}, [url]);
+	(0, react.useEffect)(() => {
+		if (authReady) authReadyResolveRef.current?.();
+	}, [authReady]);
+	const signIn = (0, react.useCallback)(async (opts) => {
+		if (!url) throw new Error("No URL configured");
+		await require_auth.requestOtp(url, opts.email);
+	}, [url]);
+	const verifyOtp = (0, react.useCallback)(async (opts) => {
+		if (!url) throw new Error("No URL configured");
+		const result = await require_auth.verifyOtpWithServer(url, opts);
+		tokenRef.current = result.token;
+		setUser(result.user);
+		require_auth.authEvents.emit("token-changed");
+	}, [url]);
+	const signOut = (0, react.useCallback)(async () => {
+		if (!url) return;
+		const token = tokenRef.current;
+		if (token) await require_auth.signOutFromServer(url, token);
+		await require_auth.clearStoredSessionToken(url);
+		tokenRef.current = null;
+		setUser(null);
+		require_auth.authEvents.emit("token-changed");
+	}, [url]);
+	(0, react.useEffect)(() => {
+		if (!url) return;
+		const handleUnauthorized = () => {
+			tokenRef.current = null;
+			setUser(null);
+		};
+		require_auth.authEvents.on("unauthorized", handleUnauthorized);
+		return () => require_auth.authEvents.off("unauthorized", handleUnauthorized);
+	}, [url]);
+	const authState = {
+		user,
+		isLoading,
+		signIn,
+		verifyOtp,
+		signOut
+	};
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_config.Context.Provider, {
+		value: {
+			subscribers,
+			url: config?.url,
+			getToken: resolvedGetToken,
+			authReady,
+			authReadyPromise: authReadyPromiseRef.current ?? Promise.resolve()
+		},
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(require_auth_context.AuthContext.Provider, {
+			value: authState,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(expo_sqlite.SQLiteProvider, {
+				databaseName: dbName,
+				onInit: async (db) => {
+					await db.execAsync(`
+              PRAGMA journal_mode = WAL;
+              CREATE TABLE IF NOT EXISTS views (
+                id TEXT PRIMARY KEY,
+                view TEXT,
+                data BLOB,
+                createdAt TEXT,
+                updatedAt TEXT,
+                version INTEGER DEFAULT 0
+              );
+              CREATE TABLE IF NOT EXISTS relations (
+                parent TEXT,
+                pid TEXT,
+                child TEXT,
+                cid TEXT
+              );
+            `);
+				},
+				options: { enableChangeListener: true },
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(SyncManagerWithConfig, {
+					config,
+					subscribers
+				}), props.children]
+			})
+		})
+	});
+}
+function SyncManagerWithConfig({ config, subscribers }) {
+	const db = (0, expo_sqlite.useSQLiteContext)();
+	const adapterRef = (0, react.useRef)(void 0);
+	const [isAuthenticated, setIsAuthenticated] = (0, react.useState)(null);
+	const checkAuth = (0, react.useCallback)(async () => {
+		if (!config?.url) {
+			setIsAuthenticated(false);
+			return;
+		}
+		const token = await (config.getToken ? config.getToken : () => require_auth.getStoredSessionToken(config.url))();
+		if (!token) {
+			setIsAuthenticated(false);
+			return;
+		}
+		try {
+			const res = await fetch(`${config.url}/auth/me`, { headers: { Authorization: `Bearer ${token}` } });
+			if (res.ok) setIsAuthenticated(!(await res.json()).isAnonymous);
+			else setIsAuthenticated(false);
+		} catch {
+			setIsAuthenticated(false);
+		}
+	}, [config?.url, config?.getToken]);
+	(0, react.useEffect)(() => {
+		checkAuth();
+	}, [checkAuth]);
+	(0, react.useEffect)(() => {
+		const handleTokenChanged = () => {
+			require_view.getQueryStoreInstance().clear();
+			checkAuth();
+			adapterRef.current?.resetConnection();
+		};
+		require_auth.authEvents.on("token-changed", handleTokenChanged);
+		return () => {
+			require_auth.authEvents.off("token-changed", handleTokenChanged);
+		};
+	}, [checkAuth]);
+	(0, react.useEffect)(() => {
+		if (!config?.url || isAuthenticated !== true) return;
+		const resolvedGetToken = config.getToken ? config.getToken : () => require_auth.getStoredSessionToken(config.url);
+		const adapter = new require_cloudflare.CloudflareSyncAdapter({
+			url: config.url,
+			getToken: resolvedGetToken,
+			db,
+			subscribers
+		});
+		adapterRef.current = adapter;
+		let mounted = true;
+		adapter.onReceive(async (payload) => {
+			if (mounted) await require_sync.applyRemoteOps(db, payload.ops, subscribers, adapter.merge);
+		});
+		adapter.connect();
+		return () => {
+			mounted = false;
+			adapter.disconnect();
+			adapterRef.current = void 0;
+		};
+	}, [
+		config?.url,
+		config?.getToken,
+		db,
+		subscribers,
+		isAuthenticated
+	]);
+	return null;
+}
+
+//#endregion
+exports.Provider = Provider;

package/dist/local/provider.d.cts

@@ -0,0 +1,25 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
+
+//#region src/local/provider.d.ts
+type ProviderConfig = {
+  /** SQLite database name. Defaults to 'app' (.db appended internally). */
+  name?: string;
+  /** CF Worker base URL. Enables DO sync + public D1 queries when present. */
+  url?: string;
+  /** Optional production base URL used for keying SecureStore. */
+  prodUrl?: string;
+  /**
+   * BYO auth: returns the bearer token for HTTP requests and WS auth.
+   * When omitted and `url` is set, the built-in auth session token is read
+   * automatically from expo-secure-store (Phase 4 built-in auth mode).
+   * Return null to send no Authorization header.
+   */
+  getToken?: () => Promise<string | null>;
+};
+declare function Provider(props: {
+  config?: ProviderConfig;
+  children: ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { Provider };

package/dist/local/provider.d.mts

@@ -0,0 +1,25 @@
+import { ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/local/provider.d.ts
+type ProviderConfig = {
+  /** SQLite database name. Defaults to 'app' (.db appended internally). */
+  name?: string;
+  /** CF Worker base URL. Enables DO sync + public D1 queries when present. */
+  url?: string;
+  /** Optional production base URL used for keying SecureStore. */
+  prodUrl?: string;
+  /**
+   * BYO auth: returns the bearer token for HTTP requests and WS auth.
+   * When omitted and `url` is set, the built-in auth session token is read
+   * automatically from expo-secure-store (Phase 4 built-in auth mode).
+   * Return null to send no Authorization header.
+   */
+  getToken?: () => Promise<string | null>;
+};
+declare function Provider(props: {
+  config?: ProviderConfig;
+  children: ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { Provider };