better-auth-nuxt 0.0.9 → 0.0.10-beta.20

package/dist/runtime/server/api/_better-auth/config.get.js

@@ -0,0 +1,47 @@
+import { defineEventHandler } from "nitro/h3";
+import { useRuntimeConfig } from "nitro/runtime-config";
+import { serverAuth } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const auth = serverAuth(event);
+    const options = auth.options;
+    const runtimeConfig = useRuntimeConfig();
+    const publicAuth = runtimeConfig.public?.auth;
+    const privateAuth = runtimeConfig.auth;
+    const sessionConfig = options.session || {};
+    const expiresInDays = sessionConfig.expiresIn ? Math.round(sessionConfig.expiresIn / 86400) : 7;
+    const updateAgeDays = sessionConfig.updateAge ? Math.round(sessionConfig.updateAge / 86400) : 1;
+    return {
+      config: {
+        // Module config (nuxt.config.ts)
+        module: {
+          redirects: publicAuth?.redirects || { login: "/login", guest: "/" },
+          secondaryStorage: privateAuth?.secondaryStorage ?? false,
+          useDatabase: publicAuth?.useDatabase ?? false
+        },
+        // Server config (server/auth.config.ts)
+        server: {
+          baseURL: options.baseURL,
+          basePath: options.basePath || "/api/auth",
+          socialProviders: Object.keys(options.socialProviders || {}),
+          plugins: (options.plugins || []).map((p) => p.id || "unknown"),
+          trustedOrigins: options.trustedOrigins || [],
+          session: {
+            expiresIn: `${expiresInDays} days`,
+            updateAge: `${updateAgeDays} days`,
+            cookieCache: sessionConfig.cookieCache?.enabled ?? false
+          },
+          emailAndPassword: !!options.emailAndPassword,
+          rateLimit: options.rateLimit?.enabled ?? false,
+          advanced: {
+            useSecureCookies: options.advanced?.useSecureCookies ?? "auto",
+            disableCSRFCheck: options.advanced?.disableCSRFCheck ?? false
+          }
+        }
+      }
+    };
+  } catch (error) {
+    console.error("[DevTools] Config fetch failed:", error);
+    return { config: null, error: "Failed to fetch configuration" };
+  }
+});

package/dist/runtime/server/api/_better-auth/sessions.delete.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("nitro/h3").EventHandlerWithFetch<import("nitro/h3").EventHandlerRequest, Promise<{
+    success: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/api/_better-auth/sessions.delete.js

@@ -0,0 +1,22 @@
+import { defineEventHandler, HTTPError, readBody } from "nitro/h3";
+import { z } from "zod";
+const deleteSessionSchema = z.object({
+  id: z.string().min(1, "Session ID required")
+});
+export default defineEventHandler(async (event) => {
+  try {
+    const body = deleteSessionSchema.parse(await readBody(event));
+    const { db, schema } = await import("@nuxthub/db");
+    if (!schema.session)
+      throw new HTTPError("Session table not found", { status: 500 });
+    const { eq } = await import("drizzle-orm");
+    await db.delete(schema.session).where(eq(schema.session.id, body.id));
+    return { success: true };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      throw new HTTPError(error.errors[0]?.message || "Invalid request", { status: 400 });
+    }
+    console.error("[DevTools] Delete session failed:", error);
+    throw new HTTPError("Failed to delete session", { status: 500 });
+  }
+});

package/dist/runtime/server/api/_better-auth/sessions.get.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("nitro/h3").EventHandlerWithFetch<import("nitro/h3").EventHandlerRequest, Promise<{
+    sessions: never[];
+    total: number;
+    error: string;
+    page?: undefined;
+    limit?: undefined;
+} | {
+    sessions: any;
+    total: any;
+    page: number;
+    limit: number;
+    error?: undefined;
+}>>;
+export default _default;

package/dist/runtime/server/api/_better-auth/sessions.get.js

