limen-auth 0.0.0 → 0.0.2-beta.0

package/dist/routes.mjs

@@ -0,0 +1,58 @@
+import { defineClientPlugin, defineRoutes } from "./define-plugin.mjs";
+import { route } from "./route.mjs";
+//#region src/routes.ts
+/**
+* Core routes available on every client.
+*/
+function coreClientPlugin() {
+	return defineClientPlugin({
+		id: "core",
+		basePath: "/",
+		routes: defineRoutes(route()({
+			method: "GET",
+			path: "/sessions"
+		}), route()({
+			method: "POST",
+			path: "/signout",
+			clearSession: true
+		}), route()({
+			method: "POST",
+			path: "/revoke-sessions",
+			clearSession: true
+		}), route()({
+			method: "POST",
+			path: "/verify-email",
+			refetchSession: true
+		}), route()({
+			method: "POST",
+			path: "/email-verifications",
+			as: "requestEmailVerification"
+		})),
+		actions: (ctx) => ({ 
+		/**
+		* Revalidate session state with `GET /me`, update `$session`, and return the
+		* resolved value (`null` when signed out).
+		*
+		* Prefer subscribing to `$session` for reactive UI state (`data`, `isPending`,
+		* `error`). Use `getSession()` when you need an awaited server re-check, such
+		* as route guards or SSR revalidation after `initialSession`.
+		*/
+getSession: async () => {
+			await ctx.refetchSession();
+			const state = ctx.store.$session.get();
+			if (state.error) throw state.error;
+			return state.data;
+		} })
+	});
+}
+/**
+* Fetch and parse the current session for the reactive store.
+*/
+function createSessionHydrator(ctx) {
+	return async () => {
+		const raw = await ctx.fetch("/me", { method: "GET" });
+		return ctx.parseSession(raw);
+	};
+}
+//#endregion
+export { coreClientPlugin, createSessionHydrator };

package/dist/serialize.d.mts

@@ -0,0 +1,11 @@
+//#region src/serialize.d.ts
+/**
+ * Default request serializer: shallow camelCase → snake_case, drops `undefined`,
+ * leaves non-objects unchanged.
+ *
+ * `additionalFields` entries are merged into the top-level body verbatim.
+ * Known route fields win on key collisions.
+ */
+declare function defaultSerialize(input: unknown): unknown;
+//#endregion
+export { defaultSerialize };

package/dist/serialize.mjs

@@ -0,0 +1,23 @@
+import { camelToSnake } from "./helpers.mjs";
+//#region src/serialize.ts
+/**
+* Default request serializer: shallow camelCase → snake_case, drops `undefined`,
+* leaves non-objects unchanged.
+*
+* `additionalFields` entries are merged into the top-level body verbatim.
+* Known route fields win on key collisions.
+*/
+function defaultSerialize(input) {
+	if (input === null || input === void 0) return input;
+	if (typeof input !== "object" || Array.isArray(input)) return input;
+	const { additionalFields, ...rest } = input;
+	const out = {};
+	if (additionalFields && typeof additionalFields === "object" && !Array.isArray(additionalFields)) Object.assign(out, additionalFields);
+	for (const [key, value] of Object.entries(rest)) {
+		if (value === void 0) continue;
+		out[camelToSnake(key)] = value;
+	}
+	return out;
+}
+//#endregion
+export { defaultSerialize };

package/dist/session-store.d.mts

