@superwall/server 0.1.5 → 0.2.1

package/dist/cache.d.ts

@@ -0,0 +1,17 @@
+import type { CacheAdapter, CacheEntry } from "./types.js";
+/**
+ * In-memory LRU cache. Entries are evicted (a) on TTL expiry when read,
+ * and (b) when the map exceeds `maxEntries` (oldest-insertion-order first).
+ *
+ * Single-process only. For multi-instance deployments, supply a Redis or
+ * KV adapter via `cache.storage`.
+ */
+export declare class InMemoryCache implements CacheAdapter {
+    #private;
+    constructor(maxEntries: number);
+    get(key: string): CacheEntry | null;
+    set(key: string, value: CacheEntry): void;
+    delete(key: string): void;
+    clear(): void;
+    get size(): number;
+}

package/dist/cache.js

@@ -0,0 +1,48 @@
+/**
+ * In-memory LRU cache. Entries are evicted (a) on TTL expiry when read,
+ * and (b) when the map exceeds `maxEntries` (oldest-insertion-order first).
+ *
+ * Single-process only. For multi-instance deployments, supply a Redis or
+ * KV adapter via `cache.storage`.
+ */
+export class InMemoryCache {
+    #map = new Map();
+    #maxEntries;
+    constructor(maxEntries) {
+        this.#maxEntries = maxEntries;
+    }
+    get(key) {
+        const entry = this.#map.get(key);
+        if (!entry)
+            return null;
+        if (entry.expiresAt <= Date.now()) {
+            this.#map.delete(key);
+            return null;
+        }
+        // Refresh LRU position — re-insert moves to the end.
+        this.#map.delete(key);
+        this.#map.set(key, entry);
+        return entry;
+    }
+    set(key, value) {
+        if (this.#map.has(key))
+            this.#map.delete(key);
+        this.#map.set(key, value);
+        while (this.#map.size > this.#maxEntries) {
+            const oldest = this.#map.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.#map.delete(oldest);
+        }
+    }
+    delete(key) {
+        this.#map.delete(key);
+    }
+    clear() {
+        this.#map.clear();
+    }
+    // Test helper — current size.
+    get size() {
+        return this.#map.size;
+    }
+}

package/dist/fetcher.d.ts

@@ -0,0 +1,13 @@
+import { type Entitlements, type NetworkEnvironment } from "@superwall/core";
+export interface FetcherConfig {
+    readonly apiKey: string;
+    readonly environment: NetworkEnvironment;
+    readonly timeoutMs: number;
+}
+/**
+ * GET /subscriptions-api/public/v1/users/{userId}/entitlements
+ *
+ * Maps status codes to typed error classes. Returns the parsed
+ * Entitlements bucket on success.
+ */
+export declare const fetchEntitlements: (cfg: FetcherConfig, userId: string) => Promise<Entitlements>;

package/dist/fetcher.js

@@ -0,0 +1,67 @@
+import { parseEntitlements, resolveHosts, SuperwallAuthError, SuperwallDecodingError, SuperwallNetworkError, SuperwallNotFoundError, SuperwallTimeoutError, } from "@superwall/core";
+const SDK_VERSION = "0.0.0";
+const requireFetch = () => {
+    if (typeof globalThis !== "undefined" && "fetch" in globalThis) {
+        return globalThis.fetch.bind(globalThis);
+    }
+    throw new SuperwallNetworkError("No fetch implementation available — Superwall needs `globalThis.fetch` (Node 18+, Bun, Deno, Workers).");
+};
+/**
+ * GET /subscriptions-api/public/v1/users/{userId}/entitlements
+ *
+ * Maps status codes to typed error classes. Returns the parsed
+ * Entitlements bucket on success.
+ */
+export const fetchEntitlements = async (cfg, userId) => {
+    const hosts = resolveHosts(cfg.environment);
+    const url = `https://${hosts.subscriptions}/subscriptions-api/public/v1/users/${encodeURIComponent(userId)}/entitlements`;
+    const headers = {
+        Authorization: `Bearer ${cfg.apiKey}`,
+        "Content-Type": "application/json",
+        "X-Platform": "Server",
+        "X-Platform-Environment": "SDK",
+        "X-Platform-Wrapper": "Server",
+        "X-SDK-Version": SDK_VERSION,
+        "X-App-User-ID": userId,
+    };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), cfg.timeoutMs);
+    let response;
+    try {
+        response = await requireFetch()(url, {
+            method: "GET",
+            headers,
+            signal: controller.signal,
+        });
+    }
+    catch (cause) {
+        clearTimeout(timer);
+        if (cause instanceof Error && cause.name === "AbortError") {
+            throw new SuperwallTimeoutError(`Entitlements request timed out after ${cfg.timeoutMs}ms`, { url, timeoutMs: cfg.timeoutMs });
+        }
+        throw new SuperwallNetworkError(`Entitlements network error: ${describe(cause)}`, { url, cause });
+    }
+    clearTimeout(timer);
+    if (response.status === 401 || response.status === 403) {
+        throw new SuperwallAuthError(`Entitlements auth failed (status ${response.status}). Check SUPERWALL_API_KEY.`, { url });
+    }
+    if (response.status === 404) {
+        throw new SuperwallNotFoundError(`Entitlements lookup returned 404 for user ${userId}.`, { url });
+    }
+    if (!response.ok) {
+        throw new SuperwallNetworkError(`Entitlements returned ${response.status}`, { url, status: response.status });
+    }
+    let body;
+    try {
+        body = (await response.json());
+    }
+    catch (cause) {
+        throw new SuperwallDecodingError(`Entitlements JSON decode failed: ${describe(cause)}`, { url, cause });
+    }
+    return parseEntitlements(body);
+};
+const describe = (cause) => cause instanceof Error
+    ? cause.message
+    : typeof cause === "string"
+        ? cause
+        : JSON.stringify(cause);

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Superwall } from "./superwall.js";
+export type { SuperwallOptions, SuperwallInstance, EntitlementSpec, RequiresOptions, UserIdExtractor, CacheAdapter, CacheOptions, RequestInfo as OnRequestInfo, UnauthorizedContext, ConnectStyleRequest, ConnectStyleResponse, ConnectStyleNext, } from "./types.js";
+export type { Entitlement, Entitlements, SubscriptionStatus, NetworkEnvironment, CustomEnvironmentHosts, } from "@superwall/core";
+export { SuperwallError, SuperwallNetworkError, SuperwallAuthError, SuperwallNotFoundError, SuperwallTimeoutError, SuperwallDecodingError, } from "@superwall/core";

