silosdk 0.0.0 → 0.0.1

package/dist/server/index.mjs

@@ -0,0 +1,348 @@
+import { view } from "../schema/index.mjs";
+import { SyncObject } from "./do.mjs";
+import { d1ApplyOps, d1EnsureSchema, d1GetRow, d1GetRows } from "./d1.mjs";
+import { isAssetOwner, parseAssetKeyScope, r2Delete, r2Get, r2Put } from "./r2.mjs";
+import { createAnonymousUser, createAuth, createOtp, createSession, customProvider, deleteSession, findOrCreateUser, otpProvider, resolveSession, verifyOtp } from "./auth.mjs";
+import { protect } from "./protect.mjs";
+
+//#region src/server/index.ts
+async function d1EnsureAuthSchema(db) {
+	await db.batch([db.prepare(`CREATE TABLE IF NOT EXISTS silo_users (
+      id TEXT PRIMARY KEY,
+      email TEXT UNIQUE,
+      role TEXT NOT NULL DEFAULT 'user',
+      createdAt TEXT NOT NULL
+    )`), db.prepare(`CREATE TABLE IF NOT EXISTS silo_otps (
+      email TEXT PRIMARY KEY,
+      code TEXT NOT NULL,
+      expiresAt TEXT NOT NULL
+    )`)]);
+}
+function createServer(config) {
+	const { auth, views, storage } = config;
+	const storageConfig = storage == null ? null : storage === true ? {} : storage || null;
+	const storageMaxSize = storageConfig?.maxSize ?? 50 * 1024 * 1024;
+	const protectedViews = /* @__PURE__ */ new Map();
+	for (const v of views) if ("_rules" in v) protectedViews.set(v.name, v);
+	let schemaReady = false;
+	async function ensureSchema(db) {
+		if (schemaReady) return;
+		await d1EnsureSchema(db);
+		if (auth && Array.isArray(auth._providers)) await d1EnsureAuthSchema(db);
+		schemaReady = true;
+	}
+	function checkRolePermission(viewName, operation, role) {
+		if (!auth?._roles) return true;
+		const roleDef = auth._roles[role];
+		if (!roleDef) return false;
+		return (roleDef[viewName] ?? roleDef.default)[operation];
+	}
+	async function resolveUser(request, env) {
+		const url = new URL(request.url);
+		const authHeader = request.headers.get("Authorization");
+		const token = (authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null) ?? url.searchParams.get("token");
+		if (auth) {
+			if (!token) return null;
+			if (!Array.isArray(auth._providers) && auth._providers._type === "custom") {
+				const resolved = await auth._providers.resolve(token);
+				if (!resolved) return null;
+				return {
+					id: resolved.id,
+					email: null,
+					role: resolved.role ?? "user",
+					isAnonymous: false
+				};
+			}
+			const user = await resolveSession(env.SILO_SESSIONS, token);
+			if (user && url.pathname === "/sync" && user.isAnonymous) return null;
+			return user;
+		}
+		const devUser = request.headers.get("X-Dev-User");
+		return devUser ? {
+			id: devUser,
+			email: null,
+			role: "user",
+			isAnonymous: false
+		} : {
+			id: "dev",
+			email: null,
+			role: "user",
+			isAnonymous: false
+		};
+	}
+	return {
+		SyncObject,
+		async fetch(request, env) {
+			await ensureSchema(env.SILO_DB);
+			const url = new URL(request.url);
+			const { pathname } = url;
+			if (pathname === "/health") return json({ ok: true });
+			if (auth && Array.isArray(auth._providers) && pathname.startsWith("/auth/")) return handleAuthRoute(pathname, request, env, auth);
+			if (storageConfig && pathname === "/storage/upload" && request.method === "POST") {
+				const user = await resolveUser(request, env);
+				if (!user || user.isAnonymous) return new Response("Unauthorized", { status: 401 });
+				const scope = request.headers.get("X-Asset-Scope") === "public" ? "public" : "private";
+				const contentLengthHeader = request.headers.get("Content-Length");
+				const declaredSize = contentLengthHeader ? Number(contentLengthHeader) : 0;
+				if (Number.isFinite(declaredSize) && declaredSize > storageMaxSize) return new Response("Payload too large", { status: 413 });
+				if (!request.body) return new Response("Missing request body", { status: 400 });
+				const contentType = request.headers.get("Content-Type") ?? "application/octet-stream";
+				const name = request.headers.get("X-File-Name") ?? void 0;
+				const uploaded = await r2Put(env.SILO_STORAGE, {
+					scope,
+					userId: user.id,
+					body: request.body,
+					name,
+					contentType,
+					size: Number.isFinite(declaredSize) && declaredSize > 0 ? declaredSize : void 0
+				});
+				if (storageConfig.onUpload) {
+					if (!await storageConfig.onUpload({
+						user,
+						key: uploaded.key,
+						contentType: uploaded.contentType ?? contentType,
+						size: uploaded.size ?? 0,
+						scope,
+						env
+					})) {
+						await r2Delete(env.SILO_STORAGE, uploaded.key);
+						return new Response("Forbidden", { status: 403 });
+					}
+				}
+				return json(uploaded);
+			}
+			const storageMatch = pathname.match(/^\/storage\/(.+)$/);
+			if (storageConfig && storageMatch && request.method === "GET") {
+				const key = decodeURIComponent(storageMatch[1]);
+				const parsed = parseAssetKeyScope(key);
+				if (!parsed) return new Response("Not found", { status: 404 });
+				if (parsed.scope === "private") {
+					const user = await resolveUser(request, env);
+					if (!user) return new Response("Unauthorized", { status: 401 });
+					if (!isAssetOwner(key, user.id)) return new Response("Forbidden", { status: 403 });
+				} else if (!storageConfig.public) {
+					if (!await resolveUser(request, env)) return new Response("Unauthorized", { status: 401 });
+				}
+				const obj = await r2Get(env.SILO_STORAGE, key);
+				if (!obj || !obj.body) return new Response("Not found", { status: 404 });
+				const headers = new Headers();
+				if (obj.httpMetadata?.contentType) headers.set("Content-Type", obj.httpMetadata.contentType);
+				else headers.set("Content-Type", "application/octet-stream");
+				return new Response(obj.body, {
+					status: 200,
+					headers
+				});
+			}
+			if (storageConfig && storageMatch && request.method === "DELETE") {
+				const user = await resolveUser(request, env);
+				if (!user) return new Response("Unauthorized", { status: 401 });
+				const key = decodeURIComponent(storageMatch[1]);
+				if (!parseAssetKeyScope(key)) return new Response("Not found", { status: 404 });
+				if (!isAssetOwner(key, user.id)) return new Response("Forbidden", { status: 403 });
+				await r2Delete(env.SILO_STORAGE, key);
+				return new Response(null, { status: 204 });
+			}
+			const publicMatch = pathname.match(/^\/public\/([^/]+)$/);
+			if (publicMatch) {
+				const viewName = decodeURIComponent(publicMatch[1]);
+				const protected_ = protectedViews.get(viewName);
+				const hasReadRules = protected_?._rules.read != null;
+				const hasWriteRules = protected_?._rules.write != null;
+				if (request.method === "GET") {
+					const whereParam = url.searchParams.get("where");
+					const orderParam = url.searchParams.get("order");
+					let where;
+					let order;
+					if (whereParam) try {
+						const parsed = JSON.parse(whereParam);
+						if (parsed && typeof parsed === "object") where = parsed;
+					} catch {
+						return new Response("Invalid where clause", { status: 400 });
+					}
+					if (orderParam) try {
+						const parsed = JSON.parse(orderParam);
+						if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) order = parsed;
+					} catch {
+						return new Response("Invalid order clause", { status: 400 });
+					}
+					if (!hasReadRules && !checkRolePermission(viewName, "read", "anon")) {
+						const id$1 = url.searchParams.get("id");
+						if (id$1) {
+							const row = await d1GetRow(env.SILO_DB, viewName, { id: id$1 });
+							if (!row) return new Response("Not found", { status: 404 });
+							return json(row);
+						} else {
+							const take = url.searchParams.get("take");
+							const options = {};
+							if (take) options.take = Number(take);
+							if (where) options.where = where;
+							if (order) options.order = order;
+							const pv = url.searchParams.get("parentView");
+							const pi = url.searchParams.get("parentId");
+							if (pv && pi) {
+								options.parentView = pv;
+								options.parentId = pi;
+							}
+							const cv = url.searchParams.get("childView");
+							const ci = url.searchParams.get("childId");
+							if (cv && ci) {
+								options.childView = cv;
+								options.childId = ci;
+							}
+							return json(await d1GetRows(env.SILO_DB, viewName, options));
+						}
+					}
+					const user = await resolveUser(request, env);
+					if (!user && (hasReadRules || hasWriteRules)) return new Response("Unauthorized", { status: 401 });
+					if (hasReadRules) {
+						const query = where && !Array.isArray(where) ? { ...where } : {};
+						if (!await protected_._rules.read({
+							user,
+							env,
+							query
+						})) return new Response("Forbidden", { status: 403 });
+					} else if (!checkRolePermission(viewName, "read", user?.role ?? "anon")) return new Response("Forbidden", { status: 403 });
+					const id = url.searchParams.get("id");
+					if (id) {
+						const row = await d1GetRow(env.SILO_DB, viewName, { id });
+						if (!row) return new Response("Not found", { status: 404 });
+						return json(row);
+					} else {
+						const take = url.searchParams.get("take");
+						const options = {};
+						if (take) options.take = Number(take);
+						if (where) options.where = where;
+						if (order) options.order = order;
+						const pv = url.searchParams.get("parentView");
+						const pi = url.searchParams.get("parentId");
+						if (pv && pi) {
+							options.parentView = pv;
+							options.parentId = pi;
+						}
+						const cv = url.searchParams.get("childView");
+						const ci = url.searchParams.get("childId");
+						if (cv && ci) {
+							options.childView = cv;
+							options.childId = ci;
+						}
+						return json(await d1GetRows(env.SILO_DB, viewName, options));
+					}
+				}
+				if (request.method === "POST") {
+					const user = await resolveUser(request, env);
+					if (!user) return new Response("Unauthorized", { status: 401 });
+					let body;
+					try {
+						body = await request.json();
+					} catch {
+						return new Response("Invalid JSON", { status: 400 });
+					}
+					if (!Array.isArray(body?.ops)) return new Response("Expected { ops: [...] }", { status: 400 });
+					if (user.isAnonymous && !protected_?._rules.write) return json({
+						error: "Anonymous users cannot write to public DB",
+						code: "ANON_WRITE_FORBIDDEN"
+					}, 403);
+					if (protected_?._rules.write) {
+						for (const op of body.ops) if (!await protected_._rules.write({
+							user,
+							env,
+							op
+						})) return new Response("Forbidden", { status: 403 });
+					} else if (!checkRolePermission(viewName, "write", user.role)) return new Response("Forbidden", { status: 403 });
+					await d1ApplyOps(env.SILO_DB, body.ops);
+					return new Response(null, { status: 204 });
+				}
+				return new Response("Method not allowed", { status: 405 });
+			}
+			if (pathname === "/sync" && request.headers.get("Upgrade") === "websocket") {
+				const user = await resolveUser(request, env);
+				if (!user) return new Response("Unauthorized", { status: 401 });
+				const doId = env.SILO_SYNC.idFromName(user.id);
+				return env.SILO_SYNC.get(doId).fetch(request);
+			}
+			return new Response("Not found", { status: 404 });
+		}
+	};
+	async function handleAuthRoute(pathname, request, env, authInst) {
+		const sessionDuration = authInst._sessionDuration;
+		const otpProv = authInst._providers.find((p) => p._type === "otp");
+		if (pathname === "/auth/anonymous" && request.method === "POST") {
+			const { token, userId } = await createAnonymousUser(env.SILO_DB, env.SILO_SESSIONS, sessionDuration, authInst._defaultRole);
+			return json({
+				token,
+				user: {
+					id: userId,
+					email: null,
+					role: authInst._defaultRole,
+					isAnonymous: true
+				}
+			});
+		}
+		if (pathname === "/auth/request" && request.method === "POST") {
+			if (!otpProv) return new Response("OTP auth not enabled", { status: 400 });
+			let body;
+			try {
+				body = await request.json();
+			} catch {
+				return new Response("Invalid JSON", { status: 400 });
+			}
+			if (!body.email) return new Response("Missing email", { status: 400 });
+			const code = await createOtp(env.SILO_DB, body.email);
+			await otpProv.config.sendOTP(body.email, code, env);
+			return json({ ok: true });
+		}
+		if (pathname === "/auth/verify" && request.method === "POST") {
+			let body;
+			try {
+				body = await request.json();
+			} catch {
+				return new Response("Invalid JSON", { status: 400 });
+			}
+			if (!body.email || !body.otp) return new Response("Missing email or otp", { status: 400 });
+			const { valid } = await verifyOtp(env.SILO_DB, body.email, body.otp);
+			if (!valid) return new Response("Invalid or expired code", { status: 401 });
+			const user = await findOrCreateUser(env.SILO_DB, body.email, { role: authInst._defaultRole });
+			return json({
+				token: await createSession(env.SILO_SESSIONS, user.id, user.email, user.role, sessionDuration),
+				user: {
+					id: user.id,
+					email: user.email,
+					role: user.role,
+					isAnonymous: false
+				}
+			});
+		}
+		if (pathname === "/auth/signout" && request.method === "POST") {
+			const authHeader = request.headers.get("Authorization");
+			const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+			if (token) await deleteSession(env.SILO_SESSIONS, token);
+			return json({ ok: true });
+		}
+		if (pathname === "/auth/me" && request.method === "GET") {
+			const user = await resolveSessionFromRequest(request, env);
+			if (!user) return new Response("Unauthorized", { status: 401 });
+			return json({
+				id: user.id,
+				email: user.email,
+				role: user.role,
+				isAnonymous: user.isAnonymous
+			});
+		}
+		return new Response("Not found", { status: 404 });
+	}
+	async function resolveSessionFromRequest(request, env) {
+		const authHeader = request.headers.get("Authorization");
+		const token = authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : null;
+		if (!token) return null;
+		return resolveSession(env.SILO_SESSIONS, token);
+	}
+}
+function json(data, status = 200) {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+
+//#endregion
+export { SyncObject, createAuth, createServer, customProvider, otpProvider, protect, resolveSession, view };

package/dist/server/protect.cjs

@@ -0,0 +1,34 @@
+
+//#region src/server/protect.ts
+/**
+* Wrap a view with access-control rules for the public DB.
+*
+* When a rule is defined, it runs INSTEAD of any role-based permission check
+* (roles configured via `createAuth`). The rule receives `user.role` in context
+* and can incorporate it if desired.
+*
+* @example
+* ```ts
+* // Rule replaces role check entirely
+* const ProtectedTicketRequest = protect(TicketRequest, {
+*   write: ({ user, op }) => {
+*     // Runners/admins can write any request
+*     if (user.role === 'runner' || user.role === 'admin') return true
+*     // Users can only create requests for themselves
+*     return (op.value as any)?.userId === user.id
+*   },
+* })
+*
+* createServer({ views: [ProtectedTicketRequest], auth })
+* ```
+*/
+function protect(view, rules) {
+	return {
+		name: view.name,
+		_protected: true,
+		_rules: rules
+	};
+}
+
+//#endregion
+exports.protect = protect;

package/dist/server/protect.d.cts

@@ -0,0 +1,32 @@
+import { ProtectedView, ReadRuleContext, View, WriteRuleContext } from "../schema/index.cjs";
+
+//#region src/server/protect.d.ts
+
+/**
+ * Wrap a view with access-control rules for the public DB.
+ *
+ * When a rule is defined, it runs INSTEAD of any role-based permission check
+ * (roles configured via `createAuth`). The rule receives `user.role` in context
+ * and can incorporate it if desired.
+ *
+ * @example
+ * ```ts
+ * // Rule replaces role check entirely
+ * const ProtectedTicketRequest = protect(TicketRequest, {
+ *   write: ({ user, op }) => {
+ *     // Runners/admins can write any request
+ *     if (user.role === 'runner' || user.role === 'admin') return true
+ *     // Users can only create requests for themselves
+ *     return (op.value as any)?.userId === user.id
+ *   },
+ * })
+ *
+ * createServer({ views: [ProtectedTicketRequest], auth })
+ * ```
+ */
+declare function protect<V extends View>(view: V, rules: {
+  read?: (ctx: ReadRuleContext) => boolean | Promise<boolean>;
+  write?: (ctx: WriteRuleContext) => boolean | Promise<boolean>;
+}): ProtectedView<V['name']>;
+//#endregion
+export { protect };

package/dist/server/protect.d.mts

@@ -0,0 +1,32 @@
+import { ProtectedView, ReadRuleContext, View, WriteRuleContext } from "../schema/index.mjs";
+
+//#region src/server/protect.d.ts
+
+/**
+ * Wrap a view with access-control rules for the public DB.
+ *
+ * When a rule is defined, it runs INSTEAD of any role-based permission check
+ * (roles configured via `createAuth`). The rule receives `user.role` in context
+ * and can incorporate it if desired.
+ *
+ * @example
+ * ```ts
+ * // Rule replaces role check entirely
+ * const ProtectedTicketRequest = protect(TicketRequest, {
+ *   write: ({ user, op }) => {
+ *     // Runners/admins can write any request
+ *     if (user.role === 'runner' || user.role === 'admin') return true
+ *     // Users can only create requests for themselves
+ *     return (op.value as any)?.userId === user.id
+ *   },
+ * })
+ *
+ * createServer({ views: [ProtectedTicketRequest], auth })
+ * ```
+ */
+declare function protect<V extends View>(view: V, rules: {
+  read?: (ctx: ReadRuleContext) => boolean | Promise<boolean>;
+  write?: (ctx: WriteRuleContext) => boolean | Promise<boolean>;
+}): ProtectedView<V['name']>;
+//#endregion
+export { protect };

package/dist/server/protect.mjs

@@ -0,0 +1,33 @@
+//#region src/server/protect.ts
+/**
+* Wrap a view with access-control rules for the public DB.
+*
+* When a rule is defined, it runs INSTEAD of any role-based permission check
+* (roles configured via `createAuth`). The rule receives `user.role` in context
+* and can incorporate it if desired.
+*
+* @example
+* ```ts
+* // Rule replaces role check entirely
+* const ProtectedTicketRequest = protect(TicketRequest, {
+*   write: ({ user, op }) => {
+*     // Runners/admins can write any request
+*     if (user.role === 'runner' || user.role === 'admin') return true
+*     // Users can only create requests for themselves
+*     return (op.value as any)?.userId === user.id
+*   },
+* })
+*
+* createServer({ views: [ProtectedTicketRequest], auth })
+* ```
+*/
+function protect(view, rules) {
+	return {
+		name: view.name,
+		_protected: true,
+		_rules: rules
+	};
+}
+
+//#endregion
+export { protect };

package/dist/server/r2.cjs

@@ -0,0 +1,58 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let nanoid = require("nanoid");
+
+//#region src/server/r2.ts
+const DEFAULT_CONTENT_TYPE = "application/octet-stream";
+function createAssetKey(scope, userId) {
+	return `${scope}/${userId}/${(0, nanoid.nanoid)()}`;
+}
+function parseAssetKeyScope(key) {
+	const parts = key.split("/");
+	if (parts.length < 3) return null;
+	const [scopeRaw, ownerId, ...rest] = parts;
+	if (scopeRaw !== "private" && scopeRaw !== "public") return null;
+	if (!ownerId) return null;
+	const objectId = rest.join("/");
+	if (!objectId) return null;
+	return {
+		scope: scopeRaw,
+		ownerId,
+		objectId
+	};
+}
+function isAssetOwner(key, userId) {
+	const parsed = parseAssetKeyScope(key);
+	if (!parsed) return false;
+	return parsed.ownerId === userId;
+}
+async function r2Put(bucket, input) {
+	const key = createAssetKey(input.scope, input.userId);
+	await bucket.put(key, input.body, {
+		httpMetadata: { contentType: input.contentType ?? DEFAULT_CONTENT_TYPE },
+		customMetadata: {
+			scope: input.scope,
+			ownerId: input.userId,
+			...input.name ? { name: input.name } : {},
+			...typeof input.size === "number" ? { size: String(input.size) } : {}
+		}
+	});
+	return {
+		key,
+		...input.name ? { name: input.name } : {},
+		...input.contentType ? { contentType: input.contentType } : {},
+		...typeof input.size === "number" ? { size: input.size } : {}
+	};
+}
+async function r2Get(bucket, key) {
+	return bucket.get(key);
+}
+async function r2Delete(bucket, key) {
+	await bucket.delete(key);
+}
+
+//#endregion
+exports.isAssetOwner = isAssetOwner;
+exports.parseAssetKeyScope = parseAssetKeyScope;
+exports.r2Delete = r2Delete;
+exports.r2Get = r2Get;
+exports.r2Put = r2Put;

package/dist/server/r2.d.cts

@@ -0,0 +1,4 @@
+//#region src/server/r2.d.ts
+type AssetScope = 'private' | 'public';
+//#endregion
+export { AssetScope };

package/dist/server/r2.d.mts

@@ -0,0 +1,4 @@
+//#region src/server/r2.d.ts
+type AssetScope = 'private' | 'public';
+//#endregion
+export { AssetScope };

package/dist/server/r2.mjs

@@ -0,0 +1,53 @@
+import { nanoid } from "nanoid";
+
+//#region src/server/r2.ts
+const DEFAULT_CONTENT_TYPE = "application/octet-stream";
+function createAssetKey(scope, userId) {
+	return `${scope}/${userId}/${nanoid()}`;
+}
+function parseAssetKeyScope(key) {
+	const parts = key.split("/");
+	if (parts.length < 3) return null;
+	const [scopeRaw, ownerId, ...rest] = parts;
+	if (scopeRaw !== "private" && scopeRaw !== "public") return null;
+	if (!ownerId) return null;
+	const objectId = rest.join("/");
+	if (!objectId) return null;
+	return {
+		scope: scopeRaw,
+		ownerId,
+		objectId
+	};
+}
+function isAssetOwner(key, userId) {
+	const parsed = parseAssetKeyScope(key);
+	if (!parsed) return false;
+	return parsed.ownerId === userId;
+}
+async function r2Put(bucket, input) {
+	const key = createAssetKey(input.scope, input.userId);
+	await bucket.put(key, input.body, {
+		httpMetadata: { contentType: input.contentType ?? DEFAULT_CONTENT_TYPE },
+		customMetadata: {
+			scope: input.scope,
+			ownerId: input.userId,
+			...input.name ? { name: input.name } : {},
+			...typeof input.size === "number" ? { size: String(input.size) } : {}
+		}
+	});
+	return {
+		key,
+		...input.name ? { name: input.name } : {},
+		...input.contentType ? { contentType: input.contentType } : {},
+		...typeof input.size === "number" ? { size: input.size } : {}
+	};
+}
+async function r2Get(bucket, key) {
+	return bucket.get(key);
+}
+async function r2Delete(bucket, key) {
+	await bucket.delete(key);
+}
+
+//#endregion
+export { isAssetOwner, parseAssetKeyScope, r2Delete, r2Get, r2Put };

package/package.json

@@ -1,5 +1,58 @@
 {
   "name": "silosdk",
-  "version": "0.0.0",
-  "packageManager": "yarn@4.9.2"
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "build": "tsdown",
+    "watch": "tsdown --watch",
+    "publish": "tsdown && npm publish"
+  },
+  "packageManager": "yarn@4.9.2",
+  "files": [
+    "dist/"
+  ],
+  "bin": {
+    "silo": "./dist/cli/index.mjs"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260219.0",
+    "@types/node": "^25.3.0",
+    "@types/react": "^19",
+    "expo-secure-store": "*",
+    "expo-sqlite": "*",
+    "prettier": "^3.7.4",
+    "tsdown": "^0.17.2",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "jotai": "^2.15.1",
+    "jotai-family": "^1.0.1",
+    "nanoid": "5.1.6"
+  },
+  "peerDependencies": {
+    "expo-secure-store": "*",
+    "expo-sqlite": "*",
+    "react": "^19"
+  },
+  "prettier": {
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "all",
+    "printWidth": 80,
+    "tabWidth": 2
+  },
+  "exports": {
+    "./schema": {
+      "types": "./dist/schema/index.d.mts",
+      "import": "./dist/schema/index.mjs",
+      "require": "./dist/schema/index.cjs"
+    },
+    "./local": "./dist/local/index.cjs",
+    "./server": {
+      "types": "./dist/server/index.d.mts",
+      "import": "./dist/server/index.mjs"
+    },
+    "./package.json": "./package.json"
+  }
 }