@@ -0,0 +1,43 @@
+import { defineEventHandler, getQuery } from "nitro/h3";
+import { paginationQuerySchema, sanitizeSearchPattern } from "./_schema.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const { db, schema } = await import("@nuxthub/db");
+    if (!schema.session)
+      return { sessions: [], total: 0, error: "Session table not found" };
+    const query = paginationQuerySchema.parse(getQuery(event));
+    const { page, limit, search } = query;
+    const offset = (page - 1) * limit;
+    const { count, like, or, desc } = await import("drizzle-orm");
+    let dbQuery = db.select().from(schema.session);
+    let countQuery = db.select({ count: count() }).from(schema.session);
+    if (search) {
+      const pattern = sanitizeSearchPattern(search);
+      const searchCondition = or(
+        like(schema.session.userId, pattern),
+        schema.session.ipAddress ? like(schema.session.ipAddress, pattern) : void 0
+      );
+      if (searchCondition) {
+        dbQuery = dbQuery.where(searchCondition);
+        countQuery = countQuery.where(searchCondition);
+      }
+    }
+    const [sessions, totalResult] = await Promise.all([
+      dbQuery.orderBy(desc(schema.session.createdAt)).limit(limit).offset(offset),
+      countQuery
+    ]);
+    const safeSessions = sessions.map((s) => ({
+      id: s.id,
+      userId: s.userId,
+      createdAt: s.createdAt,
+      updatedAt: s.updatedAt,
+      expiresAt: s.expiresAt,
+      ipAddress: s.ipAddress,
+      userAgent: s.userAgent
+    }));
+    return { sessions: safeSessions, total: totalResult[0]?.count ?? 0, page, limit };
+  } catch (error) {
+    console.error("[DevTools] Fetch sessions failed:", error);
+    return { sessions: [], total: 0, error: "Failed to fetch sessions" };
+  }
+});

package/dist/runtime/server/api/_better-auth/users.get.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("nitro/h3").EventHandlerWithFetch<import("nitro/h3").EventHandlerRequest, Promise<{
+    users: never[];
+    total: number;
+    error: string;
+    page?: undefined;
+    limit?: undefined;
+} | {
+    users: any;
+    total: any;
+    page: number;
+    limit: number;
+    error?: undefined;
+}>>;
+export default _default;

package/dist/runtime/server/api/_better-auth/users.get.js

@@ -0,0 +1,34 @@
+import { defineEventHandler, getQuery } from "nitro/h3";
+import { paginationQuerySchema, sanitizeSearchPattern } from "./_schema.js";
+export default defineEventHandler(async (event) => {
+  try {
+    const { db, schema } = await import("@nuxthub/db");
+    if (!schema.user)
+      return { users: [], total: 0, error: "User table not found" };
+    const query = paginationQuerySchema.parse(getQuery(event));
+    const { page, limit, search } = query;
+    const offset = (page - 1) * limit;
+    const { count, like, or, desc } = await import("drizzle-orm");
+    let dbQuery = db.select().from(schema.user);
+    let countQuery = db.select({ count: count() }).from(schema.user);
+    if (search) {
+      const pattern = sanitizeSearchPattern(search);
+      const searchCondition = or(
+        like(schema.user.name, pattern),
+        like(schema.user.email, pattern)
+      );
+      if (searchCondition) {
+        dbQuery = dbQuery.where(searchCondition);
+        countQuery = countQuery.where(searchCondition);
+      }
+    }
+    const [users, totalResult] = await Promise.all([
+      dbQuery.orderBy(desc(schema.user.createdAt)).limit(limit).offset(offset),
+      countQuery
+    ]);
+    return { users, total: totalResult[0]?.count ?? 0, page, limit };
+  } catch (error) {
+    console.error("[DevTools] Fetch users failed:", error);
+    return { users: [], total: 0, error: "Failed to fetch users" };
+  }
+});

package/dist/runtime/server/api/auth/[...all].d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitro/h3").EventHandlerWithFetch<import("nitro/h3").EventHandlerRequest, Promise<Response>>;
+export default _default;

package/dist/runtime/server/api/auth/[...all].js

