@classic-homes/theme-mcp 0.1.8 → 0.1.9

package/dist/index.js

@@ -11080,6 +11080,343 @@ var pattern_library_default = {
   <FormField label="Message" type="textarea" name="message" />
   <Button type="submit">Send Message</Button>
 </form>`
+    },
+    {
+      id: "mfa-verification-form",
+      name: "MFA Verification Form",
+      description: "Two-factor authentication code verification form",
+      schema: "mfaVerifySchema",
+      components: [
+        "FormField",
+        "OTPInput",
+        "Button",
+        "Checkbox",
+        "useForm"
+      ],
+      example: `<script lang="ts">
+  import { OTPInput, Button, Checkbox, useForm, mfaVerifySchema } from '@classic-homes/theme-svelte';
+  import { authApi } from '@classic-homes/auth/core';
+
+  export let mfaToken: string;
+  export let onSuccess: () => void;
+
+  const form = useForm({
+    schema: mfaVerifySchema,
+    initialValues: { code: '', trustDevice: false },
+    onSubmit: async (data) => {
+      await authApi.verifyMFAChallenge({ mfaToken, code: data.code, trustDevice: data.trustDevice });
+      onSuccess();
+    },
+  });
+</script>
+
+<form onsubmit={form.handleSubmit} class="space-y-4">
+  <OTPInput length={6} value={form.data.code} onValueChange={(v) => form.setField('code', v)} />
+  <Checkbox checked={form.data.trustDevice} onCheckedChange={(v) => form.setField('trustDevice', v)}>
+    Trust this device for 30 days
+  </Checkbox>
+  <Button type="submit" loading={form.isSubmitting} class="w-full">Verify</Button>
+</form>`
+    },
+    {
+      id: "mfa-setup-form",
+      name: "MFA Setup Form",
+      description: "MFA enrollment form with QR code display and code verification",
+      schema: "mfaSetupSchema",
+      components: [
+        "FormField",
+        "OTPInput",
+        "Button",
+        "Card",
+        "useForm"
+      ],
+      example: `<script lang="ts">
+  import { OTPInput, Button, Card, CardContent, useForm, mfaSetupSchema } from '@classic-homes/theme-svelte';
+  import { authApi } from '@classic-homes/auth/core';
+  import { onMount } from 'svelte';
+
+  let setupData: { qrCodeUrl: string; manualEntryKey: string } | null = null;
+
+  onMount(async () => {
+    setupData = await authApi.setupMFA();
+  });
+
+  const form = useForm({
+    schema: mfaSetupSchema,
+    initialValues: { code: '' },
+    onSubmit: async (data) => {
+      await authApi.verifyMFASetup(data.code);
+    },
+  });
+</script>
+
+{#if setupData}
+  <Card>
+    <CardContent class="space-y-4">
+      <img src={setupData.qrCodeUrl} alt="QR Code" class="mx-auto" />
+      <form onsubmit={form.handleSubmit}>
+        <OTPInput length={6} value={form.data.code} onValueChange={(v) => form.setField('code', v)} />
+        <Button type="submit" loading={form.isSubmitting} class="w-full mt-4">Verify & Enable MFA</Button>
+      </form>
+    </CardContent>
+  </Card>
+{/if}`
+    },
+    {
+      id: "profile-update-form",
+      name: "Profile Update Form",
+      description: "User profile editing form",
+      schema: "profileUpdateSchema",
+      components: [
+        "FormField",
+        "Button",
+        "useForm"
+      ],
+      example: `<script lang="ts">
+  import { FormField, Button, useForm, profileUpdateSchema } from '@classic-homes/theme-svelte';
+  import { authApi } from '@classic-homes/auth/core';
+  import { currentUser, authActions } from '@classic-homes/auth/svelte';
+
+  const form = useForm({
+    schema: profileUpdateSchema,
+    initialValues: {
+      firstName: $currentUser?.firstName ?? '',
+      lastName: $currentUser?.lastName ?? '',
+      email: $currentUser?.email ?? '',
+    },
+    onSubmit: async (data) => {
+      const updatedUser = await authApi.updateProfile(data);
+      authActions.updateUser(updatedUser);
+    },
+  });
+</script>
+
+<form onsubmit={form.handleSubmit} class="space-y-4">
+  <FormField label="First Name" name="firstName" value={form.data.firstName} onValueChange={(v) => form.setField('firstName', v)} />
+  <FormField label="Last Name" name="lastName" value={form.data.lastName} onValueChange={(v) => form.setField('lastName', v)} />
+  <FormField label="Email" type="email" name="email" value={form.data.email} onValueChange={(v) => form.setField('email', v)} />
+  <Button type="submit" loading={form.isSubmitting}>Save Changes</Button>
+</form>`
+    },
+    {
+      id: "change-password-form",
+      name: "Change Password Form",
+      description: "Form for authenticated users to change their password",
+      schema: "changePasswordSchema",
+      components: [
+        "FormField",
+        "Button",
+        "useForm"
+      ],
+      example: `<script lang="ts">
+  import { FormField, Button, useForm, changePasswordSchema } from '@classic-homes/theme-svelte';
+  import { authApi } from '@classic-homes/auth/core';
+
+  const form = useForm({
+    schema: changePasswordSchema,
+    initialValues: { currentPassword: '', newPassword: '', confirmPassword: '' },
+    onSubmit: async (data) => {
+      await authApi.changePassword({ currentPassword: data.currentPassword, newPassword: data.newPassword });
+    },
+  });
+</script>
+
+<form onsubmit={form.handleSubmit} class="space-y-4">
+  <FormField label="Current Password" type="password" name="currentPassword" value={form.data.currentPassword} onValueChange={(v) => form.setField('currentPassword', v)} />
+  <FormField label="New Password" type="password" name="newPassword" value={form.data.newPassword} onValueChange={(v) => form.setField('newPassword', v)} />
+  <FormField label="Confirm Password" type="password" name="confirmPassword" value={form.data.confirmPassword} onValueChange={(v) => form.setField('confirmPassword', v)} />
+  <Button type="submit" loading={form.isSubmitting}>Change Password</Button>
+</form>`
+    },
+    {
+      id: "forgot-password-form",
+      name: "Forgot Password Form",
+      description: "Password reset request form",
+      schema: "forgotPasswordSchema",
+      components: [
+        "FormField",
+        "Button",
+        "useForm"
+      ],
+      example: `<script lang="ts">
+  import { FormField, Button, useForm, forgotPasswordSchema } from '@classic-homes/theme-svelte';
+  import { authApi } from '@classic-homes/auth/core';
+
+  let submitted = false;
+
+  const form = useForm({
+    schema: forgotPasswordSchema,
+    initialValues: { email: '' },
+    onSubmit: async (data) => {
+      await authApi.forgotPassword(data.email);
+      submitted = true;
+    },
+  });
+</script>
+
+{#if submitted}
+  <p>Check your email for password reset instructions.</p>
+{:else}
+  <form onsubmit={form.handleSubmit} class="space-y-4">
+    <FormField label="Email" type="email" name="email" value={form.data.email} onValueChange={(v) => form.setField('email', v)} />
+    <Button type="submit" loading={form.isSubmitting} class="w-full">Send Reset Link</Button>
+  </form>
+{/if}`
+    },
+    {
+      id: "reset-password-form",
+      name: "Reset Password Form",
+      description: "Set new password form using reset token",
+      schema: "resetPasswordSchema",
+      components: [
+        "FormField",
+        "Button",
+        "useForm"
+      ],
+      example: `<script lang="ts">
+  import { FormField, Button, useForm, resetPasswordSchema } from '@classic-homes/theme-svelte';
+  import { authApi } from '@classic-homes/auth/core';
+  import { goto } from '$app/navigation';
+
+  export let token: string;
+
+  const form = useForm({
+    schema: resetPasswordSchema,
+    initialValues: { password: '', confirmPassword: '' },
+    onSubmit: async (data) => {
+      await authApi.resetPassword(token, data.password);
+      goto('/login?message=password-reset');
+    },
+  });
+</script>
+
+<form onsubmit={form.handleSubmit} class="space-y-4">
+  <FormField label="New Password" type="password" name="password" value={form.data.password} onValueChange={(v) => form.setField('password', v)} />
+  <FormField label="Confirm Password" type="password" name="confirmPassword" value={form.data.confirmPassword} onValueChange={(v) => form.setField('confirmPassword', v)} />
+  <Button type="submit" loading={form.isSubmitting} class="w-full">Reset Password</Button>
+</form>`
+    }
+  ],
+  auth: [
+    {
+      id: "login-with-mfa",
+      name: "Login with MFA Flow",
+      description: "Complete login flow handling MFA challenge when required",
+      components: [
+        "AuthLayout",
+        "FormField",
+        "Button",
+        "OTPInput",
+        "useForm"
+      ],
+      example: `<script lang="ts">
+  import { AuthLayout, FormField, Button, OTPInput, useForm, loginSchema, mfaVerifySchema } from '@classic-homes/theme-svelte';
+  import { authApi, isMfaChallengeResponse, getMfaToken } from '@classic-homes/auth/core';
+  import { authActions } from '@classic-homes/auth/svelte';
+  import { goto } from '$app/navigation';
+
+  let mfaRequired = false;
+  let mfaToken = '';
+
+  const loginForm = useForm({
+    schema: loginSchema,
+    initialValues: { email: '', password: '' },
+    onSubmit: async (data) => {
+      const response = await authActions.login(data);
+      if (isMfaChallengeResponse(response)) {
+        mfaRequired = true;
+        mfaToken = getMfaToken(response)!;
+      } else {
+        goto('/dashboard');
+      }
+    },
+  });
+</script>
+
+<AuthLayout logoSubtitle={mfaRequired ? 'Enter verification code' : 'Sign in'}>
+  {#if mfaRequired}
+    <OTPInput length={6} />
+    <Button class="w-full mt-4">Verify</Button>
+  {:else}
+    <form onsubmit={loginForm.handleSubmit}>
+      <FormField label="Email" type="email" name="email" />
+      <FormField label="Password" type="password" name="password" />
+      <Button type="submit" loading={loginForm.isSubmitting} class="w-full">Sign In</Button>
+    </form>
+  {/if}
+</AuthLayout>`
+    },
+    {
+      id: "sso-login",
+      name: "SSO Login Flow",
+      description: "Single Sign-On authentication with redirect handling",
+      components: [
+        "AuthLayout",
+        "Button"
+      ],
+      example: `<script lang="ts">
+  import { AuthLayout, Button } from '@classic-homes/theme-svelte';
+  import { authApi } from '@classic-homes/auth/core';
+
+  function handleSSOLogin() {
+    authApi.initiateSSOLogin({ redirectUrl: '/dashboard' });
+  }
+</script>
+
+<AuthLayout logoSubtitle="Sign in with your company account">
+  <Button onclick={handleSSOLogin} class="w-full" variant="outline">Sign in with SSO</Button>
+</AuthLayout>`
+    },
+    {
+      id: "session-management",
+      name: "Session Management",
+      description: "View and revoke active sessions",
+      components: [
+        "Card",
+        "Button"
+      ],
+      example: `<script lang="ts">
+  import { Card, CardHeader, CardTitle, CardContent, Button } from '@classic-homes/theme-svelte';
+  import { authApi } from '@classic-homes/auth/core';
+  import type { Session } from '@classic-homes/auth/core';
+  import { onMount } from 'svelte';
+
+  let sessions: Session[] = [];
+
+  onMount(async () => {
+    const response = await authApi.getSessions();
+    sessions = response.sessions;
+  });
+
+  async function revokeSession(sessionId: string) {
+    await authApi.revokeSession(sessionId);
+    sessions = sessions.filter(s => s.id !== sessionId);
+  }
+</script>
+
+<Card>
+  <CardHeader><CardTitle>Active Sessions</CardTitle></CardHeader>
+  <CardContent>
+    {#each sessions as session}
+      <div class="flex items-center justify-between py-2 border-b">
+        <div>
+          <p class="font-medium">{session.deviceName}</p>
+          <p class="text-sm text-muted-foreground">{session.location}</p>
+        </div>
+        {#if !session.isCurrent}
+          <Button variant="ghost" size="sm" onclick={() => revokeSession(session.id)}>Revoke</Button>
+        {/if}
+      </div>
+    {/each}
+  </CardContent>
+</Card>`
+    },
+    {
+      id: "protected-route",
+      name: "Protected Route",
+      description: "Route protection with auth guards in SvelteKit",
+      components: [],
+      example: "// +page.ts\nimport { requireAuth, requireRole, protectedLoad } from '@classic-homes/auth/svelte';\n\n// Simple auth requirement\nexport const load = requireAuth();\n\n// Role-based protection\nexport const load = requireRole('admin');\n\n// Custom protected load\nexport const load = protectedLoad(async (event, auth) => {\n  const data = await fetchData(event.fetch, auth.user.id);\n  return { user: auth.user, data };\n});"
     }
   ]
 };
@@ -11092,43 +11429,1479 @@ function registerLayoutResources(server) {
       {
         uri: uri.href,
         mimeType: "application/json",
-        text: JSON.stringify(patterns, null, 2)
+        text: JSON.stringify(patterns, null, 2)
+      }
+    ]
+  }));
+  server.resource("Layout Patterns", "patterns://layouts", async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(patterns.layouts, null, 2)
+      }
+    ]
+  }));
+  server.resource("Form Patterns", "patterns://forms", async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(patterns.forms, null, 2)
+      }
+    ]
+  }));
+  server.resource(
+    "Pattern Details",
+    new ResourceTemplate2("patterns://{id}", { list: void 0 }),
+    async (uri, params) => {
+      const id = params.id;
+      const layout = patterns.layouts.find((l) => l.id === id);
+      const form = patterns.forms.find((f) => f.id === id);
+      const pattern = layout || form;
+      if (!pattern) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({ error: `Pattern "${id}" not found` })
+            }
+          ]
+        };
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(pattern, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/data/schema-catalog.json
+var schema_catalog_default = {
+  auth: [
+    {
+      name: "emailSchema",
+      description: "Email validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "passwordSchema",
+      description: "Strong password (8+ chars, mixed case, numbers, special)",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "loginPasswordSchema",
+      description: "Simpler password validation for login",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "usernameSchema",
+      description: "Username validation (3-30 chars, alphanumeric)",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "fullNameSchema",
+      description: "Full name validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "phoneSchema",
+      description: "Phone number validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "mfaCodeSchema",
+      description: "MFA code validation (6 digits)",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "totpSecretSchema",
+      description: "TOTP secret validation (Base32 encoded)",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "mfaVerifySchema",
+      description: "MFA verification form schema (code + optional trust device)",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "mfaSetupSchema",
+      description: "MFA setup form schema (code verification during setup)",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "loginSchema",
+      description: "Complete login form schema",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "registerSchema",
+      description: "Complete registration form schema",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "forgotPasswordSchema",
+      description: "Forgot password form schema",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "resetPasswordSchema",
+      description: "Reset password form schema",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "changePasswordSchema",
+      description: "Change password form schema",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "profileUpdateSchema",
+      description: "Profile update form schema (firstName, lastName, email, phone)",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "emailChangeSchema",
+      description: "Email change form schema with password confirmation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "userSchema",
+      description: "User object validation schema",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "authTokensSchema",
+      description: "Auth tokens validation (accessToken, refreshToken)",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "loginResponseSchema",
+      description: "Login API response validation schema",
+      importPath: "@classic-homes/theme-svelte"
+    }
+  ],
+  common: [
+    {
+      name: "nonEmptyString",
+      description: "Non-empty string validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "trimmedString",
+      description: "Trimmed string",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "urlSchema",
+      description: "URL validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "slugSchema",
+      description: "URL slug validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "positiveInt",
+      description: "Positive integer validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "nonNegativeInt",
+      description: "Non-negative integer",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "percentageSchema",
+      description: "Percentage (0-100)",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "priceSchema",
+      description: "Price validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "isoDateSchema",
+      description: "ISO date string validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "futureDateSchema",
+      description: "Future date validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "pastDateSchema",
+      description: "Past date validation",
+      importPath: "@classic-homes/theme-svelte"
+    }
+  ],
+  file: [
+    {
+      name: "maxFileSize",
+      description: "File size limit validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "allowedFileTypes",
+      description: "File type validation",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "imageFileSchema",
+      description: "Image file validation",
+      importPath: "@classic-homes/theme-svelte"
+    }
+  ],
+  api: [
+    {
+      name: "apiResponseSchema",
+      description: "Standard API response schema",
+      importPath: "@classic-homes/theme-svelte"
+    },
+    {
+      name: "paginatedResponseSchema",
+      description: "Paginated API response",
+      importPath: "@classic-homes/theme-svelte"
+    }
+  ],
+  composables: [
+    {
+      name: "useForm",
+      description: "Form state management composable with Zod validation, field tracking, and submission handling",
+      importPath: "@classic-homes/theme-svelte",
+      example: "const form = useForm({\n  schema: loginSchema,\n  initialValues: { email: '', password: '' },\n  onSubmit: async (data) => { /* handle submit */ }\n});"
+    },
+    {
+      name: "usePersistedForm",
+      description: "Form composable with localStorage persistence for draft saving",
+      importPath: "@classic-homes/theme-svelte",
+      example: "const form = usePersistedForm('form-key', {\n  schema: registerSchema,\n  initialValues: { email: '', name: '' },\n  onSubmit: async (data) => { /* handle submit */ }\n});"
+    },
+    {
+      name: "useAsync",
+      description: "Async operation state management with loading, error, and data states",
+      importPath: "@classic-homes/theme-svelte",
+      example: "const { execute, isLoading, error, data } = useAsync(async () => {\n  return await fetchData();\n});"
+    }
+  ]
+};
+
+// src/resources/schemas.ts
+var schemas = schema_catalog_default;
+function registerSchemaResources(server) {
+  server.resource("schemas://all", "schemas://all", async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(schemas, null, 2)
+      }
+    ]
+  }));
+  server.resource("schemas://auth", "schemas://auth", async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(schemas.auth, null, 2)
+      }
+    ]
+  }));
+  server.resource("schemas://common", "schemas://common", async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(schemas.common, null, 2)
+      }
+    ]
+  }));
+}
+
+// src/resources/auth.ts
+import { ResourceTemplate as ResourceTemplate3 } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/data/auth-catalog.json
+var auth_catalog_default = {
+  version: "0.1.0",
+  packageName: "@classic-homes/auth",
+  description: "Authentication services and Svelte bindings for Classic Theme apps",
+  subpackages: {
+    core: {
+      importPath: "@classic-homes/auth/core",
+      description: "Framework-agnostic authentication core. Use this for direct API access or custom integrations.",
+      modules: {
+        config: {
+          description: "Authentication configuration and initialization",
+          functions: [
+            {
+              name: "initAuth",
+              signature: "(config: AuthConfig) => void",
+              description: "Initialize the auth system with configuration options",
+              example: "import { initAuth } from '@classic-homes/auth/core';\n\ninitAuth({\n  baseUrl: 'https://api.example.com',\n  storage: localStorage,\n  sso: {\n    enabled: true,\n    authorizeUrl: 'https://sso.example.com/authorize'\n  }\n});"
+            },
+            {
+              name: "getConfig",
+              signature: "() => AuthConfig",
+              description: "Get the current auth configuration"
+            },
+            {
+              name: "isInitialized",
+              signature: "() => boolean",
+              description: "Check if auth has been initialized"
+            },
+            {
+              name: "resetConfig",
+              signature: "() => void",
+              description: "Reset auth configuration to defaults"
+            },
+            {
+              name: "getDefaultStorage",
+              signature: "() => StorageAdapter",
+              description: "Get the default storage adapter (localStorage with fallback)"
+            },
+            {
+              name: "getStorage",
+              signature: "() => StorageAdapter",
+              description: "Get the configured storage adapter"
+            },
+            {
+              name: "getFetch",
+              signature: "() => typeof fetch",
+              description: "Get the configured fetch function"
+            }
+          ],
+          types: [
+            {
+              name: "AuthConfig",
+              description: "Configuration options for auth initialization",
+              properties: [
+                { name: "baseUrl", type: "string", required: true, description: "Base URL for auth API endpoints" },
+                { name: "storage", type: "StorageAdapter", required: false, description: "Storage adapter for tokens" },
+                { name: "fetch", type: "typeof fetch", required: false, description: "Custom fetch implementation" },
+                { name: "sso", type: "SSOConfig", required: false, description: "SSO configuration" }
+              ]
+            },
+            {
+              name: "SSOConfig",
+              description: "SSO provider configuration",
+              properties: [
+                { name: "enabled", type: "boolean", required: false, description: "Whether SSO is enabled" },
+                { name: "authorizeUrl", type: "string", required: false, description: "SSO authorization URL" }
+              ]
+            },
+            {
+              name: "StorageAdapter",
+              description: "Interface for token storage",
+              properties: [
+                { name: "getItem", type: "(key: string) => string | null", required: true, description: "Get item from storage" },
+                { name: "setItem", type: "(key: string, value: string) => void", required: true, description: "Set item in storage" },
+                { name: "removeItem", type: "(key: string) => void", required: true, description: "Remove item from storage" }
+              ]
+            }
+          ]
+        },
+        client: {
+          description: "HTTP client utilities for API requests",
+          functions: [
+            {
+              name: "api",
+              signature: "{ get, post, put, delete }",
+              description: "HTTP client object with methods for making API requests"
+            },
+            {
+              name: "apiRequest",
+              signature: "(url: string, options?: ApiRequestOptions) => Promise<Response>",
+              description: "Make an authenticated API request"
+            },
+            {
+              name: "extractData",
+              signature: "<T>(response: { data: T } | T) => T",
+              description: "Extract data from API response wrapper"
+            },
+            {
+              name: "getAccessToken",
+              signature: "() => string | null",
+              description: "Get the stored access token"
+            },
+            {
+              name: "getRefreshToken",
+              signature: "() => string | null",
+              description: "Get the stored refresh token"
+            },
+            {
+              name: "getSessionToken",
+              signature: "() => string | null",
+              description: "Get the stored session token"
+            },
+            {
+              name: "updateStoredTokens",
+              signature: "(tokens: { accessToken?: string; refreshToken?: string; sessionToken?: string }) => void",
+              description: "Update stored tokens"
+            },
+            {
+              name: "clearStoredAuth",
+              signature: "() => void",
+              description: "Clear all stored authentication data"
+            }
+          ],
+          types: [
+            {
+              name: "ApiRequestOptions",
+              description: "Options for API requests"
+            },
+            {
+              name: "ApiResponse",
+              description: "Standard API response wrapper"
+            }
+          ]
+        },
+        api: {
+          description: "Auth API client methods for all authentication endpoints",
+          functions: [
+            {
+              name: "authApi.login",
+              signature: "(credentials: LoginCredentials) => Promise<LoginResponse>",
+              description: "Login with username and password",
+              example: "import { authApi } from '@classic-homes/auth/core';\n\nconst response = await authApi.login({\n  username: 'user@example.com',\n  password: 'password'\n});\n\nif (response.requiresMFA) {\n  // Handle MFA challenge\n} else {\n  // Login success\n  console.log(response.user);\n}"
+            },
+            {
+              name: "authApi.logout",
+              signature: "() => Promise<LogoutResponse>",
+              description: "Logout the current user. Returns SSO logout URL if applicable."
+            },
+            {
+              name: "authApi.register",
+              signature: "(data: RegisterData) => Promise<RegisterResponse>",
+              description: "Register a new user"
+            },
+            {
+              name: "authApi.forgotPassword",
+              signature: "(email: string) => Promise<void>",
+              description: "Request a password reset email"
+            },
+            {
+              name: "authApi.resetPassword",
+              signature: "(token: string, newPassword: string) => Promise<void>",
+              description: "Reset password with a token"
+            },
+            {
+              name: "authApi.refreshToken",
+              signature: "(refreshToken: string) => Promise<{ accessToken: string; refreshToken: string }>",
+              description: "Refresh the access token"
+            },
+            {
+              name: "authApi.initiateSSOLogin",
+              signature: "(options?: { callbackUrl?: string; redirectUrl?: string }) => void",
+              description: "Initiate SSO login by redirecting to the SSO provider"
+            },
+            {
+              name: "authApi.getProfile",
+              signature: "(customFetch?: typeof fetch) => Promise<User>",
+              description: "Get the current user's profile"
+            },
+            {
+              name: "authApi.updateProfile",
+              signature: "(data: ProfileUpdateData) => Promise<User>",
+              description: "Update the current user's profile"
+            },
+            {
+              name: "authApi.changePassword",
+              signature: "(data: ChangePasswordData) => Promise<void>",
+              description: "Change the current user's password"
+            },
+            {
+              name: "authApi.resendVerification",
+              signature: "() => Promise<void>",
+              description: "Resend email verification"
+            },
+            {
+              name: "authApi.verifyEmail",
+              signature: "(token: string) => Promise<{ message: string; user?: User }>",
+              description: "Verify email with a token"
+            },
+            {
+              name: "authApi.getSessions",
+              signature: "(customFetch?: typeof fetch) => Promise<{ sessions: Session[]; total: number }>",
+              description: "Get all active sessions"
+            },
+            {
+              name: "authApi.revokeSession",
+              signature: "(sessionId: string) => Promise<void>",
+              description: "Revoke a specific session"
+            },
+            {
+              name: "authApi.revokeAllSessions",
+              signature: "() => Promise<void>",
+              description: "Revoke all sessions except the current one"
+            },
+            {
+              name: "authApi.getApiKeys",
+              signature: "(customFetch?: typeof fetch) => Promise<{ apiKeys: ApiKey[] }>",
+              description: "Get all API keys"
+            },
+            {
+              name: "authApi.createApiKey",
+              signature: "(data: CreateApiKeyRequest) => Promise<CreateApiKeyResponse>",
+              description: "Create a new API key"
+            },
+            {
+              name: "authApi.revokeApiKey",
+              signature: "(keyId: string) => Promise<void>",
+              description: "Revoke an API key"
+            },
+            {
+              name: "authApi.updateApiKey",
+              signature: "(keyId: string, data: { name: string }) => Promise<void>",
+              description: "Update an API key's name"
+            },
+            {
+              name: "authApi.getMFAStatus",
+              signature: "() => Promise<MFAStatus>",
+              description: "Get MFA status for the current user"
+            },
+            {
+              name: "authApi.setupMFA",
+              signature: "() => Promise<MFASetupResponse>",
+              description: "Setup MFA (get QR code and backup codes)"
+            },
+            {
+              name: "authApi.verifyMFASetup",
+              signature: "(code: string) => Promise<void>",
+              description: "Verify MFA setup with a code"
+            },
+            {
+              name: "authApi.disableMFA",
+              signature: "(password: string) => Promise<void>",
+              description: "Disable MFA"
+            },
+            {
+              name: "authApi.verifyMFAChallenge",
+              signature: "(data: MFAChallengeData) => Promise<LoginResponse>",
+              description: "Verify MFA challenge during login"
+            },
+            {
+              name: "authApi.getDevices",
+              signature: "(customFetch?: typeof fetch) => Promise<{ devices: Device[] }>",
+              description: "Get all devices"
+            },
+            {
+              name: "authApi.trustDevice",
+              signature: "(deviceId: string) => Promise<void>",
+              description: "Trust a device"
+            },
+            {
+              name: "authApi.revokeDevice",
+              signature: "(deviceId: string) => Promise<void>",
+              description: "Revoke device trust"
+            },
+            {
+              name: "authApi.removeDevice",
+              signature: "(deviceId: string) => Promise<void>",
+              description: "Remove a device completely"
+            },
+            {
+              name: "authApi.approveDevice",
+              signature: "(token: string) => Promise<{ message: string; device?: Device }>",
+              description: "Approve a device with a token"
+            },
+            {
+              name: "authApi.blockDevice",
+              signature: "(token: string) => Promise<{ message: string; device?: Device }>",
+              description: "Block a device with a token"
+            },
+            {
+              name: "authApi.getPreferences",
+              signature: "(customFetch?: typeof fetch) => Promise<UserPreferences>",
+              description: "Get user preferences"
+            },
+            {
+              name: "authApi.updatePreferences",
+              signature: "(data: Partial<UserPreferences>) => Promise<void>",
+              description: "Update user preferences"
+            },
+            {
+              name: "authApi.getSSOAccounts",
+              signature: "(customFetch?: typeof fetch) => Promise<LinkedAccount[]>",
+              description: "Get SSO linked accounts"
+            },
+            {
+              name: "authApi.unlinkSSOAccount",
+              signature: "(provider: string, password?: string) => Promise<void>",
+              description: "Unlink an SSO account"
+            },
+            {
+              name: "authApi.linkSSOAccount",
+              signature: "(provider?: string) => Promise<void>",
+              description: "Link an SSO account (redirects to SSO provider)"
+            },
+            {
+              name: "authApi.getSecurityEvents",
+              signature: "(params?: { page?: number; limit?: number; type?: string }, customFetch?: typeof fetch) => Promise<{ events: SecurityEvent[]; pagination: Pagination }>",
+              description: "Get security event history"
+            },
+            {
+              name: "authApi.getApiKey",
+              signature: "(keyId: string, customFetch?: typeof fetch) => Promise<ApiKey>",
+              description: "Get details for a specific API key"
+            },
+            {
+              name: "authApi.getMfaMethods",
+              signature: "() => Promise<MfaMethodsStatus>",
+              description: "Get available MFA methods and their status"
+            },
+            {
+              name: "authApi.setupMfaMethod",
+              signature: "(method: 'totp' | 'email') => Promise<MfaMethodSetupResponse>",
+              description: "Setup a specific MFA method"
+            },
+            {
+              name: "authApi.verifyMfaMethod",
+              signature: "(method: 'totp' | 'email', code: string) => Promise<{ success: boolean; message: string; backupCodes?: string[] }>",
+              description: "Verify and enable a specific MFA method"
+            },
+            {
+              name: "authApi.disableMfaMethod",
+              signature: "(method: 'totp' | 'email', options: { password?: string; code?: string }) => Promise<void>",
+              description: "Disable a specific MFA method"
+            },
+            {
+              name: "authApi.sendMfaEmailCode",
+              signature: "() => Promise<{ success: boolean; email: string; message: string }>",
+              description: "Send MFA verification code via email"
+            },
+            {
+              name: "authApi.getSecurityOverview",
+              signature: "(customFetch?: typeof fetch) => Promise<SecurityOverview>",
+              description: "Get security overview with recent events and device counts"
+            },
+            {
+              name: "authApi.getSecuritySummary",
+              signature: "(customFetch?: typeof fetch) => Promise<SecuritySummary>",
+              description: "Get security summary with score and recommendations"
+            },
+            {
+              name: "authApi.getTrustedDevices",
+              signature: "(customFetch?: typeof fetch) => Promise<{ devices: Device[]; total: number }>",
+              description: "Get list of trusted devices"
+            }
+          ]
+        },
+        service: {
+          description: "Auth service with automatic store updates",
+          functions: [
+            {
+              name: "AuthService",
+              signature: "class",
+              description: "Service class that wraps auth API and updates stores automatically",
+              example: "import { authService } from '@classic-homes/auth/core';\n\n// Use the singleton instance\nconst response = await authService.login({\n  username: 'user@example.com',\n  password: 'password'\n});\n\n// Or create your own instance\nconst service = new AuthService({ storeUpdate: myStoreUpdateFn });"
+            },
+            {
+              name: "authService",
+              signature: "AuthService",
+              description: "Singleton instance of AuthService"
+            }
+          ],
+          types: [
+            {
+              name: "LoginOptions",
+              description: "Options for login operation",
+              properties: [
+                { name: "updateStore", type: "boolean", required: false, description: "Whether to update auth store" }
+              ]
+            },
+            {
+              name: "MFAVerifyOptions",
+              description: "Options for MFA verification",
+              properties: [
+                { name: "updateStore", type: "boolean", required: false, description: "Whether to update auth store" }
+              ]
+            }
+          ]
+        },
+        guards: {
+          description: "Type guards for auth responses",
+          functions: [
+            {
+              name: "isMfaChallengeResponse",
+              signature: "(response: LoginResponse) => boolean",
+              description: "Check if a login response requires MFA verification",
+              example: "import { authApi, isMfaChallengeResponse } from '@classic-homes/auth/core';\n\nconst response = await authApi.login(credentials);\n\nif (isMfaChallengeResponse(response)) {\n  // Redirect to MFA verification\n  const mfaToken = getMfaToken(response);\n} else {\n  // Login complete\n}"
+            },
+            {
+              name: "isLoginSuccessResponse",
+              signature: "(response: LoginResponse) => boolean",
+              description: "Check if a login response is a success (not MFA challenge)"
+            },
+            {
+              name: "getMfaToken",
+              signature: "(response: LoginResponse) => string | undefined",
+              description: "Extract MFA token from a login response"
+            },
+            {
+              name: "getAvailableMethods",
+              signature: "(response: LoginResponse) => string[]",
+              description: "Get available MFA methods from a login response"
+            }
+          ]
+        },
+        jwt: {
+          description: "JWT token utilities",
+          functions: [
+            {
+              name: "decodeJWT",
+              signature: "(token: string) => JWTPayload | null",
+              description: "Decode a JWT token without verification",
+              example: "import { decodeJWT, isTokenExpired } from '@classic-homes/auth/core';\n\nconst payload = decodeJWT(accessToken);\nif (payload && !isTokenExpired(accessToken)) {\n  console.log('User ID:', payload.sub);\n  console.log('Expires:', new Date(payload.exp * 1000));\n}"
+            },
+            {
+              name: "isTokenExpired",
+              signature: "(token: string) => boolean",
+              description: "Check if a JWT token is expired"
+            },
+            {
+              name: "getTokenRemainingTime",
+              signature: "(token: string) => number",
+              description: "Get remaining time in milliseconds until token expires"
+            },
+            {
+              name: "getTokenExpiration",
+              signature: "(token: string) => Date | null",
+              description: "Get the expiration date of a token"
+            },
+            {
+              name: "extractClaims",
+              signature: "<T extends object>(token: string) => T | null",
+              description: "Extract custom claims from a JWT token"
+            }
+          ],
+          types: [
+            {
+              name: "JWTPayload",
+              description: "Standard JWT payload structure",
+              properties: [
+                { name: "sub", type: "string", required: true, description: "Subject (user ID)" },
+                { name: "exp", type: "number", required: true, description: "Expiration timestamp" },
+                { name: "iat", type: "number", required: true, description: "Issued at timestamp" },
+                { name: "iss", type: "string", required: false, description: "Issuer" },
+                { name: "aud", type: "string | string[]", required: false, description: "Audience" }
+              ]
+            }
+          ]
+        }
+      },
+      types: [
+        {
+          name: "User",
+          description: "User information",
+          properties: [
+            { name: "id", type: "string", required: true, description: "User ID" },
+            { name: "username", type: "string", required: true, description: "Username" },
+            { name: "email", type: "string", required: true, description: "Email address" },
+            { name: "firstName", type: "string", required: false, description: "First name" },
+            { name: "lastName", type: "string", required: false, description: "Last name" },
+            { name: "phone", type: "string", required: false, description: "Phone number" },
+            { name: "role", type: "string", required: true, description: "Primary role" },
+            { name: "roles", type: "string[]", required: false, description: "All assigned roles" },
+            { name: "permissions", type: "string[]", required: true, description: "User permissions" },
+            { name: "isActive", type: "boolean", required: true, description: "Whether user is active" },
+            { name: "emailVerified", type: "boolean", required: true, description: "Whether email is verified" },
+            { name: "authMethod", type: "'password' | 'oauth' | 'both'", required: false, description: "Authentication method" },
+            { name: "ssoProfileUrl", type: "string", required: false, description: "SSO profile URL" },
+            { name: "createdAt", type: "string", required: true, description: "Creation timestamp" },
+            { name: "lastLoginAt", type: "string", required: false, description: "Last login timestamp" }
+          ]
+        },
+        {
+          name: "AuthState",
+          description: "Current authentication state",
+          properties: [
+            { name: "accessToken", type: "string | null", required: true, description: "Current access token" },
+            { name: "refreshToken", type: "string | null", required: true, description: "Current refresh token" },
+            { name: "user", type: "User | null", required: true, description: "Current user" },
+            { name: "isAuthenticated", type: "boolean", required: true, description: "Whether user is authenticated" }
+          ]
+        },
+        {
+          name: "LoginCredentials",
+          description: "Login credentials",
+          properties: [
+            { name: "username", type: "string", required: true, description: "Username or email" },
+            { name: "password", type: "string", required: true, description: "Password" }
+          ]
+        },
+        {
+          name: "LoginResponse",
+          description: "Response from login API",
+          properties: [
+            { name: "accessToken", type: "string", required: true, description: "Access token" },
+            { name: "refreshToken", type: "string", required: true, description: "Refresh token" },
+            { name: "sessionToken", type: "string", required: false, description: "Session token" },
+            { name: "user", type: "User", required: true, description: "User info" },
+            { name: "expiresIn", type: "number", required: true, description: "Token expiration in seconds" },
+            { name: "requiresMFA", type: "boolean", required: false, description: "Whether MFA is required" },
+            { name: "mfaToken", type: "string", required: false, description: "MFA challenge token" },
+            { name: "availableMethods", type: "string[]", required: false, description: "Available MFA methods" }
+          ]
+        },
+        {
+          name: "Session",
+          description: "User session information",
+          properties: [
+            { name: "id", type: "string", required: true, description: "Session ID" },
+            { name: "deviceName", type: "string", required: true, description: "Device name" },
+            { name: "browser", type: "string", required: true, description: "Browser info" },
+            { name: "location", type: "string", required: true, description: "Location" },
+            { name: "ipAddress", type: "string", required: true, description: "IP address" },
+            { name: "lastActivity", type: "string", required: true, description: "Last activity timestamp" },
+            { name: "isCurrent", type: "boolean", required: true, description: "Whether this is the current session" },
+            { name: "isTrusted", type: "boolean", required: true, description: "Whether device is trusted" },
+            { name: "createdAt", type: "string", required: true, description: "Session creation time" },
+            { name: "expiresAt", type: "string", required: true, description: "Session expiration time" }
+          ]
+        },
+        {
+          name: "Device",
+          description: "Device information",
+          properties: [
+            { name: "id", type: "string", required: true, description: "Device ID" },
+            { name: "deviceFingerprint", type: "string", required: true, description: "Device fingerprint" },
+            { name: "deviceName", type: "string", required: true, description: "Device name" },
+            { name: "trusted", type: "boolean", required: true, description: "Whether device is trusted" },
+            { name: "status", type: "'active' | 'revoked'", required: true, description: "Device status" },
+            { name: "lastSeen", type: "string | null", required: false, description: "Last seen timestamp" },
+            { name: "createdAt", type: "string", required: true, description: "Creation timestamp" }
+          ]
+        },
+        {
+          name: "ApiKey",
+          description: "API key information",
+          properties: [
+            { name: "id", type: "string", required: true, description: "API key ID" },
+            { name: "name", type: "string", required: true, description: "Key name" },
+            { name: "description", type: "string", required: false, description: "Key description" },
+            { name: "keyPreview", type: "string", required: true, description: "Partial key preview" },
+            { name: "permissions", type: "string[]", required: true, description: "Key permissions" },
+            { name: "isActive", type: "boolean", required: true, description: "Whether key is active" },
+            { name: "expiresAt", type: "string | null", required: false, description: "Expiration date" },
+            { name: "lastUsedAt", type: "string | null", required: false, description: "Last used timestamp" },
+            { name: "createdAt", type: "string", required: true, description: "Creation timestamp" }
+          ]
+        },
+        {
+          name: "MFASetupResponse",
+          description: "MFA setup response with QR code and backup codes",
+          properties: [
+            { name: "qrCodeUrl", type: "string", required: true, description: "QR code image URL" },
+            { name: "manualEntryKey", type: "string", required: true, description: "Manual entry key for authenticator apps" },
+            { name: "backupCodes", type: "string[]", required: true, description: "One-time backup codes" },
+            { name: "instructions", type: "object", required: true, description: "Setup instructions" }
+          ]
+        },
+        {
+          name: "MFAStatus",
+          description: "MFA status for user",
+          properties: [
+            { name: "enabled", type: "boolean", required: true, description: "Whether MFA is enabled" },
+            { name: "setupRequired", type: "boolean", required: true, description: "Whether MFA setup is required" }
+          ]
+        },
+        {
+          name: "MfaMethodsStatus",
+          description: "Available MFA methods and their status",
+          properties: [
+            { name: "methods", type: "{ totp: { enabled: boolean; configured: boolean }; email: { enabled: boolean; configured: boolean } }", required: true, description: "Status of each MFA method" },
+            { name: "mfaRequired", type: "boolean", required: true, description: "Whether MFA is required overall" }
+          ]
+        },
+        {
+          name: "MfaMethodSetupResponse",
+          description: "Response from MFA method setup",
+          properties: [
+            { name: "method", type: "'totp' | 'email'", required: true, description: "MFA method being set up" },
+            { name: "qrCodeUrl", type: "string", required: false, description: "QR code URL for TOTP" },
+            { name: "manualEntryKey", type: "string", required: false, description: "Manual entry key for TOTP" },
+            { name: "backupCodes", type: "string[]", required: false, description: "Backup codes for TOTP" },
+            { name: "email", type: "string", required: false, description: "Masked email for email method" },
+            { name: "message", type: "string", required: false, description: "Status message" }
+          ]
+        },
+        {
+          name: "SecurityOverview",
+          description: "Security overview for the user",
+          properties: [
+            { name: "overview", type: "{ trustedDevicesCount: number; recentEventsCount: number }", required: true, description: "Security counts" },
+            { name: "recentEvents", type: "SecurityEvent[]", required: true, description: "Recent security events" },
+            { name: "devicesEndpoint", type: "string", required: true, description: "Endpoint for device management" }
+          ]
+        },
+        {
+          name: "SecuritySummary",
+          description: "Security summary with score and recommendations",
+          properties: [
+            { name: "mfa", type: "{ enabled: boolean; recommended: boolean }", required: true, description: "MFA status" },
+            { name: "devices", type: "{ total: number; trusted: number; untrusted: number }", required: true, description: "Device counts" },
+            { name: "recentActivity", type: "{ period: string; events: Record<string, number>; totalEvents: number }", required: true, description: "Recent activity summary" },
+            { name: "securityScore", type: "{ score: number; level: string; recommendations: string[] }", required: true, description: "Security score and recommendations" }
+          ]
+        },
+        {
+          name: "MFAChallengeData",
+          description: "Data for MFA challenge verification",
+          properties: [
+            { name: "mfaToken", type: "string", required: true, description: "MFA challenge token from login" },
+            { name: "code", type: "string", required: true, description: "MFA code from authenticator" },
+            { name: "method", type: "'totp' | 'email' | 'backup'", required: false, description: "MFA method" },
+            { name: "trustDevice", type: "boolean", required: false, description: "Whether to trust this device" }
+          ]
+        },
+        {
+          name: "UserPreferences",
+          description: "User preference settings",
+          properties: [
+            { name: "emailNotifications", type: "boolean", required: true, description: "Email notifications enabled" },
+            { name: "securityAlerts", type: "boolean", required: true, description: "Security alerts enabled" },
+            { name: "loginNotifications", type: "boolean", required: true, description: "Login notifications enabled" },
+            { name: "suspiciousActivityAlerts", type: "boolean", required: true, description: "Suspicious activity alerts" },
+            { name: "passwordChangeNotifications", type: "boolean", required: true, description: "Password change notifications" },
+            { name: "mfaChangeNotifications", type: "boolean", required: true, description: "MFA change notifications" },
+            { name: "accountUpdates", type: "boolean", required: true, description: "Account updates enabled" },
+            { name: "systemMaintenance", type: "boolean", required: true, description: "System maintenance notifications" },
+            { name: "featureAnnouncements", type: "boolean", required: true, description: "Feature announcements" },
+            { name: "newsAndUpdates", type: "boolean", required: true, description: "News and updates" },
+            { name: "apiKeyExpiration", type: "boolean", required: true, description: "API key expiration alerts" },
+            { name: "apiUsageAlerts", type: "boolean", required: true, description: "API usage alerts" },
+            { name: "rateLimit", type: "boolean", required: true, description: "Rate limit notifications" },
+            { name: "dataExportReady", type: "boolean", required: true, description: "Data export ready notifications" },
+            { name: "reportGeneration", type: "boolean", required: true, description: "Report generation notifications" },
+            { name: "theme", type: "'light' | 'dark' | 'system'", required: true, description: "UI theme preference" },
+            { name: "language", type: "string", required: true, description: "Language preference" },
+            { name: "timezone", type: "string", required: true, description: "Timezone preference" },
+            { name: "dateFormat", type: "string", required: true, description: "Date format preference" },
+            { name: "timeFormat", type: "'12h' | '24h'", required: true, description: "Time format preference" },
+            { name: "advancedSettings", type: "Record<string, any> | null", required: false, description: "Advanced settings" }
+          ]
+        },
+        {
+          name: "LinkedAccount",
+          description: "SSO linked account",
+          properties: [
+            { name: "id", type: "string", required: true, description: "Account ID" },
+            { name: "provider", type: "string", required: true, description: "SSO provider name" },
+            { name: "providerAccountId", type: "string", required: true, description: "Provider account ID" },
+            { name: "providerEmail", type: "string | null", required: false, description: "Provider email" },
+            { name: "isPrimary", type: "boolean", required: true, description: "Whether this is primary account" },
+            { name: "isVerified", type: "boolean", required: true, description: "Whether account is verified" },
+            { name: "createdAt", type: "string", required: true, description: "Link creation time" }
+          ]
+        },
+        {
+          name: "SecurityEvent",
+          description: "Security event log entry",
+          properties: [
+            { name: "id", type: "string", required: true, description: "Event ID" },
+            { name: "eventType", type: "string", required: true, description: "Event type" },
+            { name: "description", type: "string", required: true, description: "Event description" },
+            { name: "severity", type: "'low' | 'medium' | 'high'", required: true, description: "Event severity" },
+            { name: "ipAddress", type: "string", required: false, description: "Source IP address" },
+            { name: "createdAt", type: "string", required: true, description: "Event timestamp" }
+          ]
+        }
+      ]
+    },
+    svelte: {
+      importPath: "@classic-homes/auth/svelte",
+      description: "Svelte-specific bindings for authentication. Includes reactive stores and route guards.",
+      modules: {
+        stores: {
+          description: "Reactive Svelte stores for auth state",
+          functions: [
+            {
+              name: "authStore",
+              signature: "Writable<AuthState>",
+              description: "Main auth store containing current auth state",
+              example: "import { authStore } from '@classic-homes/auth/svelte';\n\n// Subscribe to auth state changes\nauthStore.subscribe(state => {\n  console.log('Authenticated:', state.isAuthenticated);\n  console.log('User:', state.user);\n});\n\n// In Svelte component\n<script>\n  import { authStore } from '@classic-homes/auth/svelte';\n</script>\n\n{#if $authStore.isAuthenticated}\n  <p>Welcome, {$authStore.user.firstName}!</p>\n{/if}"
+            },
+            {
+              name: "isAuthenticated",
+              signature: "Readable<boolean>",
+              description: "Derived store for authentication status",
+              example: "import { isAuthenticated } from '@classic-homes/auth/svelte';\n\n// In Svelte component\n{#if $isAuthenticated}\n  <Dashboard />\n{:else}\n  <LoginForm />\n{/if}"
+            },
+            {
+              name: "currentUser",
+              signature: "Readable<User | null>",
+              description: "Derived store for current user"
+            },
+            {
+              name: "authActions",
+              signature: "{ login, logout, refreshToken, updateUser, clearAuth }",
+              description: "Auth action functions that update the store",
+              example: "import { authActions } from '@classic-homes/auth/svelte';\n\nasync function handleLogin(credentials) {\n  const response = await authActions.login(credentials);\n  if (response.requiresMFA) {\n    // Handle MFA\n  }\n}\n\nfunction handleLogout() {\n  await authActions.logout();\n}"
+            }
+          ]
+        },
+        guards: {
+          description: "SvelteKit route guards for protected pages",
+          functions: [
+            {
+              name: "checkAuth",
+              signature: "(fetch: typeof fetch) => Promise<AuthGuardResult>",
+              description: "Check authentication status",
+              example: "import { checkAuth } from '@classic-homes/auth/svelte';\n\nexport const load = async ({ fetch }) => {\n  const auth = await checkAuth(fetch);\n  return { user: auth.user };\n};"
+            },
+            {
+              name: "requireAuth",
+              signature: "(options?: AuthGuardOptions) => (event: LoadEvent) => Promise<AuthGuardResult>",
+              description: "Guard that requires authentication",
+              example: "import { requireAuth } from '@classic-homes/auth/svelte';\n\nexport const load = requireAuth({\n  redirectTo: '/login'\n});"
+            },
+            {
+              name: "requireRole",
+              signature: "(roles: string | string[], options?: AuthGuardOptions) => (event: LoadEvent) => Promise<AuthGuardResult>",
+              description: "Guard that requires specific role(s)",
+              example: "import { requireRole } from '@classic-homes/auth/svelte';\n\n// Single role\nexport const load = requireRole('admin');\n\n// Multiple roles (any match)\nexport const load = requireRole(['admin', 'manager']);"
+            },
+            {
+              name: "requirePermission",
+              signature: "(permissions: string | string[], options?: AuthGuardOptions) => (event: LoadEvent) => Promise<AuthGuardResult>",
+              description: "Guard that requires specific permission(s)",
+              example: "import { requirePermission } from '@classic-homes/auth/svelte';\n\nexport const load = requirePermission('users:write');"
+            },
+            {
+              name: "protectedLoad",
+              signature: "<T>(loadFn: (event: LoadEvent, auth: AuthGuardResult) => Promise<T>, options?: AuthGuardOptions) => (event: LoadEvent) => Promise<T>",
+              description: "Wrapper for load functions that require auth",
+              example: "import { protectedLoad } from '@classic-homes/auth/svelte';\n\nexport const load = protectedLoad(async (event, auth) => {\n  // Auth is guaranteed to be valid here\n  const data = await fetchUserData(event.fetch, auth.user.id);\n  return { user: auth.user, data };\n});"
+            },
+            {
+              name: "createAuthGuard",
+              signature: "(checkFn: (auth: AuthGuardResult) => boolean, options?: AuthGuardOptions) => (event: LoadEvent) => Promise<AuthGuardResult>",
+              description: "Create a custom auth guard with your own check function"
+            }
+          ],
+          types: [
+            {
+              name: "AuthGuardOptions",
+              description: "Options for auth guards",
+              properties: [
+                { name: "redirectTo", type: "string", required: false, description: "URL to redirect to if auth fails (default: '/login')" },
+                { name: "returnTo", type: "boolean", required: false, description: "Whether to include return URL in redirect" }
+              ]
+            },
+            {
+              name: "AuthGuardResult",
+              description: "Result from auth guard check",
+              properties: [
+                { name: "authenticated", type: "boolean", required: true, description: "Whether user is authenticated" },
+                { name: "user", type: "User | null", required: true, description: "Current user if authenticated" }
+              ]
+            }
+          ]
+        }
+      }
+    },
+    testing: {
+      importPath: "@classic-homes/auth/testing",
+      description: "Test utilities for the auth package. Provides mocks, fixtures, and helpers for testing authentication flows.",
+      modules: {
+        fixtures: {
+          description: "Pre-built test fixtures for users, tokens, and responses",
+          functions: [
+            {
+              name: "mockUser",
+              signature: "User",
+              description: "Standard test user fixture"
+            },
+            {
+              name: "mockAdminUser",
+              signature: "User",
+              description: "Admin user fixture with elevated permissions"
+            },
+            {
+              name: "mockSSOUser",
+              signature: "User",
+              description: "SSO-authenticated user fixture"
+            },
+            {
+              name: "mockMFAUser",
+              signature: "User",
+              description: "User with MFA enabled"
+            },
+            {
+              name: "mockUnverifiedUser",
+              signature: "User",
+              description: "User with unverified email"
+            },
+            {
+              name: "mockInactiveUser",
+              signature: "User",
+              description: "Inactive/disabled user"
+            },
+            {
+              name: "createMockUser",
+              signature: "(overrides?: Partial<User>) => User",
+              description: "Create a custom mock user"
+            },
+            {
+              name: "createMockUserWithRoles",
+              signature: "(roles: string[], permissions?: string[]) => User",
+              description: "Create a user with specific roles"
+            },
+            {
+              name: "mockAccessToken",
+              signature: "string",
+              description: "Valid mock access token"
+            },
+            {
+              name: "mockRefreshToken",
+              signature: "string",
+              description: "Valid mock refresh token"
+            },
+            {
+              name: "mockExpiredToken",
+              signature: "string",
+              description: "Expired token for testing"
+            },
+            {
+              name: "mockMFAToken",
+              signature: "string",
+              description: "MFA challenge token"
+            },
+            {
+              name: "createMockJWT",
+              signature: "(payload?: JWTPayloadOptions) => string",
+              description: "Create a custom mock JWT"
+            },
+            {
+              name: "mockLoginSuccess",
+              signature: "LoginResponse",
+              description: "Successful login response"
+            },
+            {
+              name: "mockMFARequired",
+              signature: "LoginResponse",
+              description: "Login response requiring MFA"
+            },
+            {
+              name: "mockMFASetup",
+              signature: "MFASetupResponse",
+              description: "MFA setup response with QR code"
+            },
+            {
+              name: "mockSessions",
+              signature: "Session[]",
+              description: "Array of mock sessions"
+            },
+            {
+              name: "mockDevices",
+              signature: "Device[]",
+              description: "Array of mock devices"
+            },
+            {
+              name: "mockApiKeys",
+              signature: "ApiKey[]",
+              description: "Array of mock API keys"
+            },
+            {
+              name: "mockSecurityEvents",
+              signature: "SecurityEvent[]",
+              description: "Array of mock security events"
+            },
+            {
+              name: "mockUserPreferences",
+              signature: "UserPreferences",
+              description: "Mock user preferences"
+            }
+          ]
+        },
+        mocks: {
+          description: "Mock implementations for testing",
+          functions: [
+            {
+              name: "MockStorageAdapter",
+              signature: "class",
+              description: "Mock storage adapter with call tracking",
+              example: "import { MockStorageAdapter, createMockStorage } from '@classic-homes/auth/testing';\n\nconst storage = createMockStorage();\n\n// Use in auth init\ninitAuth({ baseUrl: 'https://api.test', storage });\n\n// Assert calls\nexpect(storage.getCalls('setItem')).toHaveLength(2);"
+            },
+            {
+              name: "createMockStorage",
+              signature: "(options?: MockStorageOptions) => MockStorageAdapter",
+              description: "Create a mock storage adapter"
+            },
+            {
+              name: "createMockStorageWithAuth",
+              signature: "(tokens?: { accessToken?: string; refreshToken?: string }) => MockStorageAdapter",
+              description: "Create storage pre-populated with auth tokens"
+            },
+            {
+              name: "MockFetchInstance",
+              signature: "class",
+              description: "Mock fetch implementation with route handling",
+              example: "import { createMockFetch, mockLoginSuccess } from '@classic-homes/auth/testing';\n\nconst mockFetch = createMockFetch();\nmockFetch.addRoute('POST', '/auth/login', { data: mockLoginSuccess });\n\n// Use in auth init\ninitAuth({ baseUrl: 'https://api.test', fetch: mockFetch.fetch });\n\n// Assert calls\nmockFetch.assertCalled('/auth/login');\nmockFetch.assertCalledWith('/auth/login', { body: { username: 'test' } });"
+            },
+            {
+              name: "createMockFetch",
+              signature: "(options?: MockFetchOptions) => MockFetchInstance",
+              description: "Create a mock fetch instance"
+            },
+            {
+              name: "createMockFetchWithRoutes",
+              signature: "(routes: MockRoute[]) => MockFetchInstance",
+              description: "Create mock fetch with pre-configured routes"
+            },
+            {
+              name: "MockAuthStore",
+              signature: "class",
+              description: "Mock auth store for Svelte testing"
+            },
+            {
+              name: "createMockAuthStore",
+              signature: "(options?: MockAuthStoreOptions) => MockAuthStore",
+              description: "Create a mock auth store"
+            },
+            {
+              name: "createAuthenticatedMockStore",
+              signature: "(user?: User) => MockAuthStore",
+              description: "Create a mock store in authenticated state"
+            }
+          ]
+        },
+        helpers: {
+          description: "Test setup and assertion helpers",
+          functions: [
+            {
+              name: "setupTestAuth",
+              signature: "(options?: SetupTestAuthOptions) => TestAuthContext",
+              description: "Complete test setup with all mocks configured",
+              example: "import { describe, it, beforeEach, afterEach } from 'vitest';\nimport { setupTestAuth, mockUser, assertAuthenticated } from '@classic-homes/auth/testing';\nimport { authService } from '@classic-homes/auth/core';\n\ndescribe('Auth', () => {\n  let ctx: TestAuthContext;\n\n  beforeEach(() => {\n    ctx = setupTestAuth();\n  });\n\n  afterEach(() => ctx.cleanup());\n\n  it('handles login', async () => {\n    const response = await authService.login({\n      username: 'test@example.com',\n      password: 'password'\n    });\n\n    assertAuthenticated(ctx.mockStore);\n    ctx.mockFetch.assertCalled('/auth/login');\n  });\n});"
+            },
+            {
+              name: "quickSetupAuth",
+              signature: "() => { cleanup: () => void }",
+              description: "Minimal setup for quick tests"
+            },
+            {
+              name: "withTestAuth",
+              signature: "(testFn: (ctx: TestAuthContext) => Promise<void>) => () => Promise<void>",
+              description: "Wrapper that handles setup and cleanup"
+            },
+            {
+              name: "authScenarios",
+              signature: "{ authenticated, unauthenticated, mfaRequired, tokenExpired, ... }",
+              description: "Pre-configured test scenarios"
+            },
+            {
+              name: "applyScenario",
+              signature: "(ctx: TestAuthContext, scenario: AuthScenario) => void",
+              description: "Apply a test scenario to the context"
+            },
+            {
+              name: "configureMFAFlow",
+              signature: "(mockFetch: MockFetchInstance) => void",
+              description: "Configure mock fetch for MFA flow testing"
+            },
+            {
+              name: "configureTokenRefresh",
+              signature: "(mockFetch: MockFetchInstance) => void",
+              description: "Configure mock fetch for token refresh testing"
+            },
+            {
+              name: "configureSSOLogout",
+              signature: "(mockFetch: MockFetchInstance) => void",
+              description: "Configure mock fetch for SSO logout flow"
+            },
+            {
+              name: "assertAuthenticated",
+              signature: "(store: MockAuthStore) => void",
+              description: "Assert that store is in authenticated state"
+            },
+            {
+              name: "assertUnauthenticated",
+              signature: "(store: MockAuthStore) => void",
+              description: "Assert that store is in unauthenticated state"
+            },
+            {
+              name: "assertHasPermissions",
+              signature: "(store: MockAuthStore, permissions: string[]) => void",
+              description: "Assert user has specific permissions"
+            },
+            {
+              name: "assertHasRoles",
+              signature: "(store: MockAuthStore, roles: string[]) => void",
+              description: "Assert user has specific roles"
+            },
+            {
+              name: "assertTokenValid",
+              signature: "(token: string) => void",
+              description: "Assert token is valid and not expired"
+            },
+            {
+              name: "assertTokenExpired",
+              signature: "(token: string) => void",
+              description: "Assert token is expired"
+            },
+            {
+              name: "assertRequiresMFA",
+              signature: "(response: LoginResponse) => void",
+              description: "Assert login response requires MFA"
+            },
+            {
+              name: "assertApiCalled",
+              signature: "(mockFetch: MockFetchInstance, endpoint: string, options?: AssertApiCalledOptions) => void",
+              description: "Assert API endpoint was called"
+            }
+          ],
+          types: [
+            {
+              name: "TestAuthContext",
+              description: "Context returned from setupTestAuth",
+              properties: [
+                { name: "mockFetch", type: "MockFetchInstance", required: true, description: "Mock fetch instance" },
+                { name: "mockStorage", type: "MockStorageAdapter", required: true, description: "Mock storage adapter" },
+                { name: "mockStore", type: "MockAuthStore", required: true, description: "Mock auth store" },
+                { name: "cleanup", type: "() => void", required: true, description: "Cleanup function" }
+              ]
+            },
+            {
+              name: "SetupTestAuthOptions",
+              description: "Options for setupTestAuth",
+              properties: [
+                { name: "authenticated", type: "boolean", required: false, description: "Start in authenticated state" },
+                { name: "user", type: "User", required: false, description: "User for authenticated state" },
+                { name: "tokens", type: "object", required: false, description: "Tokens for authenticated state" }
+              ]
+            }
+          ]
+        }
+      }
+    }
+  }
+};
+
+// src/resources/auth.ts
+var catalog2 = auth_catalog_default;
+function registerAuthResources(server) {
+  server.resource("Auth Package", "auth://all", async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(catalog2, null, 2)
       }
     ]
   }));
-  server.resource("Layout Patterns", "patterns://layouts", async (uri) => ({
+  server.resource("Auth Core", "auth://core", async (uri) => ({
     contents: [
       {
         uri: uri.href,
         mimeType: "application/json",
-        text: JSON.stringify(patterns.layouts, null, 2)
+        text: JSON.stringify(
+          {
+            importPath: catalog2.subpackages.core.importPath,
+            description: catalog2.subpackages.core.description,
+            modules: catalog2.subpackages.core.modules,
+            types: catalog2.subpackages.core.types
+          },
+          null,
+          2
+        )
       }
     ]
   }));
-  server.resource("Form Patterns", "patterns://forms", async (uri) => ({
+  server.resource("Auth Svelte", "auth://svelte", async (uri) => ({
     contents: [
       {
         uri: uri.href,
         mimeType: "application/json",
-        text: JSON.stringify(patterns.forms, null, 2)
+        text: JSON.stringify(
+          {
+            importPath: catalog2.subpackages.svelte.importPath,
+            description: catalog2.subpackages.svelte.description,
+            modules: catalog2.subpackages.svelte.modules
+          },
+          null,
+          2
+        )
+      }
+    ]
+  }));
+  server.resource("Auth Testing", "auth://testing", async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(
+          {
+            importPath: catalog2.subpackages.testing.importPath,
+            description: catalog2.subpackages.testing.description,
+            modules: catalog2.subpackages.testing.modules
+          },
+          null,
+          2
+        )
+      }
+    ]
+  }));
+  server.resource("Auth Types", "auth://types", async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(
+          {
+            description: "TypeScript types exported from @classic-homes/auth/core",
+            types: catalog2.subpackages.core.types
+          },
+          null,
+          2
+        )
+      }
+    ]
+  }));
+  server.resource("Auth API", "auth://api", async (uri) => ({
+    contents: [
+      {
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(
+          {
+            description: "Auth API client methods from @classic-homes/auth/core",
+            api: catalog2.subpackages.core.modules.api
+          },
+          null,
+          2
+        )
       }
     ]
   }));
   server.resource(
-    "Pattern Details",
-    new ResourceTemplate2("patterns://{id}", { list: void 0 }),
+    "Auth Module",
+    new ResourceTemplate3("auth://core/{module}", { list: void 0 }),
     async (uri, params) => {
-      const id = params.id;
-      const layout = patterns.layouts.find((l) => l.id === id);
-      const form = patterns.forms.find((f) => f.id === id);
-      const pattern = layout || form;
-      if (!pattern) {
+      const moduleName = params.module;
+      const modules = catalog2.subpackages.core.modules;
+      const module = modules[moduleName];
+      if (!module) {
+        const availableModules = Object.keys(modules);
         return {
           contents: [
             {
               uri: uri.href,
               mimeType: "application/json",
-              text: JSON.stringify({ error: `Pattern "${id}" not found` })
+              text: JSON.stringify({
+                error: `Module "${moduleName}" not found`,
+                availableModules
+              })
             }
           ]
         };
@@ -11138,193 +12911,44 @@ function registerLayoutResources(server) {
           {
             uri: uri.href,
             mimeType: "application/json",
-            text: JSON.stringify(pattern, null, 2)
+            text: JSON.stringify(module, null, 2)
           }
         ]
       };
     }
   );
-}
-
-// src/data/schema-catalog.json
-var schema_catalog_default = {
-  auth: [
-    {
-      name: "emailSchema",
-      description: "Email validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "passwordSchema",
-      description: "Strong password (8+ chars, mixed case, numbers, special)",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "loginPasswordSchema",
-      description: "Simpler password validation for login",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "usernameSchema",
-      description: "Username validation (3-30 chars, alphanumeric)",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "fullNameSchema",
-      description: "Full name validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "phoneSchema",
-      description: "Phone number validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "mfaCodeSchema",
-      description: "MFA code validation (6 digits)",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "loginSchema",
-      description: "Complete login form schema",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "registerSchema",
-      description: "Complete registration form schema",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "forgotPasswordSchema",
-      description: "Forgot password form schema",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "resetPasswordSchema",
-      description: "Reset password form schema",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "changePasswordSchema",
-      description: "Change password form schema",
-      importPath: "@classic-homes/theme-svelte"
-    }
-  ],
-  common: [
-    {
-      name: "nonEmptyString",
-      description: "Non-empty string validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "trimmedString",
-      description: "Trimmed string",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "urlSchema",
-      description: "URL validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "slugSchema",
-      description: "URL slug validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "positiveInt",
-      description: "Positive integer validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "nonNegativeInt",
-      description: "Non-negative integer",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "percentageSchema",
-      description: "Percentage (0-100)",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "priceSchema",
-      description: "Price validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "isoDateSchema",
-      description: "ISO date string validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "futureDateSchema",
-      description: "Future date validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "pastDateSchema",
-      description: "Past date validation",
-      importPath: "@classic-homes/theme-svelte"
-    }
-  ],
-  file: [
-    {
-      name: "maxFileSize",
-      description: "File size limit validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "allowedFileTypes",
-      description: "File type validation",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "imageFileSchema",
-      description: "Image file validation",
-      importPath: "@classic-homes/theme-svelte"
-    }
-  ],
-  api: [
-    {
-      name: "apiResponseSchema",
-      description: "Standard API response schema",
-      importPath: "@classic-homes/theme-svelte"
-    },
-    {
-      name: "paginatedResponseSchema",
-      description: "Paginated API response",
-      importPath: "@classic-homes/theme-svelte"
-    }
-  ]
-};
-
-// src/resources/schemas.ts
-var schemas = schema_catalog_default;
-function registerSchemaResources(server) {
-  server.resource("schemas://all", "schemas://all", async (uri) => ({
-    contents: [
-      {
-        uri: uri.href,
-        mimeType: "application/json",
-        text: JSON.stringify(schemas, null, 2)
-      }
-    ]
-  }));
-  server.resource("schemas://auth", "schemas://auth", async (uri) => ({
-    contents: [
-      {
-        uri: uri.href,
-        mimeType: "application/json",
-        text: JSON.stringify(schemas.auth, null, 2)
-      }
-    ]
-  }));
-  server.resource("schemas://common", "schemas://common", async (uri) => ({
+  server.resource("Auth Quick Reference", "auth://quick-reference", async (uri) => ({
     contents: [
       {
         uri: uri.href,
         mimeType: "application/json",
-        text: JSON.stringify(schemas.common, null, 2)
+        text: JSON.stringify(
+          {
+            description: "Quick reference for common auth operations",
+            initialization: {
+              code: "import { initAuth } from '@classic-homes/auth/core';\n\ninitAuth({ baseUrl: 'https://api.example.com' });",
+              description: "Initialize the auth system with your API base URL"
+            },
+            login: {
+              code: "import { authApi, isMfaChallengeResponse } from '@classic-homes/auth/core';\n\nconst response = await authApi.login({ username: 'user@example.com', password: 'password' });\nif (isMfaChallengeResponse(response)) {\n  // Handle MFA\n}",
+              description: "Login with username and password, handling MFA if required"
+            },
+            svelteStore: {
+              code: "import { isAuthenticated, currentUser, authActions } from '@classic-homes/auth/svelte';\n\n// In component\n{#if $isAuthenticated}\n  <p>Welcome, {$currentUser.firstName}!</p>\n{/if}",
+              description: "Use reactive Svelte stores for auth state"
+            },
+            routeProtection: {
+              code: "import { requireAuth, requireRole } from '@classic-homes/auth/svelte';\n\n// In +page.ts or +layout.ts\nexport const load = requireAuth();\n// or\nexport const load = requireRole('admin');",
+              description: "Protect SvelteKit routes with auth guards"
+            },
+            testing: {
+              code: "import { setupTestAuth, mockUser, assertAuthenticated } from '@classic-homes/auth/testing';\n\nconst ctx = setupTestAuth();\n// Run tests\nctx.cleanup();",
+              description: "Set up mocks for testing auth flows"
+            }
+          },
+          null,
+          2
+        )
       }
     ]
   }));
@@ -11336,11 +12960,12 @@ function registerResources(server) {
   registerTokenResources(server);
   registerLayoutResources(server);
   registerSchemaResources(server);
+  registerAuthResources(server);
 }
 
 // src/tools/searchComponents.ts
 import { z } from "zod";
-var catalog2 = component_catalog_default;
+var catalog3 = component_catalog_default;
 var SearchComponentsSchema = z.object({
   query: z.string().describe("Search query (component name, description, or functionality)"),
   category: z.enum([
@@ -11366,7 +12991,7 @@ function registerSearchComponentsTool(server) {
       const queryLower = query.toLowerCase().trim();
       const isListAll = queryLower === "*" || queryLower === "all" || queryLower === "" || queryLower === "list" || queryLower === "list all";
       const queryWords = queryLower.split(/\s+/).filter((word) => word.length > 0);
-      const results = catalog2.components.filter((component) => {
+      const results = catalog3.components.filter((component) => {
         if (category && component.category !== category) {
           return false;
         }
@@ -11433,7 +13058,7 @@ function registerSearchComponentsTool(server) {
 
 // src/tools/getComponentProps.ts
 import { z as z2 } from "zod";
-var catalog3 = component_catalog_default;
+var catalog4 = component_catalog_default;
 var GetComponentPropsSchema = z2.object({
   componentName: z2.string().describe('Name of the component (e.g., "Button", "DashboardLayout")'),
   includeExamples: z2.boolean().default(true).describe("Whether to include usage examples")
@@ -11445,11 +13070,11 @@ function registerGetComponentPropsTool(server) {
     GetComponentPropsSchema.shape,
     async (params) => {
       const { componentName, includeExamples } = GetComponentPropsSchema.parse(params);
-      const component = catalog3.components.find(
+      const component = catalog4.components.find(
         (c) => c.name.toLowerCase() === componentName.toLowerCase()
       );
       if (!component) {
-        const suggestions = catalog3.components.filter((c) => c.name.toLowerCase().includes(componentName.toLowerCase().slice(0, 3))).slice(0, 5).map((c) => c.name);
+        const suggestions = catalog4.components.filter((c) => c.name.toLowerCase().includes(componentName.toLowerCase().slice(0, 3))).slice(0, 5).map((c) => c.name);
         return {
           content: [
             {
@@ -11508,7 +13133,19 @@ var SuggestPatternSchema = z3.object({
     // Form patterns
     "login-form",
     "registration-form",
-    "contact-form"
+    "contact-form",
+    // MFA and password form patterns
+    "mfa-verification-form",
+    "mfa-setup-form",
+    "profile-update-form",
+    "change-password-form",
+    "forgot-password-form",
+    "reset-password-form",
+    // Auth flow patterns
+    "login-with-mfa",
+    "sso-login",
+    "session-management",
+    "protected-route"
   ]).describe("The use case you need a pattern for"),
   requirements: z3.array(z3.string()).optional().describe("Additional requirements or constraints")
 });
@@ -11521,11 +13158,13 @@ function registerSuggestPatternTool(server) {
       const { useCase, requirements } = SuggestPatternSchema.parse(params);
       const layout = patterns2.layouts.find((l) => l.id === useCase || l.useCase === useCase);
       const form = patterns2.forms.find((f) => f.id === useCase);
-      const pattern = layout || form;
+      const auth = patterns2.auth?.find((a) => a.id === useCase);
+      const pattern = layout || form || auth;
       if (!pattern) {
         const availablePatterns = [
           ...patterns2.layouts.map((l) => ({ id: l.id, type: "layout", name: l.name })),
-          ...patterns2.forms.map((f) => ({ id: f.id, type: "form", name: f.name }))
+          ...patterns2.forms.map((f) => ({ id: f.id, type: "form", name: f.name })),
+          ...patterns2.auth?.map((a) => ({ id: a.id, type: "auth", name: a.name })) || []
         ];
         return {
           content: [
@@ -11571,7 +13210,7 @@ function registerSuggestPatternTool(server) {
 
 // src/tools/validateUsage.ts
 import { z as z4 } from "zod";
-var catalog4 = component_catalog_default;
+var catalog5 = component_catalog_default;
 var ValidateUsageSchema = z4.object({
   componentName: z4.string().describe("Name of the component being used"),
   props: z4.record(z4.unknown()).describe("Props being passed to the component"),
@@ -11584,7 +13223,7 @@ function registerValidateUsageTool(server) {
     ValidateUsageSchema.shape,
     async (params) => {
       const { componentName, props, context } = ValidateUsageSchema.parse(params);
-      const component = catalog4.components.find(
+      const component = catalog5.components.find(
         (c) => c.name.toLowerCase() === componentName.toLowerCase()
       );
       if (!component) {
@@ -11883,7 +13522,7 @@ Example for ${pageType}Layout:
 
 // src/prompts/componentUsage.ts
 import { z as z7 } from "zod";
-var catalog5 = component_catalog_default;
+var catalog6 = component_catalog_default;
 var ComponentUsageSchema = z7.object({
   componentName: z7.string().describe("Name of the component (e.g., Button, Card, Select)"),
   variant: z7.string().optional().describe("Desired variant (optional)"),
@@ -11899,7 +13538,7 @@ function registerComponentUsagePrompt(server) {
       const componentName = parsed.componentName || "Button";
       const variant = parsed.variant || "";
       const useCase = parsed.useCase || "";
-      const component = catalog5.components.find(
+      const component = catalog6.components.find(
         (c) => c.name.toLowerCase() === componentName.toLowerCase()
       );
       let componentInfo = "";
@@ -11921,7 +13560,7 @@ ${component.examples.map((e) => `### ${e.title}
 ${e.code}
 \`\`\``).join("\n\n")}`;
       } else {
-        componentInfo = `Component "${componentName}" not found in catalog. Available components: ${catalog5.components.map((c) => c.name).join(", ")}`;
+        componentInfo = `Component "${componentName}" not found in catalog. Available components: ${catalog6.components.map((c) => c.name).join(", ")}`;
       }
       return {
         messages: [