package/dist/index.js

@@ -0,0 +1,18 @@
+// @superwall/server — server-side entitlement enforcement for the Superwall web SDK.
+//
+// Quickstart:
+//
+//   import { Superwall } from "@superwall/server"
+//
+//   const sw = Superwall({
+//     apiKey: process.env.SUPERWALL_API_KEY!,
+//     userId: (req) => req.session?.userId ?? null,
+//   })
+//
+//   app.get("/api/export", sw.requires("pro"), exportHandler)
+//
+// The browser SDK's local subscription state is writable from DevTools. This
+// package gates routes server-to-server against Superwall's `/entitlements`
+// endpoint so tampering with the client cannot grant access to real resources.
+export { Superwall } from "./superwall.js";
+export { SuperwallError, SuperwallNetworkError, SuperwallAuthError, SuperwallNotFoundError, SuperwallTimeoutError, SuperwallDecodingError, } from "@superwall/core";

package/dist/requires.d.ts

@@ -0,0 +1,18 @@
+import type { Entitlements } from "@superwall/core";
+import type { ConnectStyleNext, ConnectStyleResponse, EntitlementSpec, RequestInfo, RequiresOptions, UserIdExtractor } from "./types.js";
+interface RequiresFactoryDeps<TReq> {
+    defaultUserIdExtractor: UserIdExtractor<TReq> | undefined;
+    loadEntitlements: (userId: string) => Promise<{
+        entitlements: Entitlements;
+        cacheHit: boolean;
+    }>;
+    emitRequest: (info: RequestInfo) => void;
+}
+/**
+ * Build the `sw.requires(spec, options?)` factory bound to the instance's
+ * cache + extractor + telemetry. Returned middleware is connect-style
+ * `(req, res, next)`, duck-typed so it works with Express directly and is
+ * trivially adaptable to Hono / Bun.serve / Next via a thin wrapper.
+ */
+export declare const makeRequires: <TReq>(deps: RequiresFactoryDeps<TReq>) => (spec: EntitlementSpec, options?: RequiresOptions<TReq>) => (req: TReq, res: ConnectStyleResponse, next: ConnectStyleNext) => Promise<void>;
+export {};

