@objectstack/plugin-auth 4.0.3 → 4.0.5

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,15 +17,30 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   AUTH_ACCOUNT_CONFIG: () => AUTH_ACCOUNT_CONFIG,
+  AUTH_DEVICE_CODE_SCHEMA: () => AUTH_DEVICE_CODE_SCHEMA,
   AUTH_INVITATION_SCHEMA: () => AUTH_INVITATION_SCHEMA,
+  AUTH_JWKS_SCHEMA: () => AUTH_JWKS_SCHEMA,
   AUTH_MEMBER_SCHEMA: () => AUTH_MEMBER_SCHEMA,
   AUTH_MODEL_TO_PROTOCOL: () => AUTH_MODEL_TO_PROTOCOL,
+  AUTH_OAUTH_ACCESS_TOKEN_SCHEMA: () => AUTH_OAUTH_ACCESS_TOKEN_SCHEMA,
+  AUTH_OAUTH_APPLICATION_SCHEMA: () => AUTH_OAUTH_APPLICATION_SCHEMA,
+  AUTH_OAUTH_CLIENT_SCHEMA: () => AUTH_OAUTH_CLIENT_SCHEMA,
+  AUTH_OAUTH_CONSENT_SCHEMA: () => AUTH_OAUTH_CONSENT_SCHEMA,
+  AUTH_OAUTH_REFRESH_TOKEN_SCHEMA: () => AUTH_OAUTH_REFRESH_TOKEN_SCHEMA,
   AUTH_ORGANIZATION_SCHEMA: () => AUTH_ORGANIZATION_SCHEMA,
   AUTH_ORG_SESSION_FIELDS: () => AUTH_ORG_SESSION_FIELDS,
   AUTH_SESSION_CONFIG: () => AUTH_SESSION_CONFIG,