@@ -0,0 +1,6 @@
+import { defineEventHandler } from "nitro/h3";
+import { serverAuth } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  const auth = serverAuth(event);
+  return auth.handler(event.req);
+});

package/dist/runtime/server/middleware/route-access.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitro/h3").EventHandlerWithFetch<import("nitro/h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/middleware/route-access.js

@@ -0,0 +1,29 @@
+import { getRouteRules } from "nitro/app";
+import { defineEventHandler, getRequestURL, HTTPError } from "nitro/h3";
+import { matchesUser } from "../../utils/match-user.js";
+import { getUserSession, requireUserSession } from "../utils/session.js";
+export default defineEventHandler(async (event) => {
+  const path = getRequestURL(event).pathname;
+  if (!path.startsWith("/api/"))
+    return;
+  if (path.startsWith("/api/auth/"))
+    return;
+  const rules = getRouteRules(event.req.method, path);
+  if (!rules.auth)
+    return;
+  const auth = rules.auth;
+  const mode = typeof auth === "string" ? auth : auth?.only ?? "user";
+  if (mode === "guest") {
+    const session = await getUserSession(event);
+    if (session)
+      throw new HTTPError("Authenticated users not allowed", { status: 403 });
+    return;
+  }
+  if (mode === "user") {
+    const session = await requireUserSession(event);
+    if (typeof auth === "object" && auth.user) {
+      if (!matchesUser(session.user, auth.user))
+        throw new HTTPError("Access denied", { status: 403 });
+    }
+  }
+});

package/dist/runtime/server/tsconfig.json

@@ -1,3 +1,3 @@
 {
-  "extends": "../../../.nuxt/tsconfig.server.json",
+  "extends": "../../../.nuxt/tsconfig.server.json"
 }

package/dist/runtime/server/utils/auth.d.ts

@@ -0,0 +1,7 @@
+import type { Auth } from 'better-auth';
+import type { H3Event } from 'nitro/h3';
+import createServerAuth from '#auth/server';
+type AuthInstance = Auth<ReturnType<typeof createServerAuth>>;
+/** Returns Better Auth instance. Pass event for accurate URL detection on first call. */
+export declare function serverAuth(event?: H3Event): AuthInstance;
+export {};

package/dist/runtime/server/utils/auth.js

@@ -0,0 +1,81 @@
+import { createDatabase, db } from "#auth/database";
+import { createSecondaryStorage } from "#auth/secondary-storage";
+import createServerAuth from "#auth/server";
+import { betterAuth } from "better-auth";
+import { getRequestHost, getRequestProtocol } from "nitro/h3";
+import { useRuntimeConfig } from "nitro/runtime-config";
+import { withoutProtocol } from "ufo";
+let _auth = null;
+function validateURL(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    throw new Error(`Invalid siteUrl: "${url}". Must be a valid URL.`);
+  }
+}
+function getNitroOrigin(e) {
+  const cert = process.env.NITRO_SSL_CERT;
+  const key = process.env.NITRO_SSL_KEY;
+  let host = process.env.NITRO_HOST || process.env.HOST;
+  let port;
+  if (import.meta.dev)
+    port = process.env.NITRO_PORT || process.env.PORT || "3000";
+  let protocol = cert && key || !import.meta.dev ? "https" : "http";
+  try {
+    if ((import.meta.dev || import.meta.prerender) && process.env.__NUXT_DEV__) {
+      const origin = JSON.parse(process.env.__NUXT_DEV__).proxy.url;
+      host = withoutProtocol(origin);
+      protocol = origin.includes("https") ? "https" : "http";
+    } else if ((import.meta.dev || import.meta.prerender) && process.env.NUXT_VITE_NODE_OPTIONS) {
+      const origin = JSON.parse(process.env.NUXT_VITE_NODE_OPTIONS).baseURL.replace("/__nuxt_vite_node__", "");
+      host = withoutProtocol(origin);
+      protocol = origin.includes("https") ? "https" : "http";
+    } else if (e) {
+      host = getRequestHost(e, { xForwardedHost: true }) || host;
+      protocol = getRequestProtocol(e, { xForwardedProto: true }) || protocol;
+    }
+  } catch {
+  }
+  if (!host)
+    return void 0;
+  if (host.includes(":") && !host.startsWith("[")) {
+    const hostParts = host.split(":");
+    port = hostParts.pop();
+    host = hostParts.join(":");
+  }
+  const portSuffix = port ? `:${port}` : "";
+  return `${protocol}://${host}${portSuffix}`;
+}
+function getBaseURL(event) {
+  const config = useRuntimeConfig();
+  if (config.public.siteUrl && typeof config.public.siteUrl === "string")
+    return validateURL(config.public.siteUrl);
+  const nitroOrigin = getNitroOrigin(event);
+  if (nitroOrigin)
+    return validateURL(nitroOrigin);
+  if (process.env.VERCEL_URL)
+    return validateURL(`https://${process.env.VERCEL_URL}`);
+  if (process.env.CF_PAGES_URL)
+    return validateURL(`https://${process.env.CF_PAGES_URL}`);
+  if (process.env.URL)
+    return validateURL(process.env.URL.startsWith("http") ? process.env.URL : `https://${process.env.URL}`);
+  if (import.meta.dev)
+    return "http://localhost:3000";
+  throw new Error("siteUrl required. Set NUXT_PUBLIC_SITE_URL.");
+}
+export function serverAuth(event) {
+  if (_auth)
+    return _auth;
+  const runtimeConfig = useRuntimeConfig();
+  const siteUrl = getBaseURL(event);
+  const database = createDatabase();
+  const userConfig = createServerAuth({ runtimeConfig, db });
+  _auth = betterAuth({
+    ...userConfig,
+    ...database && { database },
+    secondaryStorage: createSecondaryStorage(),
+    secret: runtimeConfig.betterAuthSecret,
+    baseURL: siteUrl
+  });
+  return _auth;
+}