package/dist/requires.js

@@ -0,0 +1,80 @@
+import { findMissing, normalizeSpec } from "./spec.js";
+/**
+ * Build the `sw.requires(spec, options?)` factory bound to the instance's
+ * cache + extractor + telemetry. Returned middleware is connect-style
+ * `(req, res, next)`, duck-typed so it works with Express directly and is
+ * trivially adaptable to Hono / Bun.serve / Next via a thin wrapper.
+ */
+export const makeRequires = (deps) => {
+    return (spec, options = {}) => {
+        // Normalize once at registration time; validation errors surface at
+        // app boot, not at first request.
+        const normalized = normalizeSpec(spec);
+        const extractor = options.userId ?? deps.defaultUserIdExtractor;
+        const allowAnonymous = options.allowAnonymous ?? false;
+        return async (req, res, next) => {
+            const start = Date.now();
+            let userId = null;
+            if (extractor) {
+                const extracted = await extractor(req);
+                if (typeof extracted === "string" && extracted.length > 0) {
+                    userId = extracted;
+                }
+            }
+            if (!userId) {
+                if (allowAnonymous) {
+                    next();
+                    return;
+                }
+                await rejectUnauthorized(req, res, options, {
+                    userId: null,
+                    entitlement: normalized.entitlements[0] ?? "",
+                    missing: normalized.entitlements,
+                    reason: "no_user_id",
+                });
+                return;
+            }
+            let ents;
+            let cacheHit;
+            try {
+                const loaded = await deps.loadEntitlements(userId);
+                ents = loaded.entitlements;
+                cacheHit = loaded.cacheHit;
+            }
+            catch (err) {
+                // Surfaced to the framework's error handler. Default Express
+                // behavior is a 500; consumers can intercept via their own
+                // error middleware.
+                next(err);
+                return;
+            }
+            const missing = findMissing(normalized, ents);
+            deps.emitRequest({
+                userId,
+                entitlements: ents.active.map((e) => e.id),
+                cacheHit,
+                durationMs: Date.now() - start,
+            });
+            if (missing.length === 0) {
+                next();
+                return;
+            }
+            await rejectUnauthorized(req, res, options, {
+                userId,
+                entitlement: missing[0] ?? normalized.entitlements[0] ?? "",
+                missing,
+                reason: "not_entitled",
+            });
+        };
+    };
+};
+const rejectUnauthorized = async (req, res, options, ctx) => {
+    if (options.onUnauthorized) {
+        await options.onUnauthorized(req, res, ctx);
+        return;
+    }
+    res.status(403).json({
+        error: "entitlement_required",
+        entitlement: ctx.entitlement,
+    });
+};

package/dist/spec.d.ts

@@ -0,0 +1,19 @@
+import type { Entitlements } from "@superwall/core";
+import type { EntitlementSpec } from "./types.js";
+export interface NormalizedSpec {
+    readonly mode: "all" | "any";
+    readonly entitlements: ReadonlyArray<string>;
+}
+/**
+ * Normalize any accepted spec shape into `{ mode, entitlements }`.
+ * Throws on empty / malformed input — fail loud at config time, not
+ * at request time.
+ */
+export declare const normalizeSpec: (spec: EntitlementSpec) => NormalizedSpec;
+/**
+ * Returns the entitlement IDs from `spec` that are NOT active on `ents`.
+ * If `mode === "all"`, this is the set of unmet entitlements. If
+ * `mode === "any"`, returns empty when at least one is met, otherwise
+ * returns all listed entitlements (none satisfied).
+ */
+export declare const findMissing: (spec: NormalizedSpec, ents: Entitlements) => ReadonlyArray<string>;

package/dist/spec.js