@@ -33,24 +50,12 @@ __export(index_exports, {
   AUTH_TWO_FACTOR_USER_FIELDS: () => AUTH_TWO_FACTOR_USER_FIELDS,
   AUTH_USER_CONFIG: () => AUTH_USER_CONFIG,
   AUTH_VERIFICATION_CONFIG: () => AUTH_VERIFICATION_CONFIG,
-  AuthAccount: () => SysAccount,
   AuthManager: () => AuthManager,
   AuthPlugin: () => AuthPlugin,
-  AuthSession: () => SysSession,
-  AuthUser: () => SysUser,
-  AuthVerification: () => SysVerification,
-  SysAccount: () => SysAccount,
-  SysApiKey: () => SysApiKey,
-  SysInvitation: () => SysInvitation,
-  SysMember: () => SysMember,
-  SysOrganization: () => SysOrganization,
-  SysSession: () => SysSession,
-  SysTeam: () => SysTeam,
-  SysTeamMember: () => SysTeamMember,
-  SysTwoFactor: () => SysTwoFactor,
-  SysUser: () => SysUser,
-  SysUserPreference: () => SysUserPreference,
-  SysVerification: () => SysVerification,
+  buildDeviceAuthorizationPluginSchema: () => buildDeviceAuthorizationPluginSchema,
+  buildJwtPluginSchema: () => buildJwtPluginSchema,
+  buildOauthProviderPluginSchema: () => buildOauthProviderPluginSchema,
+  buildOidcProviderPluginSchema: () => buildOidcProviderPluginSchema,
   buildOrganizationPluginSchema: () => buildOrganizationPluginSchema,
   buildTwoFactorPluginSchema: () => buildTwoFactorPluginSchema,
   createObjectQLAdapter: () => createObjectQLAdapter,
@@ -59,11 +64,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/auth-manager.ts
-var import_better_auth = require("better-auth");
-var import_organization = require("better-auth/plugins/organization");
-var import_two_factor = require("better-auth/plugins/two-factor");
-var import_magic_link = require("better-auth/plugins/magic-link");
+// src/auth-plugin.ts
+var import_apps = require("@objectstack/platform-objects/apps");
 
 // src/objectql-adapter.ts
 var import_adapters = require("better-auth/adapters");
@@ -337,6 +339,81 @@ var AUTH_TWO_FACTOR_SCHEMA = {
 var AUTH_TWO_FACTOR_USER_FIELDS = {
   twoFactorEnabled: "two_factor_enabled"
 };
+var AUTH_OAUTH_CLIENT_SCHEMA = {
+  modelName: import_system2.SystemObjectName.OAUTH_APPLICATION,
+  // 'sys_oauth_application'
+  fields: {
+    clientId: "client_id",
+    clientSecret: "client_secret",
+    skipConsent: "skip_consent",
+    enableEndSession: "enable_end_session",
+    subjectType: "subject_type",
+    userId: "user_id",
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+    redirectUris: "redirect_uris",
+    postLogoutRedirectUris: "post_logout_redirect_uris",
+    tokenEndpointAuthMethod: "token_endpoint_auth_method",
+    grantTypes: "grant_types",
+    responseTypes: "response_types",
+    requirePKCE: "require_pkce",
+    softwareId: "software_id",
+    softwareVersion: "software_version",
+    softwareStatement: "software_statement",
+    referenceId: "reference_id"
+  }
+};
+var AUTH_OAUTH_APPLICATION_SCHEMA = AUTH_OAUTH_CLIENT_SCHEMA;
+var AUTH_OAUTH_ACCESS_TOKEN_SCHEMA = {
+  modelName: import_system2.SystemObjectName.OAUTH_ACCESS_TOKEN,
+  // 'sys_oauth_access_token'
+  fields: {
+    clientId: "client_id",
+    sessionId: "session_id",
+    userId: "user_id",
+    referenceId: "reference_id",
+    refreshId: "refresh_id",
+    expiresAt: "expires_at",
+    createdAt: "created_at"
+  }
+};
+var AUTH_OAUTH_REFRESH_TOKEN_SCHEMA = {
+  modelName: import_system2.SystemObjectName.OAUTH_REFRESH_TOKEN,
+  // 'sys_oauth_refresh_token'
+  fields: {
+    clientId: "client_id",
+    sessionId: "session_id",
+    userId: "user_id",
+    referenceId: "reference_id",
+    expiresAt: "expires_at",
+    createdAt: "created_at",
+    authTime: "auth_time"
+  }
+};
+var AUTH_OAUTH_CONSENT_SCHEMA = {
+  modelName: import_system2.SystemObjectName.OAUTH_CONSENT,
+  // 'sys_oauth_consent'
+  fields: {
+    clientId: "client_id",
+    userId: "user_id",
+    referenceId: "reference_id",
+    createdAt: "created_at",
+    updatedAt: "updated_at"
+  }
+};
+var AUTH_DEVICE_CODE_SCHEMA = {
+  modelName: import_system2.SystemObjectName.DEVICE_CODE,
+  // 'sys_device_code'
+  fields: {
+    deviceCode: "device_code",
+    userCode: "user_code",
+    userId: "user_id",
+    expiresAt: "expires_at",
+    lastPolledAt: "last_polled_at",
+    pollingInterval: "polling_interval",
+    clientId: "client_id"
+  }
+};
 function buildTwoFactorPluginSchema() {
   return {
     twoFactor: AUTH_TWO_FACTOR_SCHEMA,
@@ -357,6 +434,35 @@ function buildOrganizationPluginSchema() {
     }
   };
 }
+var AUTH_JWKS_SCHEMA = {
+  modelName: import_system2.SystemObjectName.JWKS,
+  // 'sys_jwks'
+  fields: {
+    publicKey: "public_key",
+    privateKey: "private_key",
+    createdAt: "created_at",
+    expiresAt: "expires_at"
+  }
+};
+function buildJwtPluginSchema() {
+  return {
+    jwks: AUTH_JWKS_SCHEMA
+  };
+}
+function buildOauthProviderPluginSchema() {
+  return {
+    oauthClient: AUTH_OAUTH_CLIENT_SCHEMA,
+    oauthAccessToken: AUTH_OAUTH_ACCESS_TOKEN_SCHEMA,
+    oauthRefreshToken: AUTH_OAUTH_REFRESH_TOKEN_SCHEMA,
+    oauthConsent: AUTH_OAUTH_CONSENT_SCHEMA
+  };
+}
+var buildOidcProviderPluginSchema = buildOauthProviderPluginSchema;
+function buildDeviceAuthorizationPluginSchema() {
+  return {
+    deviceCode: AUTH_DEVICE_CODE_SCHEMA
+  };
+}
 
 // src/auth-manager.ts
 var AuthManager = class {
@@ -370,16 +476,18 @@ var AuthManager = class {
   /**
    * Get or create the better-auth instance (lazy initialization)
    */
-  getOrCreateAuth() {
+  async getOrCreateAuth() {
     if (!this.auth) {
-      this.auth = this.createAuthInstance();
+      this.auth = await this.createAuthInstance();
     }
     return this.auth;
   }
   /**
    * Create a better-auth instance from configuration
    */
-  createAuthInstance() {
+  async createAuthInstance() {
+    const { betterAuth } = await import("better-auth");
+    const plugins = await this.buildPluginList();
     const betterAuthConfig = {
       // Base configuration
       secret: this.config.secret || this.generateSecret(),
@@ -431,9 +539,22 @@ var AuthManager = class {
         // 1 day default
       },
       // better-auth plugins — registered based on AuthPluginConfig flags
-      plugins: this.buildPluginList(),
+      plugins,
       // Trusted origins for CSRF protection (supports wildcards like "https://*.example.com")
-      ...this.config.trustedOrigins?.length ? { trustedOrigins: this.config.trustedOrigins } : {},
+      // Auto-includes origins from CORS_ORIGIN env var so CORS and CSRF stay in sync.
+      ...(() => {
+        const origins = [...this.config.trustedOrigins || []];
+        const corsOrigin = process.env.CORS_ORIGIN;
+        if (corsOrigin && corsOrigin !== "*") {
+          corsOrigin.split(",").map((s) => s.trim()).filter(Boolean).forEach((o) => {
+            if (!origins.includes(o)) origins.push(o);
+          });
+        }
+        if (!origins.length && (!corsOrigin || corsOrigin === "*")) {
+          origins.push("http://localhost:*");
+        }
+        return origins.length ? { trustedOrigins: origins } : {};
+      })(),
       // Advanced options (cross-subdomain cookies, secure cookies, CSRF, etc.)
       ...this.config.advanced ? {
         advanced: {
@@ -444,7 +565,7 @@ var AuthManager = class {
         }
       } : {}
     };
-    return (0, import_better_auth.betterAuth)(betterAuthConfig);
+    return betterAuth(betterAuthConfig);
   }
   /**
    * Build the list of better-auth plugins based on AuthPluginConfig flags.
@@ -453,21 +574,52 @@ var AuthManager = class {
    * a `schema` option containing the appropriate snake_case field mappings,
    * so that `createAdapterFactory` transforms them automatically.
    */
-  buildPluginList() {
-    const pluginConfig = this.config.plugins;
+  async buildPluginList() {
+    const pluginConfig = this.config.plugins ?? {};
     const plugins = [];
-    if (pluginConfig?.organization) {
-      plugins.push((0, import_organization.organization)({
-        schema: buildOrganizationPluginSchema()
+    const enabled = {
+      organization: pluginConfig.organization ?? true,
+      twoFactor: pluginConfig.twoFactor ?? false,
+      passkeys: pluginConfig.passkeys ?? false,
+      magicLink: pluginConfig.magicLink ?? false,
+      oidcProvider: pluginConfig.oidcProvider ?? false,
+      deviceAuthorization: pluginConfig.deviceAuthorization ?? false
+    };
+    const { bearer } = await import("better-auth/plugins/bearer");
+    plugins.push(bearer());
+    if (enabled.organization) {
+      const { organization } = await import("better-auth/plugins/organization");
+      plugins.push(organization({
+        schema: buildOrganizationPluginSchema(),
+        // Enable the team sub-feature so the framework's `sys_team` /
+        // `sys_team_member` tables (already declared in platform-objects)
+        // are actually wired up to better-auth's CRUD endpoints
+        // (`/organization/{create,update,remove,list}-team[s]` and
+        // `/organization/{add,remove,list}-team-member[s]`). The Account
+        // portal exposes a Teams page; without this flag those endpoints
+        // 404 and the section silently breaks.
+        teams: { enabled: true },
+        // No mailer is wired in framework yet — log the accept URL so
+        // operators / UI can fall back to copy-paste flows. Replace this
+        // with a real mail integration when available.
+        sendInvitationEmail: async ({ email, invitation, organization: org, inviter }) => {
+          const baseUrl = (this.config.baseUrl ?? "").replace(/\/$/, "");
+          const acceptUrl = `${baseUrl}/accept-invitation/${invitation.id}`;
+          console.warn(
+            `[AuthManager] Invitation email not configured. To: ${email} (org: ${org?.name ?? invitation.organizationId}, role: ${invitation.role}, inviter: ${inviter?.user?.email ?? "unknown"}) URL: ${acceptUrl}`
+          );
+        }
       }));
     }
-    if (pluginConfig?.twoFactor) {
-      plugins.push((0, import_two_factor.twoFactor)({
+    if (enabled.twoFactor) {
+      const { twoFactor } = await import("better-auth/plugins/two-factor");
+      plugins.push(twoFactor({
         schema: buildTwoFactorPluginSchema()
       }));
     }
-    if (pluginConfig?.magicLink) {
-      plugins.push((0, import_magic_link.magicLink)({
+    if (enabled.magicLink) {
+      const { magicLink } = await import("better-auth/plugins/magic-link");
+      plugins.push(magicLink({
         sendMagicLink: async ({ email, url }) => {
           console.warn(
             `[AuthManager] Magic-link requested for ${email} but no sendMagicLink handler configured. URL: ${url}`
@@ -475,6 +627,43 @@ var AuthManager = class {
         }
       }));
     }
+    if (this.config.oidcProviders?.length) {
+      const { genericOAuth } = await import("better-auth/plugins/generic-oauth");
+      plugins.push(genericOAuth({
+        config: this.config.oidcProviders.map((p) => ({
+          providerId: p.providerId,
+          ...p.discoveryUrl ? { discoveryUrl: p.discoveryUrl } : {},
+          ...p.issuer ? { issuer: p.issuer } : {},
+          ...p.authorizationUrl ? { authorizationUrl: p.authorizationUrl } : {},
+          ...p.tokenUrl ? { tokenUrl: p.tokenUrl } : {},
+          ...p.userInfoUrl ? { userInfoUrl: p.userInfoUrl } : {},
+          clientId: p.clientId,
+          clientSecret: p.clientSecret,
+          ...p.scopes ? { scopes: p.scopes } : {},
+          ...p.pkce != null ? { pkce: p.pkce } : {}
+        }))
+      }));
+    }
+    if (enabled.oidcProvider) {
+      const { jwt } = await import("better-auth/plugins");
+      plugins.push(jwt({ schema: buildJwtPluginSchema() }));
+      const { oauthProvider } = await import("@better-auth/oauth-provider");
+      const baseUrl = (this.config.baseUrl ?? "").replace(/\/$/, "");
+      plugins.push(oauthProvider({
+        // Account SPA renders both pages — see apps/account.
+        loginPage: `${baseUrl}/_account/login`,
+        consentPage: `${baseUrl}/_account/oauth/consent`,
+        schema: buildOauthProviderPluginSchema()
+      }));
+    }
+    if (enabled.deviceAuthorization) {
+      const { deviceAuthorization } = await import("better-auth/plugins/device-authorization");
+      const baseUrl = (this.config.baseUrl ?? "").replace(/\/$/, "");
+      plugins.push(deviceAuthorization({
+        verificationUri: `${baseUrl}/_account/auth/device`,
+        schema: buildDeviceAuthorizationPluginSchema()
+      }));
+    }
     return plugins;
   }
   /**
@@ -550,7 +739,7 @@ var AuthManager = class {
    * @returns Web standard Response object
    */
   async handleRequest(request) {
-    const auth = this.getOrCreateAuth();
+    const auth = await this.getOrCreateAuth();
     const response = await auth.handler(request);
     if (response.status >= 500) {
       try {
@@ -566,779 +755,120 @@ var AuthManager = class {
    * Get the better-auth API for programmatic access
    * Use this for server-side operations (e.g., creating users, checking sessions)
    */
-  get api() {
-    return this.getOrCreateAuth().api;
+  async getApi() {
+    const auth = await this.getOrCreateAuth();
+    return auth.api;
   }
-};
-
-// src/objects/sys-user.object.ts
-var import_data = require("@objectstack/spec/data");
-var SysUser = import_data.ObjectSchema.create({
-  namespace: "sys",
-  name: "user",
-  label: "User",
-  pluralLabel: "Users",
-  icon: "user",
-  isSystem: true,
-  description: "User accounts for authentication",
-  titleFormat: "{name} ({email})",
-  compactLayout: ["name", "email", "email_verified"],
-  fields: {
-    id: import_data.Field.text({
-      label: "User ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data.Field.datetime({
-      label: "Updated At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    email: import_data.Field.email({
-      label: "Email",
-      required: true,
-      searchable: true
-    }),
-    email_verified: import_data.Field.boolean({
-      label: "Email Verified",
-      defaultValue: false
-    }),
-    name: import_data.Field.text({
-      label: "Name",
-      required: true,
-      searchable: true,
-      maxLength: 255
-    }),
-    image: import_data.Field.url({
-      label: "Profile Image",
-      required: false
-    })
-  },
-  indexes: [
-    { fields: ["email"], unique: true },
-    { fields: ["created_at"], unique: false }
-  ],
-  enable: {
-    trackHistory: true,
-    searchable: true,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "update", "delete"],
-    trash: true,
-    mru: true
-  },
-  validations: [
-    {
-      name: "email_unique",
-      type: "unique",
-      severity: "error",
-      message: "Email must be unique",
-      fields: ["email"],
-      caseSensitive: false
+  // ---------------------------------------------------------------------------
+  // Device Flow (CLI browser-based login)
+  //
+  // The device authorization flow (RFC 8628) is now handled entirely by
+  // better-auth's `device-authorization` plugin. Endpoints are exposed at
+  // `${basePath}/device/{code,token,approve,deny}` and persisted in
+  // `sys_device_code`. Enable via `plugins.deviceAuthorization: true` in
+  // AuthPluginConfig.
+  // ---------------------------------------------------------------------------
+  getPublicConfig() {
+    const socialProviders = [];
+    if (this.config.socialProviders) {
+      for (const [id, providerConfig] of Object.entries(this.config.socialProviders)) {
+        if (providerConfig.enabled !== false) {
+          const nameMap = {
+            google: "Google",
+            github: "GitHub",
+            microsoft: "Microsoft",
+            apple: "Apple",
+            facebook: "Facebook",
+            twitter: "Twitter",
+            discord: "Discord",
+            gitlab: "GitLab",
+            linkedin: "LinkedIn"
+          };
+          socialProviders.push({
+            id,
+            name: nameMap[id] || id.charAt(0).toUpperCase() + id.slice(1),
+            enabled: true,
+            type: "social"
+          });
+        }
+      }
     }
-  ]
-});
-
-// src/objects/sys-session.object.ts
-var import_data2 = require("@objectstack/spec/data");
-var SysSession = import_data2.ObjectSchema.create({
-  namespace: "sys",
-  name: "session",
-  label: "Session",
-  pluralLabel: "Sessions",
-  icon: "key",
-  isSystem: true,
-  description: "Active user sessions",
-  titleFormat: "Session {token}",
-  compactLayout: ["user_id", "expires_at", "ip_address"],
-  fields: {
-    id: import_data2.Field.text({
-      label: "Session ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data2.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data2.Field.datetime({
-      label: "Updated At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    user_id: import_data2.Field.text({
-      label: "User ID",
-      required: true
-    }),
-    expires_at: import_data2.Field.datetime({
-      label: "Expires At",
-      required: true
-    }),
-    token: import_data2.Field.text({
-      label: "Session Token",
-      required: true
-    }),
-    ip_address: import_data2.Field.text({
-      label: "IP Address",
-      required: false,
-      maxLength: 45
-      // Support IPv6
-    }),
-    user_agent: import_data2.Field.textarea({
-      label: "User Agent",
-      required: false
-    })
-  },
-  indexes: [
-    { fields: ["token"], unique: true },
-    { fields: ["user_id"], unique: false },
-    { fields: ["expires_at"], unique: false }
-  ],
-  enable: {
-    trackHistory: false,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "delete"],
-    trash: false,
-    mru: false
-  }
-});
-
-// src/objects/sys-account.object.ts
-var import_data3 = require("@objectstack/spec/data");
-var SysAccount = import_data3.ObjectSchema.create({
-  namespace: "sys",
-  name: "account",
-  label: "Account",
-  pluralLabel: "Accounts",
-  icon: "link",
-  isSystem: true,
-  description: "OAuth and authentication provider accounts",
-  titleFormat: "{provider_id} - {account_id}",
-  compactLayout: ["provider_id", "user_id", "account_id"],
-  fields: {
-    id: import_data3.Field.text({
-      label: "Account ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data3.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data3.Field.datetime({
-      label: "Updated At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    provider_id: import_data3.Field.text({
-      label: "Provider ID",
-      required: true,
-      description: "OAuth provider identifier (google, github, etc.)"
-    }),
-    account_id: import_data3.Field.text({
-      label: "Provider Account ID",
-      required: true,
-      description: "User's ID in the provider's system"
-    }),
-    user_id: import_data3.Field.text({
-      label: "User ID",
-      required: true,
-      description: "Link to user table"
-    }),
-    access_token: import_data3.Field.textarea({
-      label: "Access Token",
-      required: false
-    }),
-    refresh_token: import_data3.Field.textarea({
-      label: "Refresh Token",
-      required: false
-    }),
-    id_token: import_data3.Field.textarea({
-      label: "ID Token",
-      required: false
-    }),
-    access_token_expires_at: import_data3.Field.datetime({
-      label: "Access Token Expires At",
-      required: false
-    }),
-    refresh_token_expires_at: import_data3.Field.datetime({
-      label: "Refresh Token Expires At",
-      required: false
-    }),
-    scope: import_data3.Field.text({
-      label: "OAuth Scope",
-      required: false
-    }),
-    password: import_data3.Field.text({
-      label: "Password Hash",
-      required: false,
-      description: "Hashed password for email/password provider"
-    })
-  },
-  indexes: [
-    { fields: ["user_id"], unique: false },
-    { fields: ["provider_id", "account_id"], unique: true }
-  ],
-  enable: {
-    trackHistory: false,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "update", "delete"],
-    trash: true,
-    mru: false
-  }
-});
-
-// src/objects/sys-verification.object.ts
-var import_data4 = require("@objectstack/spec/data");
-var SysVerification = import_data4.ObjectSchema.create({
-  namespace: "sys",
-  name: "verification",
-  label: "Verification",
-  pluralLabel: "Verifications",
-  icon: "shield-check",
-  isSystem: true,
-  description: "Email and phone verification tokens",
-  titleFormat: "Verification for {identifier}",
-  compactLayout: ["identifier", "expires_at", "created_at"],
-  fields: {
-    id: import_data4.Field.text({
-      label: "Verification ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data4.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data4.Field.datetime({
-      label: "Updated At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    value: import_data4.Field.text({
-      label: "Verification Token",
-      required: true,
-      description: "Token or code for verification"
-    }),
-    expires_at: import_data4.Field.datetime({
-      label: "Expires At",
-      required: true
-    }),
-    identifier: import_data4.Field.text({
-      label: "Identifier",
-      required: true,
-      description: "Email address or phone number"
-    })
-  },
-  indexes: [
-    { fields: ["value"], unique: true },
-    { fields: ["identifier"], unique: false },
-    { fields: ["expires_at"], unique: false }
-  ],
-  enable: {
-    trackHistory: false,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "create", "delete"],
-    trash: false,
-    mru: false
-  }
-});
-
-// src/objects/sys-organization.object.ts
-var import_data5 = require("@objectstack/spec/data");
-var SysOrganization = import_data5.ObjectSchema.create({
-  namespace: "sys",
-  name: "organization",
-  label: "Organization",
-  pluralLabel: "Organizations",
-  icon: "building-2",
-  isSystem: true,
-  description: "Organizations for multi-tenant grouping",
-  titleFormat: "{name}",
-  compactLayout: ["name", "slug", "created_at"],
-  fields: {
-    id: import_data5.Field.text({
-      label: "Organization ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data5.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data5.Field.datetime({
-      label: "Updated At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    name: import_data5.Field.text({
-      label: "Name",
-      required: true,
-      searchable: true,
-      maxLength: 255
-    }),
-    slug: import_data5.Field.text({
-      label: "Slug",
-      required: false,
-      maxLength: 255,
-      description: "URL-friendly identifier"
-    }),
-    logo: import_data5.Field.url({
-      label: "Logo",
-      required: false
-    }),
-    metadata: import_data5.Field.textarea({
-      label: "Metadata",
-      required: false,
-      description: "JSON-serialized organization metadata"
-    })
-  },
-  indexes: [
-    { fields: ["slug"], unique: true },
-    { fields: ["name"] }
-  ],
-  enable: {
-    trackHistory: true,
-    searchable: true,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "update", "delete"],
-    trash: true,
-    mru: true
-  }
-});
-
-// src/objects/sys-member.object.ts
-var import_data6 = require("@objectstack/spec/data");
-var SysMember = import_data6.ObjectSchema.create({
-  namespace: "sys",
-  name: "member",
-  label: "Member",
-  pluralLabel: "Members",
-  icon: "user-check",
-  isSystem: true,
-  description: "Organization membership records",
-  titleFormat: "{user_id} in {organization_id}",
-  compactLayout: ["user_id", "organization_id", "role"],
-  fields: {
-    id: import_data6.Field.text({
-      label: "Member ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data6.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    organization_id: import_data6.Field.text({
-      label: "Organization ID",
-      required: true
-    }),
-    user_id: import_data6.Field.text({
-      label: "User ID",
-      required: true
-    }),
-    role: import_data6.Field.text({
-      label: "Role",
-      required: false,
-      description: "Member role within the organization (e.g. admin, member)",
-      maxLength: 100
-    })
-  },
-  indexes: [
-    { fields: ["organization_id", "user_id"], unique: true },
-    { fields: ["user_id"] }
-  ],
-  enable: {
-    trackHistory: true,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "update", "delete"],
-    trash: false,
-    mru: false
-  }
-});
-
-// src/objects/sys-invitation.object.ts
-var import_data7 = require("@objectstack/spec/data");
-var SysInvitation = import_data7.ObjectSchema.create({
-  namespace: "sys",
-  name: "invitation",
-  label: "Invitation",
-  pluralLabel: "Invitations",
-  icon: "mail",
-  isSystem: true,
-  description: "Organization invitations for user onboarding",
-  titleFormat: "Invitation to {organization_id}",
-  compactLayout: ["email", "organization_id", "status"],
-  fields: {
-    id: import_data7.Field.text({
-      label: "Invitation ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data7.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    organization_id: import_data7.Field.text({
-      label: "Organization ID",
-      required: true
-    }),
-    email: import_data7.Field.email({
-      label: "Email",
-      required: true,
-      description: "Email address of the invited user"
-    }),
-    role: import_data7.Field.text({
-      label: "Role",
-      required: false,
-      maxLength: 100,
-      description: "Role to assign upon acceptance"
-    }),
-    status: import_data7.Field.select(["pending", "accepted", "rejected", "expired", "canceled"], {
-      label: "Status",
-      required: true,
-      defaultValue: "pending"
-    }),
-    inviter_id: import_data7.Field.text({
-      label: "Inviter ID",
-      required: true,
-      description: "User ID of the person who sent the invitation"
-    }),
-    expires_at: import_data7.Field.datetime({
-      label: "Expires At",
-      required: true
-    }),
-    team_id: import_data7.Field.text({
-      label: "Team ID",
-      required: false,
-      description: "Optional team to assign upon acceptance"
-    })
-  },
-  indexes: [
-    { fields: ["organization_id"] },
-    { fields: ["email"] },
-    { fields: ["expires_at"] }
-  ],
-  enable: {
-    trackHistory: true,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "update", "delete"],
-    trash: false,
-    mru: false
-  }
-});
-
-// src/objects/sys-team.object.ts
-var import_data8 = require("@objectstack/spec/data");
-var SysTeam = import_data8.ObjectSchema.create({
-  namespace: "sys",
-  name: "team",
-  label: "Team",
-  pluralLabel: "Teams",
-  icon: "users",
-  isSystem: true,
-  description: "Teams within organizations for fine-grained grouping",
-  titleFormat: "{name}",
-  compactLayout: ["name", "organization_id", "created_at"],
-  fields: {
-    id: import_data8.Field.text({
-      label: "Team ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data8.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data8.Field.datetime({
-      label: "Updated At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    name: import_data8.Field.text({
-      label: "Name",
-      required: true,
-      searchable: true,
-      maxLength: 255
-    }),
-    organization_id: import_data8.Field.text({
-      label: "Organization ID",
-      required: true
-    })
-  },
-  indexes: [
-    { fields: ["organization_id"] },
-    { fields: ["name", "organization_id"], unique: true }
-  ],
-  enable: {
-    trackHistory: true,
-    searchable: true,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "update", "delete"],
-    trash: true,
-    mru: false
-  }
-});
-
-// src/objects/sys-team-member.object.ts
-var import_data9 = require("@objectstack/spec/data");
-var SysTeamMember = import_data9.ObjectSchema.create({
-  namespace: "sys",
-  name: "team_member",
-  label: "Team Member",
-  pluralLabel: "Team Members",
-  icon: "user-plus",
-  isSystem: true,
-  description: "Team membership records linking users to teams",
-  titleFormat: "{user_id} in {team_id}",
-  compactLayout: ["user_id", "team_id", "created_at"],
-  fields: {
-    id: import_data9.Field.text({
-      label: "Team Member ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data9.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    team_id: import_data9.Field.text({
-      label: "Team ID",
-      required: true
-    }),
-    user_id: import_data9.Field.text({
-      label: "User ID",
-      required: true
-    })
-  },
-  indexes: [
-    { fields: ["team_id", "user_id"], unique: true },
-    { fields: ["user_id"] }
-  ],
-  enable: {
-    trackHistory: true,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "delete"],
-    trash: false,
-    mru: false
-  }
-});
-
-// src/objects/sys-api-key.object.ts
-var import_data10 = require("@objectstack/spec/data");
-var SysApiKey = import_data10.ObjectSchema.create({
-  namespace: "sys",
-  name: "api_key",
-  label: "API Key",
-  pluralLabel: "API Keys",
-  icon: "key-round",
-  isSystem: true,
-  description: "API keys for programmatic access",
-  titleFormat: "{name}",
-  compactLayout: ["name", "user_id", "expires_at"],
-  fields: {
-    id: import_data10.Field.text({
-      label: "API Key ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data10.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data10.Field.datetime({
-      label: "Updated At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    name: import_data10.Field.text({
-      label: "Name",
-      required: true,
-      maxLength: 255,
-      description: "Human-readable label for the API key"
-    }),
-    key: import_data10.Field.text({
-      label: "Key",
-      required: true,
-      description: "Hashed API key value"
-    }),
-    prefix: import_data10.Field.text({
-      label: "Prefix",
-      required: false,
-      maxLength: 16,
-      description: 'Visible prefix for identifying the key (e.g., "osk_")'
-    }),
-    user_id: import_data10.Field.text({
-      label: "User ID",
-      required: true,
-      description: "Owner user of this API key"
-    }),
-    scopes: import_data10.Field.textarea({
-      label: "Scopes",
-      required: false,
-      description: "JSON array of permission scopes"
-    }),
-    expires_at: import_data10.Field.datetime({
-      label: "Expires At",
-      required: false
-    }),
-    last_used_at: import_data10.Field.datetime({
-      label: "Last Used At",
-      required: false
-    }),
-    revoked: import_data10.Field.boolean({
-      label: "Revoked",
-      defaultValue: false
-    })
-  },
-  indexes: [
-    { fields: ["key"], unique: true },
-    { fields: ["user_id"] },
-    { fields: ["prefix"] }
-  ],
-  enable: {
-    trackHistory: true,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "update", "delete"],
-    trash: false,
-    mru: false
+    if (this.config.oidcProviders?.length) {
+      for (const p of this.config.oidcProviders) {
+        socialProviders.push({
+          id: p.providerId,
+          name: p.name ?? p.providerId.charAt(0).toUpperCase() + p.providerId.slice(1),
+          enabled: true,
+          type: "oidc"
+        });
+      }
+    }
+    const emailPasswordConfig = this.config.emailAndPassword ?? {};
+    const emailPassword = {
+      enabled: emailPasswordConfig.enabled !== false,
+      // Default to true
+      disableSignUp: emailPasswordConfig.disableSignUp ?? false,
+      requireEmailVerification: emailPasswordConfig.requireEmailVerification ?? false
+    };
+    const pluginConfig = this.config.plugins ?? {};
+    const features = {
+      twoFactor: pluginConfig.twoFactor ?? false,
+      passkeys: pluginConfig.passkeys ?? false,
+      magicLink: pluginConfig.magicLink ?? false,
+      organization: pluginConfig.organization ?? true,
+      oidcProvider: pluginConfig.oidcProvider ?? false,
+      deviceAuthorization: pluginConfig.deviceAuthorization ?? false
+    };
+    return {
+      emailPassword,
+      socialProviders,
+      features
+    };
   }
-});
-
-// src/objects/sys-two-factor.object.ts
-var import_data11 = require("@objectstack/spec/data");
-var SysTwoFactor = import_data11.ObjectSchema.create({
-  namespace: "sys",
-  name: "two_factor",
-  label: "Two Factor",
-  pluralLabel: "Two Factor Credentials",
-  icon: "smartphone",
-  isSystem: true,
-  description: "Two-factor authentication credentials",
-  titleFormat: "Two-factor for {user_id}",
-  compactLayout: ["user_id", "created_at"],
-  fields: {
-    id: import_data11.Field.text({
-      label: "Two Factor ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data11.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data11.Field.datetime({
-      label: "Updated At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    user_id: import_data11.Field.text({
-      label: "User ID",
-      required: true
-    }),
-    secret: import_data11.Field.text({
-      label: "Secret",
-      required: true,
-      description: "TOTP secret key"
-    }),
-    backup_codes: import_data11.Field.textarea({
-      label: "Backup Codes",
-      required: false,
-      description: "JSON-serialized backup recovery codes"
-    })
-  },
-  indexes: [
-    { fields: ["user_id"], unique: true }
-  ],
-  enable: {
-    trackHistory: false,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "create", "update", "delete"],
-    trash: false,
-    mru: false
+  /**
+   * Returns the data engine wired into this auth manager. Used by route
+   * handlers (e.g. bootstrap-status) that need to query identity tables
+   * directly without going through better-auth.
+   */
+  getDataEngine() {
+    return this.config.dataEngine;
   }
-});
+};
 
-// src/objects/sys-user-preference.object.ts
-var import_data12 = require("@objectstack/spec/data");
-var SysUserPreference = import_data12.ObjectSchema.create({
+// src/manifest.ts
+var import_identity = require("@objectstack/platform-objects/identity");
+var AUTH_PLUGIN_ID = "com.objectstack.plugin-auth";
+var AUTH_PLUGIN_VERSION = "3.0.1";
+var authIdentityObjects = [
+  import_identity.SysUser,
+  import_identity.SysSession,
+  import_identity.SysAccount,
+  import_identity.SysVerification,
+  import_identity.SysOrganization,
+  import_identity.SysMember,
+  import_identity.SysInvitation,
+  import_identity.SysTeam,
+  import_identity.SysTeamMember,
+  import_identity.SysApiKey,
+  import_identity.SysTwoFactor,
+  import_identity.SysUserPreference,
+  import_identity.SysOauthApplication,
+  import_identity.SysOauthAccessToken,
+  import_identity.SysOauthRefreshToken,
+  import_identity.SysOauthConsent,
+  import_identity.SysJwks,
+  import_identity.SysDeviceCode
+];
+var authPluginManifestHeader = {
+  id: AUTH_PLUGIN_ID,
   namespace: "sys",
-  name: "user_preference",
-  label: "User Preference",
-  pluralLabel: "User Preferences",
-  icon: "settings",
-  isSystem: true,
-  description: "Per-user key-value preferences (theme, locale, etc.)",
-  titleFormat: "{key}",
-  compactLayout: ["user_id", "key"],
-  fields: {
-    id: import_data12.Field.text({
-      label: "Preference ID",
-      required: true,
-      readonly: true
-    }),
-    created_at: import_data12.Field.datetime({
-      label: "Created At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data12.Field.datetime({
-      label: "Updated At",
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    user_id: import_data12.Field.text({
-      label: "User ID",
-      required: true,
-      maxLength: 255,
-      description: "Owner user of this preference"
-    }),
-    key: import_data12.Field.text({
-      label: "Key",
-      required: true,
-      maxLength: 255,
-      description: "Preference key (e.g., theme, locale, plugin.ai.auto_save)"
-    }),
-    value: import_data12.Field.json({
-      label: "Value",
-      description: "Preference value (any JSON-serializable type)"
-    })
-  },
-  indexes: [
-    { fields: ["user_id", "key"], unique: true },
-    { fields: ["user_id"], unique: false }
-  ],
-  enable: {
-    trackHistory: false,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "update", "delete"],
-    trash: false,
-    mru: false
-  }
-});
+  version: AUTH_PLUGIN_VERSION,
+  type: "plugin",
+  scope: "system",
+  defaultDatasource: "cloud",
+  name: "Authentication & Identity Plugin",
+  description: "Core authentication objects for ObjectStack (User, Session, Account, Verification)"
+};
 
 // src/auth-plugin.ts
 var AuthPlugin = class {
@@ -1369,43 +899,27 @@ var AuthPlugin = class {
     });
     ctx.registerService("auth", this.authManager);
     ctx.getService("manifest").register({
-      id: "com.objectstack.system",
-      name: "System",
-      version: "1.0.0",
-      type: "plugin",
-      namespace: "sys",
-      objects: [
-        SysUser,
-        SysSession,
-        SysAccount,
-        SysVerification,
-        SysOrganization,
-        SysMember,
-        SysInvitation,
-        SysTeam,
-        SysTeamMember,
-        SysApiKey,
-        SysTwoFactor,
-        SysUserPreference
-      ]
+      ...authPluginManifestHeader,
+      objects: authIdentityObjects,
+      // The platform Setup App is a static metadata artifact (lives in
+      // @objectstack/platform-objects/apps). plugin-auth is the natural
+      // owner of its registration since it loads first among the trio
+      // (auth + security + audit) that supplies the underlying objects.
+      apps: [import_apps.SETUP_APP],
+      // Curated list views and dashboards consumed by the Setup App's
+      // navigation entries. The manifest service does NOT auto-discover
+      // these from the app definition — they must be registered as
+      // explicit top-level arrays per ObjectStackDefinitionSchema.
+      views: [
+        import_apps.UsersView,
+        import_apps.OrganizationsView,
+        import_apps.RolesView,
+        import_apps.SessionsView,
+        import_apps.AuditLogsView,
+        import_apps.PackageInstallationsView
+      ],
+      dashboards: [import_apps.SystemOverviewDashboard, import_apps.SecurityOverviewDashboard]
     });
-    try {
-      const setupNav = ctx.getService("setupNav");
-      if (setupNav) {
-        setupNav.contribute({
-          areaId: "area_administration",
-          items: [
-            { id: "nav_users", type: "object", label: "Users", objectName: "user", icon: "users", order: 10 },
-            { id: "nav_organizations", type: "object", label: "Organizations", objectName: "organization", icon: "building-2", order: 20 },
-            { id: "nav_teams", type: "object", label: "Teams", objectName: "team", icon: "users-round", order: 30 },
-            { id: "nav_api_keys", type: "object", label: "API Keys", objectName: "api_key", icon: "key", order: 40 },
-            { id: "nav_sessions", type: "object", label: "Sessions", objectName: "session", icon: "monitor", order: 50 }
-          ]
-        });
-        ctx.logger.info("Auth navigation items contributed to Setup App");
-      }
-    } catch {
-    }
     ctx.logger.info("Auth Plugin initialized successfully");
   }
   async start(ctx) {
@@ -1428,7 +942,8 @@ var AuthPlugin = class {
               const configuredUrl = this.options.baseUrl || "http://localhost:3000";
               const configuredOrigin = new URL(configuredUrl).origin;
               const actualUrl = `http://localhost:${actualPort}`;
-              if (configuredOrigin !== actualUrl) {
+              const configuredIsLocalhost = configuredOrigin.startsWith("http://localhost");
+              if (configuredIsLocalhost && configuredOrigin !== actualUrl) {
                 this.authManager.setRuntimeBaseUrl(actualUrl);
                 ctx.logger.info(
                   `Auth baseUrl auto-updated to ${actualUrl} (configured: ${configuredUrl})`
@@ -1486,6 +1001,28 @@ var AuthPlugin = class {
       );
     }
     const rawApp = httpServer.getRawApp();
+    rawApp.get(`${basePath}/config`, (c) => {
+      try {
+        const config = this.authManager.getPublicConfig();
+        return c.json({ success: true, data: config });
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return c.json({ success: false, error: { code: "auth_config_error", message: err.message } }, 500);
+      }
+    });
+    rawApp.get(`${basePath}/bootstrap-status`, async (c) => {
+      try {
+        const dataEngine = this.authManager.getDataEngine();
+        if (!dataEngine) {
+          return c.json({ hasOwner: true });
+        }
+        const count = await dataEngine.count("sys_user", {});
+        return c.json({ hasOwner: (count ?? 0) > 0 });
+      } catch (error) {
+        ctx.logger.warn("[AuthPlugin] bootstrap-status check failed; assuming bootstrapped", error);
+        return c.json({ hasOwner: true });
+      }
+    });
     rawApp.all(`${basePath}/*`, async (c) => {
       try {
         const response = await this.authManager.handleRequest(c.req.raw);
@@ -1513,15 +1050,44 @@ var AuthPlugin = class {
         );
       }
     });
+    if (this.options.plugins?.oidcProvider) {
+      void this.registerOidcDiscoveryRoutes(rawApp, ctx).catch((error) => {
+        ctx.logger.error("Failed to register OIDC discovery routes", error);
+      });
+    }
     ctx.logger.info(`Auth routes registered: All requests under ${basePath}/* forwarded to better-auth`);
   }
+  /**
+   * Mount the OIDC / OAuth 2.0 well-known discovery documents at the root
+   * URL. Required by RFC 8414 §3 and OpenID Connect Discovery 1.0 §4 — the
+   * documents must live at `/.well-known/{oauth-authorization-server,openid-configuration}`
+   * relative to the issuer, not under the auth basePath.
+   */
+  async registerOidcDiscoveryRoutes(rawApp, ctx) {
+    const auth = await this.authManager.getAuthInstance();
+    const { oauthProviderAuthServerMetadata, oauthProviderOpenIdConfigMetadata } = await import("@better-auth/oauth-provider");
+    const authServerHandler = oauthProviderAuthServerMetadata(auth);
+    const openidConfigHandler = oauthProviderOpenIdConfigMetadata(auth);
+    rawApp.get("/.well-known/oauth-authorization-server", (c) => authServerHandler(c.req.raw));
+    rawApp.get("/.well-known/openid-configuration", (c) => openidConfigHandler(c.req.raw));
+    ctx.logger.info(
+      "OIDC discovery endpoints mounted at /.well-known/{oauth-authorization-server,openid-configuration}"
+    );
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AUTH_ACCOUNT_CONFIG,
+  AUTH_DEVICE_CODE_SCHEMA,
   AUTH_INVITATION_SCHEMA,
+  AUTH_JWKS_SCHEMA,
   AUTH_MEMBER_SCHEMA,
   AUTH_MODEL_TO_PROTOCOL,
+  AUTH_OAUTH_ACCESS_TOKEN_SCHEMA,
+  AUTH_OAUTH_APPLICATION_SCHEMA,
+  AUTH_OAUTH_CLIENT_SCHEMA,
+  AUTH_OAUTH_CONSENT_SCHEMA,
+  AUTH_OAUTH_REFRESH_TOKEN_SCHEMA,
   AUTH_ORGANIZATION_SCHEMA,
   AUTH_ORG_SESSION_FIELDS,
   AUTH_SESSION_CONFIG,
@@ -1531,24 +1097,12 @@ var AuthPlugin = class {
   AUTH_TWO_FACTOR_USER_FIELDS,
   AUTH_USER_CONFIG,
   AUTH_VERIFICATION_CONFIG,
-  AuthAccount,
   AuthManager,
   AuthPlugin,
-  AuthSession,
-  AuthUser,
-  AuthVerification,
-  SysAccount,
-  SysApiKey,
-  SysInvitation,
-  SysMember,
-  SysOrganization,
-  SysSession,
-  SysTeam,
-  SysTeamMember,
-  SysTwoFactor,
-  SysUser,
-  SysUserPreference,
-  SysVerification,
+  buildDeviceAuthorizationPluginSchema,
+  buildJwtPluginSchema,
+  buildOauthProviderPluginSchema,
+  buildOidcProviderPluginSchema,
   buildOrganizationPluginSchema,
   buildTwoFactorPluginSchema,
   createObjectQLAdapter,