package/dist/runtime/server/utils/session.d.ts

@@ -0,0 +1,9 @@
+import type { H3Event } from 'nitro/h3';
+import type { AuthSession, AuthUser, RequireSessionOptions } from '../../types.js';
+interface FullSession {
+    user: AuthUser;
+    session: AuthSession;
+}
+export declare function getUserSession(event: H3Event): Promise<FullSession | null>;
+export declare function requireUserSession(event: H3Event, options?: RequireSessionOptions): Promise<FullSession>;
+export {};

package/dist/runtime/server/utils/session.js

@@ -0,0 +1,23 @@
+import { HTTPError } from "nitro/h3";
+import { matchesUser } from "../../utils/match-user.js";
+import { serverAuth } from "./auth.js";
+export async function getUserSession(event) {
+  const auth = serverAuth(event);
+  const session = await auth.api.getSession({ headers: event.headers });
+  return session;
+}
+export async function requireUserSession(event, options) {
+  const session = await getUserSession(event);
+  if (!session)
+    throw new HTTPError("Authentication required", { status: 401 });
+  if (options?.user) {
+    if (!matchesUser(session.user, options.user))
+      throw new HTTPError("Access denied", { status: 403 });
+  }
+  if (options?.rule) {
+    const allowed = await options.rule({ user: session.user, session: session.session });
+    if (!allowed)
+      throw new HTTPError("Access denied", { status: 403 });
+  }
+  return session;
+}

package/dist/runtime/types/augment.d.ts