@@ -0,0 +1,29 @@
+import { LimenError } from "./errors.mjs";
+import { Session } from "./types.mjs";
+import { ReadableAtom } from "nanostores";
+
+//#region src/session-store.d.ts
+type SessionState<TFields = unknown> = {
+  /** The current session, or `null` when signed out. */data: Session<TFields> | null; /** True while a `/me` fetch is in flight. */
+  isPending: boolean;
+  /**
+   * The last non-401 failure (network error, 5xx, etc.). A 401 is not an error
+   * — it resolves to `data: null`. `error` is cleared on the next successful or
+   * 401 outcome.
+   */
+  error: LimenError | null;
+};
+type RefetchOptions = {
+  /** Skip the fetch when the last hydration ran within this many milliseconds. */maxAgeMs?: number; /** Skip the fetch when the session is signed out. */
+  skipSignedOut?: boolean;
+};
+type SessionStore<TFields = unknown> = {
+  readonly $session: ReadableAtom<SessionState<TFields>>;
+  setData(session: Session<TFields> | null): void;
+  /**
+   * Re-validate the session from the server.
+   */
+  refetch(options?: RefetchOptions): Promise<void>;
+};
+//#endregion
+export { SessionState, SessionStore };

package/dist/session-store.mjs

@@ -0,0 +1,79 @@
+import { LimenError } from "./errors.mjs";
+import { createSessionSync } from "./session-sync.mjs";
+import { atom, onMount } from "nanostores";
+//#region src/session-store.ts
+function createSessionStore(options) {
+	const $session = atom({
+		data: options.initialSession ?? null,
+		isPending: false,
+		error: null
+	});
+	let inFlightHydration = null;
+	let writeVersion = 0;
+	let lastRefreshedAt = 0;
+	const isStale = (requestVersion) => requestVersion !== writeVersion;
+	const fetchSessionFromServer = async () => {
+		const requestVersion = ++writeVersion;
+		$session.set({
+			data: $session.get().data,
+			isPending: true,
+			error: null
+		});
+		try {
+			const session = await options.hydrator();
+			if (isStale(requestVersion)) return;
+			$session.set({
+				data: session,
+				isPending: false,
+				error: null
+			});
+		} catch (err) {
+			if (isStale(requestVersion)) return;
+			if (err instanceof LimenError && err.isUnauthorized) {
+				$session.set({
+					data: null,
+					isPending: false,
+					error: null
+				});
+				return;
+			}
+			const error = err instanceof LimenError ? err : new LimenError(err instanceof Error ? err.message : "Failed to load session", 0, "unknown");
+			$session.set({
+				data: $session.get().data,
+				isPending: false,
+				error
+			});
+		}
+	};
+	const refetch = (options) => {
+		const { skipSignedOut, maxAgeMs } = options ?? {};
+		if (skipSignedOut && $session.get().data === null) return Promise.resolve();
+		if (maxAgeMs !== void 0 && Date.now() - lastRefreshedAt < maxAgeMs) return Promise.resolve();
+		if (!inFlightHydration) inFlightHydration = fetchSessionFromServer().finally(() => {
+			inFlightHydration = null;
+			lastRefreshedAt = Date.now();
+		});
+		return inFlightHydration;
+	};
+	const setData = (session) => {
+		writeVersion++;
+		$session.set({
+			data: session,
+			isPending: false,
+			error: null
+		});
+	};
+	const store = {
+		$session,
+		setData,
+		refetch
+	};
+	onMount($session, () => createSessionSync(store, {
+		fetchOnMount: options.initialSession === void 0,
+		crossTabSync: options.crossTabSync ?? false,
+		refetchOnWindowFocus: options.refetchOnWindowFocus ?? false
+	}));
+	return store;
+}
+//#endregion
+export { createSessionStore };

package/dist/session-sync.mjs

