@voltro/react-native 0.29.0

package/dist/index.d.ts

@@ -0,0 +1,341 @@
+export declare type BackgroundSyncAction = {
+    readonly type: 'foreground';
+} | {
+    readonly type: 'background';
+} | {
+    readonly type: 'syncStarted';
+    readonly at: number;
+} | {
+    readonly type: 'syncSucceeded';
+    readonly at: number;
+} | {
+    readonly type: 'syncFailed';
+    readonly at: number;
+    readonly error: string;
+} | {
+    readonly type: 'reset';
+};
+
+export declare const backgroundSyncReducer: (state: BackgroundSyncState, action: BackgroundSyncAction) => BackgroundSyncState;
+
+export declare interface BackgroundSyncState {
+    readonly status: BackgroundSyncStatus;
+    /** Whether the app is currently foregrounded (drives interval + focus sync). */
+    readonly isForeground: boolean;
+    /** When the last SUCCESSFUL sync completed, epoch ms. `undefined` until one does. */
+    readonly lastSyncAt: number | undefined;
+    /** When the last sync ATTEMPT started, epoch ms — the interval clock reads this. */
+    readonly lastAttemptAt: number | undefined;
+    /** The last error message, set on failure, cleared on the next success/start. */
+    readonly lastError: string | undefined;
+    /** Successful syncs so far. */
+    readonly successCount: number;
+    /** Consecutive failures with no success since — 0 when healthy. */
+    readonly failureCount: number;
+}
+
+export declare type BackgroundSyncStatus = 'idle' | 'syncing' | 'success' | 'error';
+
+/**
+ * The descriptor a `*.deepLink.ts` file default-exports. `_tag` marks it for
+ * the (future) discovery walk without relying on structural guessing.
+ */
+export declare interface DeepLinkDescriptor<Pattern extends string = string> {
+    readonly _tag: 'VoltroDeepLink';
+    readonly pattern: Pattern;
+    readonly handler: DeepLinkHandler<Pattern>;
+}
+
+/** A handler for a matched deep link. May be async (navigation can await). */
+export declare type DeepLinkHandler<Pattern extends string> = (params: DeepLinkParams<Pattern>) => void | Promise<void>;
+
+/**
+ * The params a pattern yields, inferred from its `:name` segments.
+ *
+ * `'/orders/:id'` → `{ id: string }`, `'/t/:tenant/u/:user'` →
+ * `{ tenant: string; user: string }`, a param-less pattern →
+ * `Record<string, never>`. This is what makes `handler: ({ id }) => …`
+ * type-check against exactly the params the pattern declares.
+ */
+export declare type DeepLinkParams<Pattern extends string> = Pattern extends `${string}:${infer Param}/${infer Rest}` ? {
+    readonly [K in Param | keyof DeepLinkParams<`/${Rest}`>]: string;
+} : Pattern extends `${string}:${infer Param}` ? {
+    readonly [K in Param]: string;
+} : Record<string, never>;
+
+/**
+ * Declare a deep link.
+ *
+ * ```ts
+ * export default defineDeepLink({
+ *   pattern: '/orders/:id',
+ *   handler: ({ id }) => navigateTo(`/orders/${id}`),
+ * })
+ * ```
+ */
+export declare const defineDeepLink: <const Pattern extends string>(config: DefineDeepLinkConfig<Pattern>) => DeepLinkDescriptor<Pattern>;
+
+export declare interface DefineDeepLinkConfig<Pattern extends string> {
+    readonly pattern: Pattern;
+    readonly handler: DeepLinkHandler<Pattern>;
+}
+
+/**
+ * The status mapping, pure and standalone (mirrors `@voltro/client`'s):
+ *   - browser says offline → `offline` (a real signal for "no", weak for "yes"),
+ *   - otherwise any outstanding failure → `degraded`,
+ *   - else `connected`. No fake "connecting" ping.
+ */
+export declare const deriveConnectionStatus: (online: boolean, failureCount: number) => MobileConnectionStatus;
+
+/** The set of platforms, as a value (for validation / `<Picker>` lists). */
+export declare const DEVICE_PLATFORMS: ReadonlyArray<DevicePlatform>;
+
+/** The push transport a device is reachable on. */
+export declare type DevicePlatform = 'ios' | 'android' | 'web';
+
+/**
+ * The normalised row, ready to upsert into `_voltro_devices`. `locale` and
+ * `timezone` are resolved (never `undefined`); `registeredAt` is the moment we
+ * built this. `userId` / `tenantId` are NOT here on purpose — they are the
+ * server's to stamp from the authenticated request, never trusted from the
+ * client (mirrors how API-key metadata is merged UNDER the framework's claims).
+ */
+export declare interface DeviceRegistration {
+    readonly deviceToken: string;
+    readonly platform: DevicePlatform;
+    readonly locale: string;
+    readonly timezone: string;
+    readonly appVersion: string | null;
+    readonly metadata: Readonly<Record<string, unknown>> | null;
+    readonly registeredAt: number;
+}
+
+/**
+ * Ambient facts the resolver reads for the locale/timezone defaults. Injectable
+ * so it is pure + testable — in a real RN/web runtime the defaults come from
+ * the device, in a test you pass them explicitly.
+ */
+export declare interface DeviceRegistrationEnv {
+    readonly locale?: string;
+    readonly timezone?: string;
+    readonly now?: () => number;
+}
+
+/**
+ * What the app hands us at registration time. `deviceToken` and `platform` are
+ * the only two the caller MUST supply — the OS gives it both. `locale` and
+ * `timezone` are filled from the running environment when omitted (see
+ * {@link resolveDeviceRegistration}); `appVersion` and `metadata` are optional
+ * tags the app may attach.
+ */
+export declare interface DeviceRegistrationInput {
+    readonly deviceToken: string;
+    readonly platform: DevicePlatform;
+    readonly locale?: string;
+    readonly timezone?: string;
+    readonly appVersion?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+
+/** The framework table name devices are stored in — shared with `./schema`. */
+export declare const DEVICES_TABLE = "_voltro_devices";
+
+/**
+ * The transport that actually persists a device. The app supplies it — usually
+ * a generated mutation caller (`api.registerDevice`) or a plain `fetch` — so
+ * this package stays free of any transport/codegen coupling. It receives the
+ * fully-resolved row and returns whatever the server sends back.
+ */
+export declare type DeviceUpsert<Result = unknown> = (registration: DeviceRegistration) => Promise<Result>;
+
+/**
+ * Subscribe to "app returned to the foreground". Returns an unsubscribe.
+ *
+ * The app supplies this — on RN, wrap `AppState.addEventListener('change', …)`
+ * and call `onForeground` when it flips to `'active'`; on web the default below
+ * uses `visibilitychange` + `focus`. Injectable so the hook is testable without
+ * a real app lifecycle.
+ */
+export declare type ForegroundSubscribe = (onForeground: () => void, onBackground: () => void) => () => void;
+
+export declare const initialBackgroundSyncState: BackgroundSyncState;
+
+/** Narrow an untrusted string to a {@link DevicePlatform}. */
+export declare const isDevicePlatform: (value: unknown) => value is DevicePlatform;
+
+/**
+ * Match a `pattern` against a `path`, returning the captured params or `null`
+ * when it does not match. Pure — no navigation, no side effects.
+ *
+ * ```ts
+ * matchDeepLink('/orders/:id', '/orders/42')      // → { id: '42' }
+ * matchDeepLink('/orders/:id', '/orders/42/edit') // → null
+ * matchDeepLink('/health', '/health')             // → {}
+ * ```
+ *
+ * A `*` segment matches exactly one segment without capturing; a trailing `*`
+ * is not a catch-all (keep the model boringly predictable — one pattern
+ * segment matches one path segment).
+ */
+export declare const matchDeepLink: <Pattern extends string>(pattern: Pattern, path: string) => DeepLinkParams<Pattern> | null;
+
+/**
+ * First descriptor whose pattern matches `path`, with its captured params —
+ * the hand-registration entry point until file discovery lands. Declaration
+ * order wins, so list more-specific patterns first.
+ */
+export declare const matchFirstDeepLink: (descriptors: ReadonlyArray<DeepLinkDescriptor>, path: string) => {
+    readonly descriptor: DeepLinkDescriptor;
+    readonly params: Record<string, string>;
+} | null;
+
+export declare interface MobileConnectionControls {
+    /** Report that a call failed — bumps `failureCount`, flips to `degraded`. */
+    readonly reportFailure: () => void;
+    /** Report a known-good round trip — clears `degraded`. */
+    readonly reportSuccess: () => void;
+}
+
+export declare interface MobileConnectionState {
+    readonly status: MobileConnectionStatus;
+    /** `navigator.onLine` (true when unknowable, e.g. SSR / headless RN). */
+    readonly online: boolean;
+    /** Consecutive reported failures with no success since. 0 when healthy. */
+    readonly failureCount: number;
+    readonly lastFailureAt: number | undefined;
+}
+
+export declare type MobileConnectionStatus = 'connected' | 'degraded' | 'offline';
+
+/**
+ * The mobile client posture. Spread into the client config on RN:
+ *
+ * ```ts
+ * createClient({ ...offlineFirstDefaults, url })
+ * ```
+ */
+export declare interface OfflineFirstDefaults {
+    /** Local-first is ON by default on mobile (opt-out), OFF on web (opt-in). */
+    readonly localFirst: boolean;
+    /** Apply mutations optimistically before the server confirms. */
+    readonly optimistic: boolean;
+    /** Sync when the app returns to the foreground. */
+    readonly syncOnForeground: boolean;
+    /** Background sync cadence while foregrounded, ms. */
+    readonly syncIntervalMs: number;
+    /** Surface sync/connection status in the UI (mobile shows it prominently). */
+    readonly showSyncStatus: boolean;
+    /** Retry backoff schedule for a failed sync, ms. */
+    readonly retryBackoffMs: ReadonlyArray<number>;
+}
+
+export declare const offlineFirstDefaults: OfflineFirstDefaults;
+
+/**
+ * Register (or re-register, on token rotation) the current device.
+ *
+ * ```ts
+ * await registerDevice(
+ *   (row) => api.mutate('registerDevice', row),
+ *   { deviceToken, platform: 'ios' },
+ * )
+ * ```
+ *
+ * Idempotent by construction: the `_voltro_devices` unique key is
+ * `(platform, token)`, so calling this again with the same token updates the
+ * existing row (locale/timezone/lastSeen) instead of inserting a duplicate. A
+ * ROTATED token is a new registration; reaping the stale one is the sender
+ * adapter's job (a seam), not the client's.
+ */
+export declare const registerDevice: <Result = unknown>(upsert: DeviceUpsert<Result>, input: DeviceRegistrationInput, env?: DeviceRegistrationEnv) => Promise<Result>;
+
+/**
+ * Turn a raw {@link DeviceRegistrationInput} into a {@link DeviceRegistration}.
+ *
+ * Locale/timezone precedence: explicit input → injected env → ambient runtime →
+ * the `en` / `UTC` floor. Pure given an `env` (including `now`), so the same
+ * input always produces the same row in a test.
+ */
+export declare const resolveDeviceRegistration: (input: DeviceRegistrationInput, env?: DeviceRegistrationEnv) => DeviceRegistration;
+
+/**
+ * Match `path` against a descriptor and, on a hit, invoke its handler with the
+ * captured params. Returns the params (so callers know it matched) or `null`.
+ */
+export declare const runDeepLink: <Pattern extends string>(descriptor: DeepLinkDescriptor<Pattern>, path: string) => DeepLinkParams<Pattern> | null;
+
+/**
+ * Should a trigger run a sync right now? Pure — the single place the timing
+ * policy lives, so the hook and any test agree:
+ *
+ *   - not while one is already in flight (single-flight),
+ *   - not while backgrounded (a background tick is the OS's job, not ours),
+ *   - not before `intervalMs` has elapsed since the last ATTEMPT,
+ *   - not when disabled.
+ *
+ * A `force` trigger (a manual `sync()` call) bypasses only the interval gate —
+ * it still respects single-flight and enabled, because running two syncs at
+ * once or after teardown is never what the caller meant.
+ */
+export declare const shouldSync: (state: BackgroundSyncState, now: number, options: ShouldSyncOptions, force?: boolean) => boolean;
+
+export declare interface ShouldSyncOptions {
+    /** Minimum ms between attempts; `0` disables the interval gate. */
+    readonly intervalMs: number;
+    /** Whether syncing is enabled at all. */
+    readonly enabled: boolean;
+}
+
+/**
+ * Register a periodic + foreground-triggered sync callback.
+ *
+ * ```tsx
+ * const { status, lastSyncAt, sync } = useBackgroundSync(
+ *   () => api.refetchAll(),
+ *   { intervalMs: 60_000, syncOnForeground: true },
+ * )
+ * ```
+ *
+ * `onSync` may be async — a rejection is captured into `status: 'error'` +
+ * `lastError`, a resolution into `status: 'success'` + `lastSyncAt`. The
+ * callback is read through a ref, so passing a fresh closure each render does
+ * not reset the timer.
+ */
+export declare const useBackgroundSync: (onSync: () => void | Promise<void>, options?: UseBackgroundSyncOptions) => UseBackgroundSyncResult;
+
+export declare interface UseBackgroundSyncOptions {
+    /** Run the sync on this cadence while foregrounded. `0` disables the interval. */
+    readonly intervalMs?: number;
+    /** Run the sync when the app returns to the foreground. Default `true`. */
+    readonly syncOnForeground?: boolean;
+    /** Master switch — when `false`, no trigger runs. Default `true`. */
+    readonly enabled?: boolean;
+    /** Override the foreground signal source (RN passes an `AppState` wrapper). */
+    readonly subscribeForeground?: ForegroundSubscribe;
+    /** Injectable clock, for tests. Default `Date.now`. */
+    readonly now?: () => number;
+}
+
+export declare interface UseBackgroundSyncResult extends BackgroundSyncState {
+    /** Trigger a sync by hand. Bypasses the interval gate; still single-flight. */
+    readonly sync: () => void;
+}
+
+/**
+ * Observe mobile connection health.
+ *
+ * ```tsx
+ * const { status, reportFailure, reportSuccess } = useMobileConnectionStatus()
+ * {status !== 'connected' && <OfflineBanner status={status} />}
+ * ```
+ *
+ * Standalone by design (see the file header): it derives `offline` from
+ * `navigator.onLine` + its events, and `degraded` from failures the app reports
+ * — it does not reach into any transport. Coming back online clears the failure
+ * count, on the same reasoning as the web hook: those failures were the offline
+ * window itself.
+ */
+export declare const useMobileConnectionStatus: () => MobileConnectionState & MobileConnectionControls;
+
+export { }

package/dist/index.js

@@ -0,0 +1,196 @@
+import { a as e, i as t, n, r, t as i } from "./devices-BjXAU-8I.js";
+import { useCallback as a, useEffect as o, useReducer as s, useRef as c, useState as l } from "react";
+//#region src/deepLink.ts
+var u = (e) => {
+	let t = e.pattern;
+	if (t.length === 0 || t[0] !== "/") throw Error(`defineDeepLink: pattern must start with "/" (got "${t}")`);
+	return {
+		_tag: "VoltroDeepLink",
+		pattern: t,
+		handler: e.handler
+	};
+}, d = (e) => {
+	let t = e, n = /^([a-zA-Z][a-zA-Z0-9+.-]*):\/\//.exec(t);
+	if (n) {
+		let e = t.slice(n[0].length), r = n[1].toLowerCase();
+		if (r === "http" || r === "https") {
+			let n = e.indexOf("/");
+			t = n === -1 ? "/" : e.slice(n);
+		} else t = `/${e}`;
+	}
+	let r = t.search(/[?#]/);
+	return r !== -1 && (t = t.slice(0, r)), t.split("/").filter((e) => e.length > 0).map((e) => {
+		try {
+			return decodeURIComponent(e);
+		} catch {
+			return e;
+		}
+	});
+}, f = (e, t) => {
+	let n = d(e), r = d(t);
+	if (n.length !== r.length) return null;
+	let i = {};
+	for (let e = 0; e < n.length; e++) {
+		let t = n[e], a = r[e];
+		if (t.startsWith(":")) {
+			let e = t.slice(1);
+			if (e.length === 0) return null;
+			i[e] = a;
+		} else if (t !== "*" && t !== a) return null;
+	}
+	return i;
+}, p = (e, t) => {
+	let n = f(e.pattern, t);
+	return n === null ? null : (e.handler(n), n);
+}, m = (e, t) => {
+	for (let n of e) {
+		let e = f(n.pattern, t);
+		if (e !== null) return {
+			descriptor: n,
+			params: e
+		};
+	}
+	return null;
+}, h = {
+	status: "idle",
+	isForeground: !0,
+	lastSyncAt: void 0,
+	lastAttemptAt: void 0,
+	lastError: void 0,
+	successCount: 0,
+	failureCount: 0
+}, g = (e, t) => {
+	switch (t.type) {
+		case "foreground": return e.isForeground ? e : {
+			...e,
+			isForeground: !0
+		};
+		case "background": return e.isForeground ? {
+			...e,
+			isForeground: !1
+		} : e;
+		case "syncStarted": return e.status === "syncing" ? e : {
+			...e,
+			status: "syncing",
+			lastAttemptAt: t.at,
+			lastError: void 0
+		};
+		case "syncSucceeded": return {
+			...e,
+			status: "success",
+			lastSyncAt: t.at,
+			lastError: void 0,
+			successCount: e.successCount + 1,
+			failureCount: 0
+		};
+		case "syncFailed": return {
+			...e,
+			status: "error",
+			lastError: t.error,
+			failureCount: e.failureCount + 1
+		};
+		case "reset": return {
+			...h,
+			isForeground: e.isForeground
+		};
+	}
+}, _ = (e, t, n, r = !1) => !(!n.enabled || e.status === "syncing" || !r && !e.isForeground || !r && n.intervalMs > 0 && e.lastAttemptAt !== void 0 && t - e.lastAttemptAt < n.intervalMs), v = (e, t) => {
+	if (typeof document > "u" || typeof window > "u") return () => {};
+	let n = () => {
+		document.visibilityState === "visible" ? e() : t();
+	};
+	return document.addEventListener("visibilitychange", n), window.addEventListener("focus", e), () => {
+		document.removeEventListener("visibilitychange", n), window.removeEventListener("focus", e);
+	};
+}, y = 5 * 6e4, b = (e, t = {}) => {
+	let n = t.intervalMs ?? y, r = t.syncOnForeground ?? !0, i = t.enabled ?? !0, l = t.now ?? Date.now, u = t.subscribeForeground ?? v, [d, f] = s(g, h), p = c(e);
+	p.current = e;
+	let m = c(d);
+	m.current = d;
+	let b = c(!0), x = a((e) => {
+		_(m.current, l(), {
+			intervalMs: n,
+			enabled: i
+		}, e) && (f({
+			type: "syncStarted",
+			at: l()
+		}), Promise.resolve().then(() => p.current()).then(() => {
+			b.current && f({
+				type: "syncSucceeded",
+				at: l()
+			});
+		}).catch((e) => {
+			b.current && f({
+				type: "syncFailed",
+				at: l(),
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}));
+	}, [
+		i,
+		n,
+		l
+	]);
+	o(() => (b.current = !0, () => {
+		b.current = !1;
+	}), []), o(() => u(() => {
+		f({ type: "foreground" }), r && x(!0);
+	}, () => f({ type: "background" })), [
+		u,
+		r,
+		x
+	]), o(() => {
+		if (!i || n <= 0) return;
+		let e = setInterval(() => x(!1), n);
+		return () => clearInterval(e);
+	}, [
+		i,
+		n,
+		x
+	]);
+	let S = a(() => x(!0), [x]);
+	return {
+		...d,
+		sync: S
+	};
+}, x = {
+	localFirst: !0,
+	optimistic: !0,
+	syncOnForeground: !0,
+	syncIntervalMs: 5 * 6e4,
+	showSyncStatus: !0,
+	retryBackoffMs: [
+		1e3,
+		5e3,
+		15e3,
+		6e4
+	]
+}, S = (e, t) => e ? t > 0 ? "degraded" : "connected" : "offline", C = () => typeof navigator > "u" || navigator.onLine, w = () => {
+	let [e, t] = l(C), [n, r] = l(0), [i, s] = l(void 0), u = c(!0);
+	o(() => (u.current = !0, () => {
+		u.current = !1;
+	}), []), o(() => {
+		if (typeof window > "u") return;
+		let e = () => {
+			t(!0), r(0);
+		}, n = () => t(!1);
+		return window.addEventListener("online", e), window.addEventListener("offline", n), () => {
+			window.removeEventListener("online", e), window.removeEventListener("offline", n);
+		};
+	}, []);
+	let d = a(() => {
+		u.current && (r((e) => e + 1), s(Date.now()));
+	}, []), f = a(() => {
+		u.current && r(0);
+	}, []);
+	return {
+		status: S(e, n),
+		online: e,
+		failureCount: n,
+		lastFailureAt: i,
+		reportFailure: d,
+		reportSuccess: f
+	};
+};
+//#endregion
+export { i as DEVICES_TABLE, n as DEVICE_PLATFORMS, g as backgroundSyncReducer, u as defineDeepLink, S as deriveConnectionStatus, h as initialBackgroundSyncState, r as isDevicePlatform, f as matchDeepLink, m as matchFirstDeepLink, x as offlineFirstDefaults, t as registerDevice, e as resolveDeviceRegistration, p as runDeepLink, _ as shouldSync, b as useBackgroundSync, w as useMobileConnectionStatus };

package/dist/schema.d.ts

@@ -0,0 +1,22 @@
+import { ColumnBuilder } from '@voltro/database';
+import { FieldDefinitions } from '@voltro/database';
+import { Table } from '@voltro/database';
+
+/** The framework table name devices are stored in — shared with `./schema`. */
+export declare const DEVICES_TABLE = "_voltro_devices";
+
+export declare const devicesTable: Table<"_voltro_devices", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string | null, "text", boolean>;
+    readonly userId: ColumnBuilder<string, "text", boolean>;
+    readonly platform: ColumnBuilder<string, "text", boolean>;
+    readonly token: ColumnBuilder<string, "text", boolean>;
+    readonly locale: ColumnBuilder<string | null, "text", boolean>;
+    readonly timezone: ColumnBuilder<string | null, "text", boolean>;
+    readonly appVersion: ColumnBuilder<string | null, "text", boolean>;
+    readonly metadata: ColumnBuilder<string | null, "text", boolean>;
+    readonly lastSeenAt: ColumnBuilder<Date, "timestamp", true>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", true>;
+}>, true, "byDeviceUser" | "byDeviceTenant">;
+
+export { }

package/dist/schema.js

@@ -0,0 +1,18 @@
+import { t as e } from "./devices-BjXAU-8I.js";
+import { id as t, table as n, text as r, timestamp as i } from "@voltro/database";
+//#region src/schema.ts
+var a = n(e, {
+	id: t({ prefix: "device" }),
+	tenantId: r().nullable(),
+	userId: r(),
+	platform: r(),
+	token: r(),
+	locale: r().nullable(),
+	timezone: r().nullable(),
+	appVersion: r().nullable(),
+	metadata: r().nullable(),
+	lastSeenAt: i().default("now"),
+	createdAt: i().default("now")
+}).unique("byDeviceToken", ["platform", "token"]).index("byDeviceUser", ["userId"]).index("byDeviceTenant", ["tenantId"]);
+//#endregion
+export { e as DEVICES_TABLE, a as devicesTable };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@voltro/react-native",
+  "version": "0.29.0",
+  "description": "React Native bindings for the framework: device-registration primitive, background-sync state machine, offline-first client defaults + connection-status surface, and the deep-link declaration shape — the credential-free mobile plumbing on top of the RN-safe React client.",
+  "keywords": [
+    "voltro",
+    "typescript",
+    "framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://voltro.dev",
+  "bugs": {
+    "email": "support@voltro.dev"
+  },
+  "author": {
+    "name": "Voltro UG",
+    "url": "https://voltro.dev"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js",
+      "default": "./dist/schema.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@voltro/database": "0.29.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}