@@ -0,0 +1,42 @@
+import type { ComputedRef, Ref } from 'vue';
+export interface AuthUser {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    email: string;
+    emailVerified: boolean;
+    name: string;
+    image?: string | null;
+}
+export interface AuthSession {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    userId: string;
+    expiresAt: Date;
+    token: string;
+    ipAddress?: string | null;
+    userAgent?: string | null;
+}
+export interface ServerAuthContext {
+    runtimeConfig: Record<string, unknown>;
+    db: unknown;
+}
+export interface UserSessionComposable {
+    client: unknown;
+    user: Ref<AuthUser | null>;
+    session: Ref<AuthSession | null>;
+    loggedIn: ComputedRef<boolean>;
+    ready: ComputedRef<boolean>;
+    signIn: unknown;
+    signUp: unknown;
+    fetchSession: (options?: {
+        headers?: HeadersInit;
+        force?: boolean;
+    }) => Promise<void>;
+    waitForSession: () => Promise<void>;
+    signOut: (options?: {
+        onSuccess?: () => void | Promise<void>;
+    }) => Promise<void>;
+    updateUser: (updates: Partial<AuthUser>) => void;
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,23 @@
+import type { NitroRouteRules } from 'nitro/types';
+import type { AuthSession, AuthUser } from './types/augment.js';
+export type { AuthSession, AuthUser, ServerAuthContext, UserSessionComposable } from './types/augment.js';
+export type { Auth, InferPluginTypes, InferSession, InferUser } from 'better-auth';
+export type AuthMode = 'guest' | 'user';
+export type UserMatch<T> = {
+    [K in keyof T]?: T[K] | T[K][];
+};
+export type AuthMeta = false | AuthMode | {
+    only?: AuthMode;
+    redirectTo?: string;
+    user?: UserMatch<AuthUser>;
+};
+export type AuthRouteRules = NitroRouteRules & {
+    auth?: AuthMeta;
+};
+export interface RequireSessionOptions {
+    user?: UserMatch<AuthUser>;
+    rule?: (ctx: {
+        user: AuthUser;
+        session: AuthSession;
+    }) => boolean | Promise<boolean>;
+}

package/dist/runtime/utils/match-user.d.ts

@@ -0,0 +1,2 @@
+import type { UserMatch } from '../types.js';
+export declare function matchesUser<T extends object>(user: T, match: UserMatch<T>): boolean;

package/dist/runtime/utils/match-user.js

@@ -0,0 +1,13 @@
+export function matchesUser(user, match) {
+  for (const [key, expected] of Object.entries(match)) {
+    const actual = user[key];
+    if (Array.isArray(expected)) {
+      if (!expected.includes(actual))
+        return false;
+    } else {
+      if (actual !== expected)
+        return false;
+    }
+  }
+  return true;
+}

package/dist/types.d.mts

@@ -1,9 +1,11 @@
-import type { ModulePublicRuntimeConfig } from './module.mjs'
+import type { NuxtModule } from '@nuxt/schema'
 
-declare module '@nuxt/schema' {
-  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
-}
+import type { default as Module } from './module.mjs'
 
-export { default } from './module.mjs'
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type BetterAuthModuleOptions, type defineClientAuth, type defineServerAuth } from '../dist/runtime/config.js'
 
-export { type ModuleClientOptions, type ModuleOptions, type ModulePublicRuntimeConfig, type ModuleServerOptions } from './module.mjs'
+export { type Auth, type AuthMeta, type AuthMode, type AuthRouteRules, type AuthSession, type AuthUser, type InferSession, type InferUser, type RequireSessionOptions, type ServerAuthContext, type UserMatch } from '../dist/runtime/types.js'
+
+export { default } from './module.mjs'

package/package.json

@@ -1,14 +1,34 @@
 {
   "name": "better-auth-nuxt",
-  "version": "0.0.9",
-  "description": "Better Auth Nuxt Module",
-  "repository": "productdevbook/better-auth-nuxt",
-  "license": "MIT",
   "type": "module",
+  "version": "0.0.10-beta.20",
+  "description": "Nuxt module for Better Auth integration with NuxtHub, route protection, session management, and role-based access",
+  "author": "onmax",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/onmax/nuxt-better-auth"
+  },
+  "agents": {
+    "skills": [
+      {
+        "name": "nuxt-better-auth",
+        "path": "./skills/nuxt-better-auth"
+      }
+    ]
+  },
   "exports": {
     ".": {
       "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs"
+    },
+    "./config": {
+      "types": "./dist/runtime/config.d.ts",
+      "import": "./dist/runtime/config.js"
+    },
+    "./adapters/convex": {
+      "types": "./dist/runtime/adapters/convex.d.ts",
+      "import": "./dist/runtime/adapters/convex.js"
     }
   },
   "main": "./dist/module.mjs",