@@ -0,0 +1,47 @@
+import { createBroadcastChannel } from "./broadcast-channel.mjs";
+import { deepJsonEqual } from "./json-deep-equal.mjs";
+import { onNotify } from "nanostores";
+//#region src/session-sync.ts
+const CHANNEL_NAME = "limen.session";
+const FOCUS_REFETCH_THROTTLE_MS = 5e3;
+function createSessionSync(store, options) {
+	if (options.fetchOnMount) store.refetch();
+	const teardowns = [];
+	if (options.crossTabSync) teardowns.push(syncAcrossTabs(store));
+	if (options.refetchOnWindowFocus) teardowns.push(refetchOnFocus(store));
+	return () => {
+		for (const teardown of teardowns) teardown();
+	};
+}
+function syncAcrossTabs(store) {
+	const port = createBroadcastChannel(CHANNEL_NAME);
+	let lastData = store.$session.get().data;
+	const unsubscribe = port.subscribe((message) => {
+		lastData = message.data;
+		store.setData(message.data);
+	});
+	const unbindNotify = onNotify(store.$session, () => {
+		const data = store.$session.get().data;
+		if (deepJsonEqual(data, lastData)) return;
+		lastData = data;
+		port.post({ data });
+	});
+	return () => {
+		unbindNotify();
+		unsubscribe();
+		port.close();
+	};
+}
+function refetchOnFocus(store) {
+	if (typeof document === "undefined") return () => {};
+	const onVisibilityChange = () => {
+		if (document.visibilityState === "visible") store.refetch({
+			maxAgeMs: FOCUS_REFETCH_THROTTLE_MS,
+			skipSignedOut: true
+		});
+	};
+	document.addEventListener("visibilitychange", onVisibilityChange);
+	return () => document.removeEventListener("visibilitychange", onVisibilityChange);
+}
+//#endregion
+export { createSessionSync };

package/dist/solid/index.d.mts

@@ -1,10 +1,10 @@
-import { D as User, E as Session, O as SessionState, V as Prettify, _ as AuthClient, k as SessionStore, t as AnyClientPlugin, y as CreateAuthClientOptions } from "../define-plugin-Dv0xXIaH.mjs";
-import { Store, StoreValue } from "nanostores";
+import { Prettify } from "../type-utils.mjs";
+import { SessionState, SessionStore } from "../session-store.mjs";
+import { AuthClient, CreateAuthClientOptions, Session, User } from "../types.mjs";
+import { AnyClientPlugin } from "../define-plugin.mjs";
+import { useStore } from "./solid-store.mjs";
 import { Accessor } from "solid-js";
 
-//#region src/solid/solid-store.d.ts
-declare function useStore<SomeStore extends Store, Value extends StoreValue<SomeStore>>(store: SomeStore): Accessor<Value>;
-//#endregion
 //#region src/solid/index.d.ts
 /**
  * An {@link AuthClient} augmented with Solid primitives.
@@ -21,5 +21,4 @@ type SolidAuthClient<Plugins extends readonly AnyClientPlugin[], TFields = unkno
  */
 declare function createAuthClient<const Plugins extends readonly AnyClientPlugin[] = readonly [], TFields = unknown>(opts: CreateAuthClientOptions<Plugins, TFields>): SolidAuthClient<Plugins, TFields>;
 //#endregion
-export { type AuthClient, type CreateAuthClientOptions, type Session, type SessionState, type SessionStore, SolidAuthClient, type User, createAuthClient, useStore };
-//# sourceMappingURL=index.d.mts.map
+export { type AuthClient, type CreateAuthClientOptions, type Session, type SessionState, type SessionStore, SolidAuthClient, type User, createAuthClient, useStore };

package/dist/solid/index.mjs