@@ -0,0 +1,49 @@
+/**
+ * Normalize any accepted spec shape into `{ mode, entitlements }`.
+ * Throws on empty / malformed input — fail loud at config time, not
+ * at request time.
+ */
+export const normalizeSpec = (spec) => {
+    if (typeof spec === "string") {
+        if (spec.length === 0) {
+            throw new TypeError("Entitlement spec cannot be an empty string.");
+        }
+        return { mode: "all", entitlements: [spec] };
+    }
+    if (Array.isArray(spec)) {
+        if (spec.length === 0) {
+            throw new TypeError("Entitlement spec array cannot be empty.");
+        }
+        return { mode: "all", entitlements: spec };
+    }
+    if (typeof spec === "object" && spec !== null) {
+        if ("all" in spec) {
+            if (!Array.isArray(spec.all) || spec.all.length === 0) {
+                throw new TypeError("`{ all: [...] }` must be a non-empty string array.");
+            }
+            return { mode: "all", entitlements: spec.all };
+        }
+        if ("any" in spec) {
+            if (!Array.isArray(spec.any) || spec.any.length === 0) {
+                throw new TypeError("`{ any: [...] }` must be a non-empty string array.");
+            }
+            return { mode: "any", entitlements: spec.any };
+        }
+    }
+    throw new TypeError(`Unrecognized entitlement spec: ${JSON.stringify(spec)}. Expected string, string[], { all: string[] }, or { any: string[] }.`);
+};
+/**
+ * Returns the entitlement IDs from `spec` that are NOT active on `ents`.
+ * If `mode === "all"`, this is the set of unmet entitlements. If
+ * `mode === "any"`, returns empty when at least one is met, otherwise
+ * returns all listed entitlements (none satisfied).
+ */
+export const findMissing = (spec, ents) => {
+    const activeIds = new Set(ents.active.map((e) => e.id));
+    if (spec.mode === "all") {
+        return spec.entitlements.filter((id) => !activeIds.has(id));
+    }
+    // any
+    const anyMet = spec.entitlements.some((id) => activeIds.has(id));
+    return anyMet ? [] : spec.entitlements;
+};

package/dist/superwall.d.ts

@@ -0,0 +1,16 @@
+import { type FetcherConfig } from "./fetcher.js";
+import type { SuperwallInstance, SuperwallOptions } from "./types.js";
+/**
+ * Construct a Superwall server instance. One per process — internally
+ * shares the cache and outbound HTTP config across all middleware and
+ * direct calls.
+ *
+ * ```ts
+ * const sw = Superwall({
+ *   apiKey: process.env.SUPERWALL_API_KEY!,
+ *   userId: (req) => req.session?.userId ?? null,
+ * })
+ * ```
+ */
+export declare const Superwall: <TReq = unknown>(options: SuperwallOptions<TReq>) => SuperwallInstance<TReq>;
+export type { FetcherConfig };

package/dist/superwall.js

