@every-app/sdk 0.1.14 → 0.2.0

package/dist/server/everyApp.js

@@ -0,0 +1,121 @@
+/**
+ * `everyApp()` — the app-side identity boundary.
+ *
+ *   import manifest from "../everyapp.config.js";
+ *   export default everyApp(handler, manifest);
+ *
+ * The wrapper verifies the gateway-injected identity before app code runs,
+ * stores the result on the original Request, and then delegates to the
+ * worker-style handler.
+ */
+import { APP_ID_ENV, ConfigurationError, DEV_ENV, IdentityError, ISSUER_ENV, PUBLIC_KEYS_ENV, getIdentityFromRequest, } from "../internal/index.js";
+export { ConfigurationError, IdentityError };
+const requestIdentities = new WeakMap();
+function envValue(env, key) {
+    if (!env || typeof env !== "object")
+        return undefined;
+    const value = env[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function configFrom(manifest, options = {}) {
+    return {
+        audience: manifest.id,
+        issuer: options.issuer,
+        keysEnvVar: options.keysEnvVar ?? PUBLIC_KEYS_ENV,
+        publicKeys: options.publicKeys,
+        allowDevIdentities: options.allowDevIdentities,
+        now: options.now,
+    };
+}
+function unauthorized(message) {
+    return Response.json({ error: "unauthenticated", message }, { status: 401 });
+}
+function misconfigured(message) {
+    return Response.json({ error: "misconfigured", message }, { status: 500 });
+}
+async function resolveIdentity(request, env, config) {
+    const devEnv = env && typeof env === "object"
+        ? env[DEV_ENV]
+        : undefined;
+    return getIdentityFromRequest(request, {
+        audience: config.audience,
+        issuer: config.issuer ?? envValue(env, ISSUER_ENV),
+        publicKeys: config.publicKeys,
+        env: env,
+        keysEnvVar: config.keysEnvVar,
+        allowDevIdentities: config.allowDevIdentities ??
+            (typeof devEnv === "string" &&
+                (devEnv === "1" || devEnv.toLowerCase() === "true")),
+        now: config.now,
+    });
+}
+function rememberIdentity(request, identity) {
+    requestIdentities.set(request, identity);
+}
+function helperConfigFromEnv(env) {
+    const audience = envValue(env, APP_ID_ENV);
+    if (!audience) {
+        throw new ConfigurationError(`${APP_ID_ENV} is not set — the CLI must inject the app id for identity verification.`);
+    }
+    return {
+        audience,
+        keysEnvVar: PUBLIC_KEYS_ENV,
+    };
+}
+/**
+ * Return the verified Every App user for this request, or null for a declared
+ * public request. Uses the request cache first, then verifies the identity
+ * headers from the app id and public keys configured in env.
+ */
+export async function getEveryAppUser(request, env) {
+    const cached = requestIdentities.get(request);
+    if (cached)
+        return cached.user;
+    const identity = await resolveIdentity(request, env, helperConfigFromEnv(env));
+    rememberIdentity(request, identity);
+    return identity.user;
+}
+/**
+ * Return the verified user, or throw the same 401 JSON Response shape as
+ * everyApp() when the request is public or unauthenticated.
+ */
+export async function requireEveryAppUser(request, env) {
+    try {
+        const user = await getEveryAppUser(request, env);
+        if (!user) {
+            throw new IdentityError("this request does not have an authenticated user");
+        }
+        return user;
+    }
+    catch (error) {
+        if (error instanceof IdentityError) {
+            throw unauthorized(error.message);
+        }
+        throw error;
+    }
+}
+export function hasScope(user, scope) {
+    return user.scopes.includes("*") || user.scopes.includes(scope);
+}
+export function everyApp(handler, manifest, options = {}) {
+    const config = configFrom(manifest, options);
+    return {
+        async fetch(request, env, ctx) {
+            let identity;
+            try {
+                identity = await resolveIdentity(request, env, config);
+                rememberIdentity(request, identity);
+            }
+            catch (err) {
+                if (err instanceof ConfigurationError) {
+                    console.error(err);
+                    return misconfigured(err.message);
+                }
+                if (err instanceof IdentityError)
+                    return unauthorized(err.message);
+                throw err;
+            }
+            return handler(request, env, ctx, identity.user);
+        },
+    };
+}

package/dist/server/gatewayFetch.d.ts

@@ -0,0 +1,21 @@
+interface GatewayServiceBinding {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export interface GatewayFetchEnv {
+    EVERY_APP_GATEWAY?: GatewayServiceBinding;
+    EVERYAPP_DEV?: string | boolean;
+    OPENAI_API_KEY?: string;
+}
+export interface CreateGatewayFetchOptions {
+    env: GatewayFetchEnv;
+    /** The inbound app request whose verified identity may be forwarded. */
+    request: Request;
+}
+/**
+ * Create an OpenAI-compatible fetch function backed by the private gateway
+ * service binding. In local dev only, the developer's own OPENAI_API_KEY is a
+ * direct-provider fallback when no binding exists.
+ */
+export declare function createGatewayFetch({ env, request: inboundRequest, }: CreateGatewayFetchOptions): typeof fetch;
+export {};
+//# sourceMappingURL=gatewayFetch.d.ts.map

package/dist/server/gatewayFetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gatewayFetch.d.ts","sourceRoot":"","sources":["../../src/server/gatewayFetch.ts"],"names":[],"mappings":"AAMA,UAAU,qBAAqB;IAC7B,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CACxE;AAED,MAAM,WAAW,eAAe;IAC9B,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;IAC1C,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,eAAe,CAAC;IACrB,wEAAwE;IACxE,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,GAAG,EACH,OAAO,EAAE,cAAc,GACxB,EAAE,yBAAyB,GAAG,OAAO,KAAK,CAyC1C"}

package/dist/server/gatewayFetch.js

@@ -0,0 +1,70 @@
+import { ConfigurationError, IDENTITY_HEADER } from "../internal/index.js";
+const BINDING_ORIGIN = "http://every-app-gateway.internal";
+const OPENAI_UPSTREAM_ORIGIN = "https://api.openai.com";
+const OPENAI_PROXY_PREFIX = "/api/ai/openai";
+/**
+ * Create an OpenAI-compatible fetch function backed by the private gateway
+ * service binding. In local dev only, the developer's own OPENAI_API_KEY is a
+ * direct-provider fallback when no binding exists.
+ */
+export function createGatewayFetch({ env, request: inboundRequest, }) {
+    const binding = env.EVERY_APP_GATEWAY;
+    const devProviderKey = env.EVERYAPP_DEV
+        ? env.OPENAI_API_KEY?.trim()
+        : undefined;
+    if (binding && typeof binding.fetch !== "function") {
+        throw new ConfigurationError("EVERY_APP_GATEWAY is configured but is not a valid service binding.");
+    }
+    if (!binding && !devProviderKey) {
+        throw new ConfigurationError("AI gateway unavailable: deploy with the EVERY_APP_GATEWAY binding, or set OPENAI_API_KEY in .dev.vars for direct local development.");
+    }
+    return async (input, init) => {
+        const outbound = new Request(input, init);
+        const headers = new Headers(outbound.headers);
+        headers.delete("authorization");
+        const identity = inboundRequest.headers.get(IDENTITY_HEADER);
+        if (identity)
+            headers.set(IDENTITY_HEADER, identity);
+        else
+            headers.delete(IDENTITY_HEADER);
+        if (binding) {
+            const target = new URL(outbound.url);
+            const bindingRequest = streamingRequest(`${BINDING_ORIGIN}${target.pathname}${target.search}`, outbound, headers);
+            return binding.fetch(bindingRequest);
+        }
+        const providerUrl = directOpenAiUrl(outbound.url);
+        headers.delete(IDENTITY_HEADER);
+        headers.set("authorization", `Bearer ${devProviderKey}`);
+        return fetch(streamingRequest(providerUrl, outbound, headers));
+    };
+}
+function streamingRequest(url, source, headers) {
+    const body = canIncludeBody(source.method) ? source.body : undefined;
+    const init = {
+        method: source.method,
+        headers,
+        body,
+        signal: source.signal,
+        ...(body ? { duplex: "half" } : {}),
+    };
+    return new Request(url, init);
+}
+function directOpenAiUrl(input) {
+    const incoming = new URL(input);
+    if (incoming.pathname !== OPENAI_PROXY_PREFIX &&
+        !incoming.pathname.startsWith(`${OPENAI_PROXY_PREFIX}/`)) {
+        throw new ConfigurationError(`Direct local provider fallback only supports ${OPENAI_PROXY_PREFIX} paths.`);
+    }
+    const upstreamPath = incoming.pathname.slice(OPENAI_PROXY_PREFIX.length) || "/";
+    if (!upstreamPath.startsWith("/") || upstreamPath.startsWith("//")) {
+        throw new ConfigurationError("Invalid OpenAI proxy path.");
+    }
+    const upstream = new URL(OPENAI_UPSTREAM_ORIGIN);
+    upstream.pathname = upstreamPath;
+    upstream.search = incoming.search;
+    return upstream.toString();
+}
+function canIncludeBody(method) {
+    const normalized = method.toUpperCase();
+    return normalized !== "GET" && normalized !== "HEAD";
+}

package/dist/server/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @every-app/sdk/server — the server-side surface.
+ *
+ * There is intentionally no client-side export.
+ */
+export { ConfigurationError, IdentityError, everyApp, getEveryAppUser, hasScope, requireEveryAppUser, type EveryAppOptions, type EveryAppManifestLike, type EveryAppHandler, type EveryAppUser, type IdentityResult, } from "./everyApp.js";
+export { createGatewayFetch, type CreateGatewayFetchOptions, type GatewayFetchEnv, } from "./gatewayFetch.js";
+export { createMcpHandler, type CreateMcpHandlerOptions, type McpToolContext, type McpToolDefinition, type McpRequestHandler, } from "./mcp.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,mBAAmB,EACnB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,KAAK,eAAe,GACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,GACvB,MAAM,UAAU,CAAC"}

package/dist/server/index.js

@@ -0,0 +1,8 @@
+/**
+ * @every-app/sdk/server — the server-side surface.
+ *
+ * There is intentionally no client-side export.
+ */
+export { ConfigurationError, IdentityError, everyApp, getEveryAppUser, hasScope, requireEveryAppUser, } from "./everyApp.js";
+export { createGatewayFetch, } from "./gatewayFetch.js";
+export { createMcpHandler, } from "./mcp.js";

package/dist/server/mcp.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `createMcpHandler()` — a stateless Streamable HTTP MCP server handler.
+ *
+ *   const mcp = createMcpHandler({
+ *     name: "my-app",
+ *     tools: {
+ *       list_items: {
+ *         description: "List the user's items",
+ *         inputSchema: { type: "object", properties: { limit: { type: "number" } } },
+ *         handler: async (args, { user, env }) => listItems(user.id, args.limit),
+ *       },
+ *     },
+ *   });
+ *   export default everyApp((request, env, ctx, user) => {
+ *     if (new URL(request.url).pathname === "/mcp") return mcp(request, env, ctx, user);
+ *     ...
+ *   }, manifest);
+ *
+ * The gateway authenticates the caller and injects the identity JWT; this
+ * handler only consumes the verified `EveryAppUser`. Each POST carries one
+ * self-contained JSON-RPC message (no sessions, no SSE), so any isolate can
+ * serve any request.
+ */
+import type { EveryAppUser } from "../internal/index.js";
+import { type ExecutionContextLike } from "./everyApp.js";
+export interface McpToolContext<TEnv = Record<string, unknown>> {
+    user: EveryAppUser;
+    env: TEnv;
+    request: Request;
+    ctx: ExecutionContextLike;
+}
+export interface McpToolDefinition<TEnv = Record<string, unknown>> {
+    description?: string;
+    /** JSON Schema for the tool's arguments. Defaults to an empty object schema. */
+    inputSchema?: Record<string, unknown>;
+    /**
+     * Scope required to list or call this tool, checked against the scopes the
+     * credential was granted (`user.scopes`). Omit to allow any authenticated user.
+     */
+    scope?: string;
+    /**
+     * Tool implementation. Return a string or JSON-serializable value (wrapped as
+     * text content), or a full `{ content: [...] }` result. Thrown errors become
+     * `isError: true` tool results, not protocol errors.
+     */
+    handler: (args: Record<string, unknown>, context: McpToolContext<TEnv>) => unknown;
+}
+export interface CreateMcpHandlerOptions<TEnv = Record<string, unknown>> {
+    /** Server name reported to MCP clients. */
+    name: string;
+    version?: string;
+    /** Optional usage hints surfaced to clients after initialize. */
+    instructions?: string;
+    /**
+     * Browser origins allowed to call this endpoint, in addition to the
+     * endpoint's own origin. Non-browser clients send no Origin header and are
+     * unaffected; any other present Origin is rejected with 403 (the Streamable
+     * HTTP spec's DNS-rebinding defense).
+     */
+    allowedOrigins?: string[];
+    tools: Record<string, McpToolDefinition<TEnv>>;
+}
+/** Matches the everyApp() handler signature so it can be delegated to directly. */
+export type McpRequestHandler<TEnv = Record<string, unknown>> = (request: Request, env: TEnv, ctx: ExecutionContextLike, user?: EveryAppUser | null) => Promise<Response>;
+export declare function createMcpHandler<TEnv = Record<string, unknown>>(options: CreateMcpHandlerOptions<TEnv>): McpRequestHandler<TEnv>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/server/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/server/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,eAAe,CAAC;AAUvB,MAAM,WAAW,cAAc,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5D,IAAI,EAAE,YAAY,CAAC;IACnB,GAAG,EAAE,IAAI,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,oBAAoB,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,OAAO,EAAE,CACP,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,KAC1B,OAAO,CAAC;CACd;AAED,MAAM,WAAW,uBAAuB,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACrE,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;CAChD;AAED,mFAAmF;AACnF,MAAM,MAAM,iBAAiB,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAC9D,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,IAAI,EACT,GAAG,EAAE,oBAAoB,EACzB,IAAI,CAAC,EAAE,YAAY,GAAG,IAAI,KACvB,OAAO,CAAC,QAAQ,CAAC,CAAC;AAiDvB,wBAAgB,gBAAgB,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7D,OAAO,EAAE,uBAAuB,CAAC,IAAI,CAAC,GACrC,iBAAiB,CAAC,IAAI,CAAC,CA8IzB"}

package/dist/server/mcp.js

@@ -0,0 +1,147 @@
+import { getEveryAppUser, hasScope, } from "./everyApp.js";
+/** Protocol revisions this handler accepts; initialize echoes the client's when supported. */
+const SUPPORTED_PROTOCOL_VERSIONS = [
+    "2025-03-26",
+    "2025-06-18",
+    "2025-11-25",
+];
+const DEFAULT_PROTOCOL_VERSION = "2025-06-18";
+function userHasScope(user, scope) {
+    return !scope || hasScope(user, scope);
+}
+function jsonRpcResult(id, result) {
+    return Response.json({ jsonrpc: "2.0", id, result });
+}
+function jsonRpcError(id, code, message) {
+    return Response.json({ jsonrpc: "2.0", id, error: { code, message } });
+}
+function accepted() {
+    return new Response(null, { status: 202 });
+}
+function toCallToolResult(value) {
+    if (value !== null &&
+        typeof value === "object" &&
+        Array.isArray(value.content)) {
+        return value;
+    }
+    const text = typeof value === "string" ? value : JSON.stringify(value ?? null);
+    return { content: [{ type: "text", text }] };
+}
+function negotiateProtocolVersion(params) {
+    const requested = params && typeof params === "object"
+        ? params.protocolVersion
+        : undefined;
+    return typeof requested === "string" &&
+        SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
+        ? requested
+        : DEFAULT_PROTOCOL_VERSION;
+}
+export function createMcpHandler(options) {
+    const { name, version = "0.0.0", instructions, allowedOrigins = [], tools, } = options;
+    return async (request, env, ctx, user) => {
+        if (request.method !== "POST") {
+            return new Response(null, { status: 405, headers: { allow: "POST" } });
+        }
+        const origin = request.headers.get("origin");
+        if (origin &&
+            origin !== new URL(request.url).origin &&
+            !allowedOrigins.includes(origin)) {
+            return Response.json({ error: "forbidden_origin" }, { status: 403 });
+        }
+        const resolvedUser = user !== undefined ? user : await getEveryAppUser(request, env);
+        if (!resolvedUser) {
+            return Response.json({ error: "unauthenticated", message: "MCP requests require a user" }, { status: 401 });
+        }
+        const versionHeader = request.headers.get("mcp-protocol-version");
+        if (versionHeader &&
+            !SUPPORTED_PROTOCOL_VERSIONS.includes(versionHeader)) {
+            return Response.json({
+                error: "unsupported_protocol_version",
+                supported: SUPPORTED_PROTOCOL_VERSIONS,
+            }, { status: 400 });
+        }
+        let message;
+        try {
+            message = (await request.json());
+        }
+        catch {
+            return jsonRpcError(null, -32700, "parse error: body must be JSON");
+        }
+        if (Array.isArray(message)) {
+            return jsonRpcError(null, -32600, "batch requests are not supported");
+        }
+        if (message === null || typeof message !== "object") {
+            return jsonRpcError(null, -32600, "invalid JSON-RPC message");
+        }
+        if (message.jsonrpc !== "2.0") {
+            return jsonRpcError(null, -32600, 'jsonrpc must be "2.0"');
+        }
+        if ("id" in message &&
+            typeof message.id !== "string" &&
+            typeof message.id !== "number" &&
+            message.id !== null) {
+            return jsonRpcError(null, -32600, "id must be a string, number, or null");
+        }
+        // Notifications and client-side responses expect no reply body.
+        if (typeof message.method !== "string")
+            return accepted();
+        if (!("id" in message))
+            return accepted();
+        const id = message.id;
+        switch (message.method) {
+            case "initialize":
+                return jsonRpcResult(id, {
+                    protocolVersion: negotiateProtocolVersion(message.params),
+                    capabilities: { tools: { listChanged: false } },
+                    serverInfo: { name, version },
+                    ...(instructions ? { instructions } : {}),
+                });
+            case "ping":
+                return jsonRpcResult(id, {});
+            case "tools/list": {
+                const visible = Object.entries(tools)
+                    .filter(([, tool]) => userHasScope(resolvedUser, tool.scope))
+                    .map(([toolName, tool]) => ({
+                    name: toolName,
+                    ...(tool.description ? { description: tool.description } : {}),
+                    inputSchema: tool.inputSchema ?? { type: "object", properties: {} },
+                }));
+                return jsonRpcResult(id, { tools: visible });
+            }
+            case "tools/call": {
+                const params = message.params && typeof message.params === "object"
+                    ? message.params
+                    : {};
+                const toolName = typeof params.name === "string" ? params.name : "";
+                const tool = tools[toolName];
+                if (!tool) {
+                    return jsonRpcError(id, -32602, `unknown tool: ${toolName}`);
+                }
+                if (!userHasScope(resolvedUser, tool.scope)) {
+                    return jsonRpcError(id, -32602, `tool ${toolName} requires scope ${tool.scope}`);
+                }
+                const args = params.arguments && typeof params.arguments === "object"
+                    ? params.arguments
+                    : {};
+                try {
+                    const value = await tool.handler(args, {
+                        user: resolvedUser,
+                        env,
+                        request,
+                        ctx,
+                    });
+                    return jsonRpcResult(id, toCallToolResult(value));
+                }
+                catch (error) {
+                    const text = error instanceof Error ? error.message : String(error);
+                    return jsonRpcResult(id, {
+                        content: [{ type: "text", text }],
+                        isError: true,
+                    });
+                }
+            }
+            default:
+                return jsonRpcError(id, -32601, `method not found: ${message.method}`);
+        }
+    };
+}

package/package.json

@@ -1,67 +1,44 @@
 {
   "name": "@every-app/sdk",
-  "version": "0.1.14",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "exports": {
-    "./core": {
-      "types": "./dist/core/index.d.ts",
-      "default": "./dist/core/index.js"
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "default": "./dist/server/index.js"
     },
-    "./tanstack": {
-      "types": "./dist/tanstack/index.d.ts",
-      "default": "./dist/tanstack/index.js"
-    },
-    "./tanstack/server": {
-      "types": "./dist/tanstack/server/index.d.ts",
-      "default": "./dist/tanstack/server/index.js"
-    },
-    "./cloudflare": {
-      "types": "./dist/cloudflare/index.d.ts",
-      "default": "./dist/cloudflare/index.js"
-    },
-    "./cloudflare/server": {
-      "types": "./dist/cloudflare/server/index.d.ts",
-      "default": "./dist/cloudflare/server/index.js"
+    "./internal": {
+      "types": "./dist/internal/index.d.ts",
+      "default": "./dist/internal/index.js"
     }
   },
   "files": [
     "dist",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prepack": "npm run build",
-    "build:prepublish": "pnpm install --ignore-scripts && npm run types:check && npm run build",
-    "prepublishOnly": "npm run build:prepublish",
-    "types:check": "tsc --noEmit",
-    "format:check": "prettier --check .",
-    "format:write": "prettier . --write",
-    "test": "vitest run --silent",
-    "test:watch": "vitest",
-    "check:esm-relative-imports": "node ./scripts/check-esm-relative-imports.mjs"
-  },
-  "dependencies": {
-    "jsonc-parser": "^3.3.1"
-  },
   "peerDependencies": {
-    "@tanstack/react-router": "^1.0.0",
-    "@tanstack/react-start": "^1.0.0",
-    "jose": "^6.0.0",
-    "react": "^18.0.0 || ^19.0.0"
+    "jose": "^6.0.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "^4.20251014.0",
-    "@tanstack/react-router": "^1.136.3",
-    "@tanstack/react-start": "^1.136.3",
     "@types/node": "^22.18.13",
-    "@types/react": "^19.0.8",
     "jose": "^6.0.12",
     "prettier": "^3.6.2",
-    "react": "^19.0.0",
     "typescript": "^5.9.3",
     "vite": "^7.1.2",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "tsc -p tsconfig.build.json",
+    "build:prepublish": "pnpm install --ignore-scripts && npm run types:check && npm run build",
+    "types:check": "tsc --noEmit",
+    "format:check": "prettier --check .",
+    "format:write": "prettier . --write",
+    "test": "vitest run --silent",
+    "test:watch": "vitest",
+    "check:esm-relative-imports": "node ./scripts/check-esm-relative-imports.mjs"
   }
-}
+}

package/dist/cloudflare/getLocalD1Url.d.ts

@@ -1,2 +0,0 @@
-export declare function getLocalD1Url(): string | null;
-//# sourceMappingURL=getLocalD1Url.d.ts.map

package/dist/cloudflare/getLocalD1Url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getLocalD1Url.d.ts","sourceRoot":"","sources":["../../src/cloudflare/getLocalD1Url.ts"],"names":[],"mappings":"AAWA,wBAAgB,aAAa,kBAoD5B"}

package/dist/cloudflare/getLocalD1Url.js

@@ -1,40 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { execSync } from "child_process";
-import { parse } from "jsonc-parser";
-function findSqliteFile(basePath) {
-    return fs
-        .readdirSync(basePath, { encoding: "utf-8", recursive: true })
-        .find((f) => f.endsWith(".sqlite"));
-}
-export function getLocalD1Url() {
-    const basePath = path.resolve(".wrangler");
-    // Check if .wrangler directory exists
-    if (!fs.existsSync(basePath)) {
-        console.error("================================================================================");
-        console.error("WARNING: .wrangler directory not found");
-        console.error("This is expected in CI/non-development environments.");
-        console.error("The local D1 database is only available after running 'wrangler dev' which you can trigger by running 'npm run dev'.");
-        console.error("================================================================================");
-        return null;
-    }
-    let dbFile = findSqliteFile(basePath);
-    if (!dbFile) {
-        // Read wrangler.jsonc to get the database name
-        const wranglerConfigPath = path.resolve("wrangler.jsonc");
-        const wranglerConfig = parse(fs.readFileSync(wranglerConfigPath, "utf-8"));
-        const databaseName = wranglerConfig.d1_databases?.[0]?.database_name;
-        if (!databaseName) {
-            throw new Error("Could not find database_name in wrangler.jsonc d1_databases configuration");
-        }
-        // Execute the command to initialize the local database
-        console.log(`Initializing local D1 database: ${databaseName}...`);
-        execSync(`npx wrangler d1 execute ${databaseName} --local --command "SELECT 1;"`, { stdio: "pipe" });
-        // Try to find the db file again after initialization
-        dbFile = findSqliteFile(basePath);
-        if (!dbFile) {
-            throw new Error(`Failed to initialize local D1 database. The sqlite file was not created.`);
-        }
-    }
-    return path.resolve(basePath, dbFile);
-}

package/dist/cloudflare/index.d.ts

@@ -1,2 +0,0 @@
-export { lazyInitForWorkers } from "./lazyInit.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/cloudflare/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cloudflare/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC"}

package/dist/cloudflare/index.js

@@ -1 +0,0 @@
-export { lazyInitForWorkers } from "./lazyInit.js";

package/dist/cloudflare/lazyInit.d.ts

@@ -1,22 +0,0 @@
-/**
- * Wraps a factory function in a Proxy to defer initialization until first access.
- * This prevents async operations (Like creating Tanstack DB Collections) from running in Cloudflare Workers' global scope.
- *
- * @param factory - A function that creates and returns the resource.
- *                  Must be a callback to defer execution; passing the value directly
- *                  would evaluate it at module load time, triggering the Cloudflare error.
- * @returns A Proxy that lazily initializes the resource on first property access
- *
- * @example
- * ```ts
- * export const myCollection = lazyInitForWorkers(() =>
- *   createCollection(queryCollectionOptions({
- *     queryKey: ["myData"],
- *     queryFn: async () => fetchData(),
- *     // ... other options
- *   }))
- * );
- * ```
- */
-export declare function lazyInitForWorkers<T extends object>(factory: () => T): T;
-//# sourceMappingURL=lazyInit.d.ts.map

package/dist/cloudflare/lazyInit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazyInit.d.ts","sourceRoot":"","sources":["../../src/cloudflare/lazyInit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,CA8CxE"}