@@ -1,18 +1,5 @@
-import { t as createAuthClient$1 } from "../client-Er91De-z.mjs";
-import { onCleanup } from "solid-js";
-import { createStore, reconcile } from "solid-js/store";
-//#region src/solid/solid-store.ts
-function useStore(store) {
-	const unbindActivation = store.listen(() => {});
-	const [state, setState] = createStore({ value: store.get() });
-	const unsubscribe = store.subscribe((value) => {
-		setState("value", reconcile(value));
-	});
-	onCleanup(() => unsubscribe());
-	unbindActivation();
-	return () => state.value;
-}
-//#endregion
+import { createAuthClient as createAuthClient$1 } from "../client.mjs";
+import { useStore } from "./solid-store.mjs";
 //#region src/solid/index.ts
 /**
 * Create a Limen auth client with Solid primitives attached.
@@ -24,5 +11,3 @@ function createAuthClient(opts) {
 }
 //#endregion
 export { createAuthClient, useStore };
-
-//# sourceMappingURL=index.mjs.map

package/dist/solid/solid-store.d.mts

@@ -0,0 +1,7 @@
+import { Store, StoreValue } from "nanostores";
+import { Accessor } from "solid-js";
+
+//#region src/solid/solid-store.d.ts
+declare function useStore<SomeStore extends Store, Value extends StoreValue<SomeStore>>(store: SomeStore): Accessor<Value>;
+//#endregion
+export { useStore };

package/dist/solid/solid-store.mjs

@@ -0,0 +1,15 @@
+import { onCleanup } from "solid-js";
+import { createStore, reconcile } from "solid-js/store";
+//#region src/solid/solid-store.ts
+function useStore(store) {
+	const unbindActivation = store.listen(() => {});
+	const [state, setState] = createStore({ value: store.get() });
+	const unsubscribe = store.subscribe((value) => {
+		setState("value", reconcile(value));
+	});
+	onCleanup(() => unsubscribe());
+	unbindActivation();
+	return () => state.value;
+}
+//#endregion
+export { useStore };

package/dist/svelte/index.d.mts

@@ -1,4 +1,7 @@
-import { D as User, E as Session, O as SessionState, V as Prettify, _ as AuthClient, k as SessionStore, t as AnyClientPlugin, y as CreateAuthClientOptions } from "../define-plugin-Dv0xXIaH.mjs";
+import { Prettify } from "../type-utils.mjs";
+import { SessionState, SessionStore } from "../session-store.mjs";
+import { AuthClient, CreateAuthClientOptions, Session, User } from "../types.mjs";
+import { AnyClientPlugin } from "../define-plugin.mjs";
 import { Readable } from "svelte/store";
 
 //#region src/svelte/index.d.ts
@@ -21,5 +24,4 @@ type SvelteAuthClient<Plugins extends readonly AnyClientPlugin[], TFields = unkn
  */
 declare function createAuthClient<const Plugins extends readonly AnyClientPlugin[] = readonly [], TFields = unknown>(opts: CreateAuthClientOptions<Plugins, TFields>): SvelteAuthClient<Plugins, TFields>;
 //#endregion
-export { type AuthClient, type CreateAuthClientOptions, type Session, type SessionState, type SessionStore, SvelteAuthClient, type User, createAuthClient };
-//# sourceMappingURL=index.d.mts.map
+export { type AuthClient, type CreateAuthClientOptions, type Session, type SessionState, type SessionStore, SvelteAuthClient, type User, createAuthClient };

package/dist/svelte/index.mjs