@@ -0,0 +1,91 @@
+import { InMemoryCache } from "./cache.js";
+import { fetchEntitlements } from "./fetcher.js";
+import { findMissing, normalizeSpec } from "./spec.js";
+import { makeRequires } from "./requires.js";
+const DEFAULT_CACHE_TTL_MS = 60_000;
+const DEFAULT_CACHE_MAX = 10_000;
+const DEFAULT_TIMEOUT_MS = 5_000;
+/**
+ * Construct a Superwall server instance. One per process — internally
+ * shares the cache and outbound HTTP config across all middleware and
+ * direct calls.
+ *
+ * ```ts
+ * const sw = Superwall({
+ *   apiKey: process.env.SUPERWALL_API_KEY!,
+ *   userId: (req) => req.session?.userId ?? null,
+ * })
+ * ```
+ */
+export const Superwall = (options) => {
+    if (!options.apiKey || typeof options.apiKey !== "string") {
+        throw new TypeError("Superwall: `apiKey` is required.");
+    }
+    const cacheOpts = options.cache ?? {};
+    const ttlMs = cacheOpts.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+    const maxEntries = cacheOpts.maxEntries ?? DEFAULT_CACHE_MAX;
+    const cache = cacheOpts.storage === undefined || cacheOpts.storage === "memory"
+        ? new InMemoryCache(maxEntries)
+        : cacheOpts.storage;
+    const fetcherConfig = {
+        apiKey: options.apiKey,
+        environment: options.environment ?? "release",
+        timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    };
+    /** Fetch + cache for one userId. Inflight de-dup is intentionally
+     *  omitted for v0 — callers rarely concurrently lookup the same user
+     *  thousands of times, and the trade-off (extra closure per request)
+     *  isn't worth it before we measure. */
+    const loadEntitlements = async (userId) => {
+        const cached = await cache.get(userId);
+        if (cached)
+            return { entitlements: cached.value, cacheHit: true };
+        const ents = await fetchEntitlements(fetcherConfig, userId);
+        await cache.set(userId, { value: ents, expiresAt: Date.now() + ttlMs });
+        return { entitlements: ents, cacheHit: false };
+    };
+    const emitRequest = (info) => {
+        if (!options.onRequest)
+            return;
+        try {
+            options.onRequest(info);
+        }
+        catch {
+            // Telemetry hooks never break the request.
+        }
+    };
+    const getEntitlements = async (userId) => {
+        const start = Date.now();
+        const { entitlements, cacheHit } = await loadEntitlements(userId);
+        emitRequest({
+            userId,
+            entitlements: entitlements.active.map((e) => e.id),
+            cacheHit,
+            durationMs: Date.now() - start,
+        });
+        return entitlements;
+    };
+    const userHas = async (userId, spec) => {
+        const normalized = normalizeSpec(spec);
+        const ents = await getEntitlements(userId);
+        return findMissing(normalized, ents).length === 0;
+    };
+    const invalidate = async (userId) => {
+        await cache.delete(userId);
+    };
+    const invalidateAll = async () => {
+        await cache.clear();
+    };
+    const requires = makeRequires({
+        defaultUserIdExtractor: options.userId,
+        loadEntitlements,
+        emitRequest,
+    });
+    return {
+        requires,
+        userHas,
+        getEntitlements,
+        invalidate,
+        invalidateAll,
+    };
+};

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+import type { Entitlements, NetworkEnvironment } from "@superwall/core";
+/**
+ * Entitlement spec accepted by `sw.requires()` and `sw.userHas()`.
+ *
+ * - `"pro"` — single entitlement (must be active)
+ * - `["pro", "team"]` — multiple entitlements, ALL required
+ * - `{ all: [...] }` — explicit AND
+ * - `{ any: [...] }` — OR (any of the listed must be active)
+ */
+export type EntitlementSpec = string | ReadonlyArray<string> | {
+    readonly all: ReadonlyArray<string>;
+} | {
+    readonly any: ReadonlyArray<string>;
+};
+/**
+ * Cache adapter shape. The built-in `"memory"` storage implements this.
+ * Plug in Redis, KV, or any async store with the same surface.
+ *
+ * Keys are app-user IDs. Values are the parsed Entitlements bucket plus
+ * the timestamp it expires at.
+ */
+export interface CacheAdapter {
+    get(key: string): Promise<CacheEntry | null> | CacheEntry | null;
+    set(key: string, value: CacheEntry): Promise<void> | void;
+    delete(key: string): Promise<void> | void;
+    clear(): Promise<void> | void;
+}
+export interface CacheEntry {
+    readonly value: Entitlements;
+    readonly expiresAt: number;
+}
+export interface CacheOptions {
+    /** Time-to-live in milliseconds. Default 60_000 (60s). */
+    ttlMs?: number;
+    /** LRU cap; oldest evicted first. Default 10_000. */
+    maxEntries?: number;
+    /** `"memory"` or a custom adapter. Default `"memory"`. */
+    storage?: "memory" | CacheAdapter;
+}
+/**
+ * Extracts the user identifier from whatever request shape your framework
+ * uses. Safety-critical knob: read from authenticated session, never from
+ * request body / query string / unverified header.
+ */
+export type UserIdExtractor<TReq = unknown> = (req: TReq) => string | null | undefined | Promise<string | null | undefined>;
+export interface RequestInfo {
+    readonly userId: string;
+    readonly entitlements: ReadonlyArray<string>;
+    readonly cacheHit: boolean;
+    readonly durationMs: number;
+}
+export interface SuperwallOptions<TReq = unknown> {
+    /** Superwall API key. Read from `process.env.SUPERWALL_API_KEY`. */
+    apiKey: string;
+    /** Environment selector. Default `"release"`. */
+    environment?: NetworkEnvironment;
+    cache?: CacheOptions;
+    /** Default userId extractor; can be overridden per-call on `requires()`. */
+    userId?: UserIdExtractor<TReq>;
+    /** Hook invoked after every entitlement check. Use for tracing. */
+    onRequest?: (info: RequestInfo) => void;
+    /** Request timeout in milliseconds for outbound calls to Superwall. Default 5_000. */
+    timeoutMs?: number;
+}
+/**
+ * Narrow internal `fetch` surface. Not exported as a public option — server
+ * runtimes (Node 18+, Bun, Deno, Workers) all carry `globalThis.fetch`
+ * natively, and unlike the browser there's no CORS proxy use case. Tests
+ * stub `globalThis.fetch` directly.
+ */
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface ConnectStyleResponse {
+    status(code: number): ConnectStyleResponse;
+    json(body: unknown): unknown;
+    setHeader?(name: string, value: string): unknown;
+}
+export type ConnectStyleNext = (err?: unknown) => void;
+export type ConnectStyleRequest = Record<string, unknown>;
+export interface UnauthorizedContext {
+    readonly userId: string | null;
+    readonly entitlement: string;
+    readonly missing: ReadonlyArray<string>;
+    readonly reason: "no_user_id" | "not_entitled";
+}
+export interface RequiresOptions<TReq = unknown> {
+    /** Per-route userId override (rare). */
+    userId?: UserIdExtractor<TReq>;
+    /**
+     * Custom rejection handler. Default: respond `403 { error:
+     * "entitlement_required", entitlement }`.
+     */
+    onUnauthorized?: (req: TReq, res: ConnectStyleResponse, ctx: UnauthorizedContext) => void | Promise<void>;
+    /**
+     * Allow anonymous requests (no userId extracted) to fall through to the
+     * route handler. Defaults to `false` — fail closed. Set `true` when the
+     * route handler itself decides what to render for guests vs. entitled users.
+     */
+    allowAnonymous?: boolean;
+}
+export interface SuperwallInstance<TReq = unknown> {
+    requires(spec: EntitlementSpec, options?: RequiresOptions<TReq>): (req: TReq, res: ConnectStyleResponse, next: ConnectStyleNext) => Promise<void>;
+    userHas(userId: string, spec: EntitlementSpec): Promise<boolean>;
+    getEntitlements(userId: string): Promise<Entitlements>;
+    invalidate(userId: string): Promise<void>;
+    invalidateAll(): Promise<void>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/verify.d.ts

@@ -0,0 +1 @@
+export * from "@superwall/verify";

package/package.json

@@ -1,27 +1,41 @@
 {
   "name": "@superwall/server",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "type": "module",
   "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "@superwall/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./verify": {
-      "types": "./src/verify.ts",
-      "default": "./src/verify.ts"
+      "@superwall/source": "./src/verify.ts",
+      "types": "./dist/verify.d.ts",
+      "import": "./dist/verify.js",
+      "default": "./dist/verify.js"
     }
   },
   "scripts": {
     "test": "bun test",
     "typecheck": "tsc --noEmit",
-    "build": "echo 'no-op for v0; consumers import .ts directly via Bun/Vite/Next ESM'",
-    "clean": "rm -rf node_modules .turbo *.tsbuildinfo"
+    "build": "bun run ../../scripts/build-package.ts",
+    "clean": "rm -rf dist node_modules .turbo *.tsbuildinfo"
   },
   "dependencies": {
-    "@superwall/core": "^0.1.3",
-    "@superwall/verify": "^0.1.3"
+    "@superwall/core": "^0.2.0",
+    "@superwall/verify": "^0.2.0"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/.turbo/turbo-build.log

@@ -1,3 +0,0 @@
-
-$ echo 'no-op for v0; consumers import .ts directly via Bun/Vite/Next ESM'
-no-op for v0; consumers import .ts directly via Bun/Vite/Next ESM