@@ -16,51 +36,84 @@
     "*": {
       ".": [
         "./dist/types.d.mts"
+      ],
+      "config": [
+        "./dist/runtime/config.d.ts"
+      ],
+      "adapters/convex": [
+        "./dist/runtime/adapters/convex.d.ts"
       ]
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "skills"
   ],
   "peerDependencies": {
-    "better-auth": ">=1.2.7"
+    "@nuxthub/core": ">=0.10.5",
+    "better-auth": ">=1.0.0",
+    "convex": ">=1.25.0"
+  },
+  "peerDependenciesMeta": {
+    "@nuxthub/core": {
+      "optional": true
+    },
+    "convex": {
+      "optional": true
+    }
   },
   "dependencies": {
-    "@fastify/deepmerge": "^3.1.0",
-    "@nuxt/kit": "^3.17.3",
+    "@better-auth/cli": "^1.5.0-beta.3",
+    "@nuxt/kit": "^4.2.2",
+    "@nuxt/ui": "^4.2.1",
     "defu": "^6.1.4",
-    "ohash": "^2.0.11",
+    "jiti": "^2.4.2",
     "pathe": "^2.0.3",
-    "scule": "^1.3.0",
-    "tinyglobby": "^0.2.13"
+    "radix3": "^1.1.2",
+    "std-env": "^3.10.0"
   },
   "devDependencies": {
-    "@nuxt/devtools": "^2.4.1",
-    "@nuxt/eslint-config": "^1.4.0",
-    "@nuxt/module-builder": "^1.0.1",
-    "@nuxt/schema": "^3.17.3",
-    "@nuxt/test-utils": "^3.19.0",
-    "@tailwindcss/vite": "^4.1.7",
+    "@antfu/eslint-config": "^4.12.0",
+    "@libsql/client": "^0.15.15",
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/devtools-kit": "^3.1.1",
+    "@nuxt/kit": "https://pkg.pr.new/@nuxt/kit@33005",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "https://pkg.pr.new/@nuxt/schema@33005",
+    "@nuxt/test-utils": "^3.21.0",
+    "@nuxthub/core": "^0.10.5",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "latest",
-    "better-auth": "^1.2.8",
-    "better-sqlite3": "^11.10.0",
-    "changelogen": "^0.6.1",
-    "eslint": "^9.26.0",
-    "nuxt": "^3.17.3",
-    "typescript": "~5.8.3",
-    "vitest": "^3.1.3",
-    "vue-tsc": "^2.2.10"
+    "better-auth": "^1.5.0-beta.3",
+    "better-sqlite3": "^11.9.1",
+    "bumpp": "^10.3.2",
+    "changelogen": "^0.6.2",
+    "consola": "^3.4.2",
+    "drizzle-kit": "^0.31.8",
+    "drizzle-orm": "^0.38.4",
+    "eslint": "^9.39.1",
+    "nitro": "3.0.1-alpha.2",
+    "npm-agentskills": "https://pkg.pr.new/onmax/npm-agentskills@394499e",
+    "nuxt": "https://pkg.pr.new/nuxt@33005",
+    "tinyexec": "^1.0.2",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.15",
+    "vitest-package-exports": "^0.1.1",
+    "vue-tsc": "^3.1.7",
+    "yaml": "^2.8.2"
   },
   "scripts": {
-    "dev": "nuxi dev playground",
+    "dev": "pnpm dev:prepare && nuxi dev playground",
     "dev:build": "nuxi build playground",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
-    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && pnpm publish --no-git-checks --access public && git push --follow-tags",
+    "dev:docs": "nuxi dev docs",
+    "build:docs": "nuxi build docs",
+    "release": "pnpm publish --no-git-checks --access public --tag beta",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
+    "typecheck": "vue-tsc --noEmit",
+    "typecheck:playground": "cd playground && vue-tsc --noEmit",
     "test": "vitest run",
-    "test:watch": "vitest watch",
-    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+    "test:watch": "vitest watch"
   }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Wind
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/runtime/middleware/auth.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;