@@ -1,4 +1,4 @@
-import { t as createAuthClient$1 } from "../client-Er91De-z.mjs";
+import { createAuthClient as createAuthClient$1 } from "../client.mjs";
 //#region src/svelte/index.ts
 /**
 * Create a Limen auth client with Svelte stores attached.
@@ -14,5 +14,3 @@ function createAuthClient(opts) {
 }
 //#endregion
 export { createAuthClient };
-
-//# sourceMappingURL=index.mjs.map

package/dist/type-utils.d.mts

@@ -0,0 +1,15 @@
+//#region src/type-utils.d.ts
+/** Collapse an intersection into a single readable object type on hover. */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/** Turn a union `A | B | C` into the intersection `A & B & C`. */
+type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+/**
+ * Convert a kebab-case literal to camelCase: `"magic-link"` -> `"magicLink"`.
+ */
+type KebabToCamel<S extends string> = S extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<KebabToCamel<Tail>>}` : S;
+/** Split a string literal into a tuple on a delimiter, dropping empty segments. */
+type Split<S extends string, D extends string> = S extends `${infer Head}${D}${infer Tail}` ? Head extends "" ? Split<Tail, D> : [Head, ...Split<Tail, D>] : S extends "" ? [] : [S];
+/** Check if a type is `any`. */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+//#endregion
+export { IsAny, KebabToCamel, Prettify, Split, UnionToIntersection };

package/dist/types.d.mts

@@ -0,0 +1,97 @@
+import { Prettify } from "./type-utils.mjs";
+import { FetcherFetchOptions } from "./fetcher.mjs";
+import { CoreContribution } from "./routes.mjs";
+import { SessionState } from "./session-store.mjs";
+import { PluginOverrides } from "./plugin.mjs";
+import { AnyClientPlugin, CombinedClientContributions } from "./define-plugin.mjs";
+import { ReadableAtom } from "nanostores";
+
+//#region src/types.d.ts
+type ClientFetchOptions = Partial<FetcherFetchOptions>;
+type CreateAuthClientOptions<Plugins extends readonly AnyClientPlugin[], TFields = unknown> = {
+  /** Server origin, e.g. `"http://localhost:8080"`. Trailing slash is stripped. */baseURL: string; /** Path where the Limen handler is mounted. Defaults to `"/auth"`. */
+  basePath?: string; /** Options that modify how the SDK performs HTTP requests. */
+  fetchOptions?: ClientFetchOptions;
+  /**
+   * Optional transformer for non-default session payloads.
+   *
+   * Provide this when your server returns custom user/session fields. It must
+   * map the raw response into `Session<TFields>`.
+   */
+  parseSession?: ParseSession<TFields>;
+  /**
+   * How the SDK navigates the browser when a flow hands control to an external
+   * page (e.g. an OAuth provider's authorization URL). Defaults to
+   * `window.location.href = url` when a `window` is available; a no-op in
+   * non-browser environments. Provide a custom function to integrate with a
+   * client-side router.
+   */
+  redirectFn?: RedirectFn; /** Plugins to register. */
+  plugins?: Plugins;
+  /**
+   * Response-envelope config. Set this when the server wraps successful or all
+   * responses.
+   */
+  envelope?: EnvelopeConfig;
+  /**
+   * Per-plugin route overrides. Keys are camelCased plugin ids, e.g.
+   * `{ magicLink: { basePath: "/passwordless" } }`.
+   */
+  overrides?: PluginOverrides<Plugins>;
+  /**
+   * SSR seed for the session store. Provide the session resolved server-side to
+   * avoid a hydration flash. When provided, lazy hydration is skipped until you
+   * call `getSession()` or the store revalidates.
+   */
+  initialSession?: Session<TFields> | null;
+  /**
+   * Keep session state in sync across browser tabs.
+   * Enabled by default in browsers. Set `false` to disable.
+   */
+  crossTabSync?: boolean;
+  /**
+   * Refresh session state when the tab becomes active again.
+   * Enabled by default in browsers. Set `false` to disable.
+   */
+  refetchOnWindowFocus?: boolean;
+};
+type AuthClient<Plugins extends readonly AnyClientPlugin[], TFields = unknown> = Prettify<{
+  readonly baseURL: string;
+  readonly basePath: string;
+  /**
+   * Reactive session store holding `{ data, isPending, error }`. Read it with
+   * `.get()` / `.listen()` or a framework `useStore`.
+   */
+  readonly $session: ReadableAtom<SessionState<TFields>>;
+} & CoreContribution<TFields> & CombinedClientContributions<Plugins>>;
+/**
+ * The user object returned from `/me` and any session-bearing response.
+ *
+ * `TFields` lets consumers extend the shape with custom user fields. The
+ * fields listed here are always present.
+ *
+ * @example
+ *   type AppUser = User<{ firstName: string; orgId: string }>;
+ */
+type User<TFields = unknown> = {
+  id: string;
+  email: string;
+  emailVerifiedAt: string | null;
+} & TFields;
+type Session<TFields = unknown> = {
+  user: User<TFields>;
+};
+type EnvelopeMode = "off" | "wrap-success" | "always";
+type EnvelopeFields = {
+  data: string;
+  message: string;
+};
+type EnvelopeConfig = {
+  mode: EnvelopeMode;
+  fields?: EnvelopeFields;
+};
+type ParseSession<TFields = unknown> = (raw: unknown) => Session<TFields>;
+type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+type RedirectFn = (url: string) => boolean;
+//#endregion
+export { AuthClient, ClientFetchOptions, CreateAuthClientOptions, EnvelopeConfig, EnvelopeFields, EnvelopeMode, HTTPMethod, ParseSession, RedirectFn, Session, User };

package/dist/version.d.mts

@@ -0,0 +1,4 @@
+//#region src/version.d.ts
+declare const VERSION: string;
+//#endregion
+export { VERSION };

package/dist/version.mjs

@@ -0,0 +1,5 @@
+import { version } from "./package.mjs";
+//#region src/version.ts
+const VERSION = version;
+//#endregion
+export { VERSION };

package/dist/vue/index.d.mts

@@ -1,21 +1,9 @@
-import { D as User, E as Session, O as SessionState, V as Prettify, _ as AuthClient, k as SessionStore, t as AnyClientPlugin, y as CreateAuthClientOptions } from "../define-plugin-Dv0xXIaH.mjs";
-import { Store, StoreValue } from "nanostores";
-import { DeepReadonly, ShallowRef, UnwrapNestedRefs } from "vue";
+import { Prettify } from "../type-utils.mjs";
+import { SessionState, SessionStore } from "../session-store.mjs";
+import { AuthClient, CreateAuthClientOptions, Session, User } from "../types.mjs";
+import { AnyClientPlugin } from "../define-plugin.mjs";
+import { ReactiveValue, useStore } from "./vue-store.mjs";
 
-//#region src/vue/vue-store.d.ts
-/** What {@link useStore} returns: a readonly reactive ref of the store value. */
-type ReactiveValue<Value> = DeepReadonly<UnwrapNestedRefs<ShallowRef<Value>>>;
-/**
- * Subscribe a Vue component to a nanostores store.
- *
- * Modeled on `@nanostores/vue`'s `useStore`: a `shallowRef` mirrors the store
- * value, `subscribe` keeps it in sync (firing once immediately), and the
- * listener is torn down on scope dispose. On the server (no `window`) it reads
- * once without subscribing, so a store seeded with `initialSession` renders
- * without leaving a subscription behind.
- */
-declare function useStore<SomeStore extends Store>(store: SomeStore): ReactiveValue<StoreValue<SomeStore>>;
-//#endregion
 //#region src/vue/index.d.ts
 /**
  * An {@link AuthClient} augmented with Vue composables.
@@ -32,5 +20,4 @@ type VueAuthClient<Plugins extends readonly AnyClientPlugin[], TFields = unknown
  */
 declare function createAuthClient<const Plugins extends readonly AnyClientPlugin[] = readonly [], TFields = unknown>(opts: CreateAuthClientOptions<Plugins, TFields>): VueAuthClient<Plugins, TFields>;
 //#endregion
-export { type AuthClient, type CreateAuthClientOptions, type ReactiveValue, type Session, type SessionState, type SessionStore, type User, VueAuthClient, createAuthClient, useStore };
-//# sourceMappingURL=index.d.mts.map
+export { type AuthClient, type CreateAuthClientOptions, type ReactiveValue, type Session, type SessionState, type SessionStore, type User, VueAuthClient, createAuthClient, useStore };

package/dist/vue/index.mjs

@@ -1,26 +1,5 @@
-import { t as createAuthClient$1 } from "../client-Er91De-z.mjs";
-import { getCurrentScope, onScopeDispose, readonly, shallowRef } from "vue";
-//#region src/vue/vue-store.ts
-/**
-* Subscribe a Vue component to a nanostores store.
-*
-* Modeled on `@nanostores/vue`'s `useStore`: a `shallowRef` mirrors the store
-* value, `subscribe` keeps it in sync (firing once immediately), and the
-* listener is torn down on scope dispose. On the server (no `window`) it reads
-* once without subscribing, so a store seeded with `initialSession` renders
-* without leaving a subscription behind.
-*/
-function useStore(store) {
-	const state = shallowRef(store.get());
-	if (typeof window !== "undefined") {
-		const unsubscribe = store.subscribe((value) => {
-			state.value = value;
-		});
-		if (getCurrentScope()) onScopeDispose(unsubscribe);
-	}
-	return readonly(state);
-}
-//#endregion
+import { createAuthClient as createAuthClient$1 } from "../client.mjs";
+import { useStore } from "./vue-store.mjs";
 //#region src/vue/index.ts
 /**
 * Create a Limen auth client with Vue composables attached.
@@ -32,5 +11,3 @@ function createAuthClient(opts) {
 }
 //#endregion
 export { createAuthClient, useStore };
-
-//# sourceMappingURL=index.mjs.map

package/dist/vue/vue-store.d.mts

@@ -0,0 +1,18 @@
+import { Store, StoreValue } from "nanostores";
+import { DeepReadonly, ShallowRef, UnwrapNestedRefs } from "vue";
+
+//#region src/vue/vue-store.d.ts
+/** What {@link useStore} returns: a readonly reactive ref of the store value. */
+type ReactiveValue<Value> = DeepReadonly<UnwrapNestedRefs<ShallowRef<Value>>>;
+/**
+ * Subscribe a Vue component to a nanostores store.
+ *
+ * Modeled on `@nanostores/vue`'s `useStore`: a `shallowRef` mirrors the store
+ * value, `subscribe` keeps it in sync (firing once immediately), and the
+ * listener is torn down on scope dispose. On the server (no `window`) it reads
+ * once without subscribing, so a store seeded with `initialSession` renders
+ * without leaving a subscription behind.
+ */
+declare function useStore<SomeStore extends Store>(store: SomeStore): ReactiveValue<StoreValue<SomeStore>>;
+//#endregion
+export { ReactiveValue, useStore };

package/dist/vue/vue-store.mjs

@@ -0,0 +1,23 @@
+import { getCurrentScope, onScopeDispose, readonly, shallowRef } from "vue";
+//#region src/vue/vue-store.ts
+/**
+* Subscribe a Vue component to a nanostores store.
+*
+* Modeled on `@nanostores/vue`'s `useStore`: a `shallowRef` mirrors the store
+* value, `subscribe` keeps it in sync (firing once immediately), and the
+* listener is torn down on scope dispose. On the server (no `window`) it reads
+* once without subscribing, so a store seeded with `initialSession` renders
+* without leaving a subscription behind.
+*/
+function useStore(store) {
+	const state = shallowRef(store.get());
+	if (typeof window !== "undefined") {
+		const unsubscribe = store.subscribe((value) => {
+			state.value = value;
+		});
+		if (getCurrentScope()) onScopeDispose(unsubscribe);
+	}
+	return readonly(state);
+}
+//#endregion
+export { useStore };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "limen-auth",
-  "version": "0.0.0",
-  "description": "TypeScript authentication client for Limen — framework-agnostic core with React, Vue, Svelte, and Solid adapters.",
+  "version": "0.0.2-beta.0",
+  "description": "Official TypeScript SDK for Limen, a composable Go auth library. Framework-agnostic core with React, Vue, Svelte, and Solid adapters.",
   "keywords": [
     "limen",
     "auth",
@@ -18,7 +18,7 @@
     "typescript",
     "sdk"
   ],
-  "homepage": "https://github.com/thecodearcher/limen#readme",
+  "homepage": "https://limenauth.dev",
   "bugs": "https://github.com/thecodearcher/limen/issues",
   "repository": {
     "type": "git",
@@ -29,6 +29,7 @@
   "author": "Brian Iyoha <brian.iyoha@gmail.com>",
   "type": "module",
   "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "publishConfig": {
     "access": "public"
   },