@gauts/auth 0.8.2 → 0.9.0

package/README.md

@@ -2,7 +2,7 @@
 
 Database-backed password authentication, opaque browser sessions, and optional social authentication for Node.js applications.
 
-`@gauts/auth` provides password hashing, session lifecycle, secure cookies, database validation, optional short caching, Prisma persistence, Hono integration, and Google/GitHub/X OAuth. The application keeps control of credential lookup, business-specific registration data, authorization, responses, and UI.
+`@gauts/auth` provides password hashing, session lifecycle, secure cookies, database validation, optional short caching, Prisma or Drizzle persistence, Hono/Express/Fastify integration, and Google/GitHub/X OAuth. The application keeps control of credential lookup, business-specific registration data, authorization, responses, and UI.
 
 ## Features
 
@@ -19,7 +19,10 @@ Database-backed password authentication, opaque browser sessions, and optional s
 | IP validation                  |   ✅    | Disabled            |
 | Platform validation            |   ✅    | Disabled            |
 | Hono adapter                   |   ✅    | Available           |
+| Express adapter                |   ✅    | Available           |
+| Fastify adapter                |   ✅    | Available           |
 | Prisma adapter                 |   ✅    | Available           |
+| Drizzle MySQL/MariaDB adapter  |   ✅    | Available           |
 | Next.js renewal adapter        |   ✅    | Available           |
 | Google social authentication   |   ✅    | Opt-in              |
 | GitHub social authentication   |   ✅    | Opt-in              |
@@ -40,25 +43,38 @@ The application defines its credential login, renewal, logout, and protected end
 
 ### 1. Install the package
 
-Run these commands inside the Hono API project:
+Install the package and the framework used by the API. Only one framework adapter is required:
 
 ```bash
-npm install @gauts/auth
-npm install hono @prisma/client
+npm install @gauts/auth hono
+npm install @gauts/auth express
+npm install @gauts/auth fastify
 ```
 
-When the Next.js frontend is a separate project, run these commands inside the frontend project:
+When the Next.js frontend is a separate project, run this command inside the frontend project:
 
 ```bash
-npm install @gauts/auth
-npm install next
+npm install @gauts/auth next
 ```
 
-`hono`, `@prisma/client`, and `next` only need to be installed when the corresponding project does not already provide them. The API imports `@gauts/auth/hono` and `@gauts/auth/prisma`; the frontend imports `@gauts/auth/next`.
+Run only the matching API command. `hono`, `express`, `fastify`, and `next` only need to be installed when the corresponding project does not already provide them.
 
-### 2. Add the Prisma schema
+Express TypeScript projects also install its type declarations:
 
-The default adapter uses this fixed relationship tree:
+```bash
+npm install --save-dev @types/express
+```
+
+### 2. Choose the database adapter and schema
+
+One database adapter is required. Prisma and Drizzle are equivalent persistence choices; install and configure only one.
+
+| Adapter | Database support           | Setup                                          |
+| ------- | -------------------------- | ---------------------------------------------- |
+| Prisma  | Prisma-supported databases | [Use Prisma](#option-a--prisma)                |
+| Drizzle | MySQL and MariaDB          | [Use Drizzle](#option-b--drizzle-mysqlmariadb) |
+
+Both schemas use the same relationship tree:
 
 ```text
 users
@@ -66,70 +82,78 @@ users
     └── account_sessions
 ```
 
-Add the three required models to the API schema. Social authentication is an optional addon with its own schema instructions later in this README.
+Social authentication is an optional addon with separate schema instructions later in this README.
 
-```prisma
-model users {
-  id   String @id @default(uuid()) @db.VarChar(255)
-  name String @db.VarChar(255)
+#### Option A — Prisma
 
-  accounts user_accounts[]
-}
+Install Prisma inside the API project:
 
-model user_accounts {
-  id            String  @id @default(uuid()) @db.VarChar(255)
-  user_id       String  @db.VarChar(255)
-  email         String  @unique @db.VarChar(255)
-  password_hash String? @db.VarChar(255)
+```bash
+npm install @prisma/client
+npm install --save-dev prisma
+```
 
-  user     users             @relation(fields: [user_id], references: [id], onDelete: Cascade)
-  sessions account_sessions[]
+[View and copy the Prisma schema](./src/adapters/prisma/schema.prisma) into the application's Prisma schema.
 
-  @@index([user_id])
-}
+Create the migration through the application's Prisma workflow, then regenerate its client:
 
-model account_sessions {
-  id          String    @id @default(uuid()) @db.VarChar(255)
-  account_id  String    @db.VarChar(255)
-  token_hash  String    @unique @db.VarChar(64)
-  ip          String?   @db.VarChar(45)
-  country     String?   @db.VarChar(2)
-  platform    String?   @db.VarChar(255)
-  agent       String?   @db.Text
-  expires_at  DateTime  @db.Timestamp(0)
-  revoked_at  DateTime? @db.Timestamp(0)
-  created_at  DateTime  @default(now()) @db.Timestamp(0)
-  updated_at  DateTime? @db.Timestamp(0)
+```bash
+npx prisma migrate dev --name add_auth
+npx prisma generate
+```
 
-  account user_accounts @relation(fields: [account_id], references: [id], onDelete: Cascade)
+Create the database adapter:
 
-  @@index([account_id])
-  @@index([expires_at])
-  @@index([revoked_at])
-}
+```ts
+import { createPrismaAdapter } from "@gauts/auth/prisma";
+
+import { prisma } from "./db.js";
+
+export const authDb = createPrismaAdapter({
+    client: prisma,
+});
 ```
 
-Create the migration through the application's Prisma workflow, then regenerate its client:
+#### Option B — Drizzle MySQL/MariaDB
+
+Install Drizzle and the application's MySQL driver inside the API project:
 
 ```bash
-npx prisma migrate dev --name add_auth
-npx prisma generate
+npm install drizzle-orm mysql2
+npm install --save-dev drizzle-kit
+```
+
+[View and copy the Drizzle MySQL/MariaDB schema](./src/adapters/drizzle/schema.ts) into the application.
+
+Create and apply the migration through the application's Drizzle workflow, then create the database adapter:
+
+```ts
+import { createDrizzleAdapter } from "@gauts/auth/drizzle";
+
+import { db } from "./db.js";
+import { accountSessions, userAccounts, users } from "./schema.js";
+
+export const authDb = createDrizzleAdapter({
+    client: db,
+    models: {
+        accounts: { table: userAccounts },
+        sessions: { table: accountSessions },
+        users: { table: users },
+    },
+});
 ```
 
 ### 3. Create the auth instance and routes
 
-Create the API auth instance:
+This Hono example is identical for Prisma and Drizzle:
 
 ```ts
 import { createHonoAuth } from "@gauts/auth/hono";
-import { createPrismaAdapter } from "@gauts/auth/prisma";
 
-import { prisma } from "./db.js";
+import { authDb } from "./authDb.js";
 
 export const auth = createHonoAuth({
-    db: createPrismaAdapter({
-        client: prisma,
-    }),
+    db: authDb,
 });
 ```
 
@@ -202,6 +226,16 @@ app.get("/account", auth.requireSession, (c) => {
 });
 ```
 
+The equivalent framework examples are available here:
+
+| Framework | Simple example                                                  | Advanced example                                                    |
+| --------- | --------------------------------------------------------------- | ------------------------------------------------------------------- |
+| Hono      | [`examples/hono/simple`](./examples/hono/simple/index.ts)       | [`examples/hono/advanced`](./examples/hono/advanced/index.ts)       |
+| Express   | [`examples/express/simple`](./examples/express/simple/index.ts) | [`examples/express/advanced`](./examples/express/advanced/index.ts) |
+| Fastify   | [`examples/fastify/simple`](./examples/fastify/simple/index.ts) | [`examples/fastify/advanced`](./examples/fastify/advanced/index.ts) |
+
+Express exposes authenticated values through `response.locals`. Fastify exposes them through request decorators and requires one `auth.decorate(app)` call before routes are registered. All routes remain application-owned.
+
 When `storedHash` is missing, the package performs password work with the configured algorithm and always returns `false`. Applications do not need a dummy hash. Keep the response identical for unknown accounts and incorrect passwords.
 
 ### 4. Connect the Next.js frontend
@@ -221,7 +255,6 @@ Call it from the Next.js middleware (proxy.ts) on protected routes:
 ```ts
 import type { NextRequest } from "next/server";
 import { NextResponse } from "next/server";
-
 import { nextAuth } from "./lib/auth.js";
 
 export const proxy = async (request: NextRequest) => {
@@ -247,16 +280,22 @@ The application owns the redirect URL. When `unauthorizedUrl` is provided, the a
 
 - Node.js 22 or newer.
 - A database adapter.
+- Drizzle ORM 0.45.2 or newer when using the Drizzle adapter.
 - Hono 4 when using the Hono adapter.
+- Express 5 when using the Express adapter.
+- Fastify 5 when using the Fastify adapter.
 - Next.js 15 or newer when using the Next.js adapter.
 
-`hono` and `next` are optional peer dependencies. The Prisma adapter receives the application's generated Prisma client and does not import Prisma at runtime.
+`drizzle-orm`, `hono`, `express`, `fastify`, and `next` are optional peer dependencies. Installing or importing one adapter does not load the others. The Prisma adapter receives the application's generated Prisma client and does not import Prisma at runtime. The Drizzle adapter imports `drizzle-orm`, while the application owns the MySQL/MariaDB driver.
 
 | Import                  | Purpose                                                   |
 | ----------------------- | --------------------------------------------------------- |
 | `@gauts/auth`           | Password service, session core, errors, and public types. |
+| `@gauts/auth/drizzle`   | Drizzle database adapter for MySQL and MariaDB.           |
 | `@gauts/auth/prisma`    | Prisma database adapter.                                  |
 | `@gauts/auth/hono`      | Hono cookies, methods, and middleware.                    |
+| `@gauts/auth/express`   | Express cookies, methods, and middleware.                 |
+| `@gauts/auth/fastify`   | Fastify cookies, methods, decorators, and hooks.          |
 | `@gauts/auth/next`      | Next.js renewal scheduling and `Set-Cookie` forwarding.   |
 | `@gauts/auth/providers` | Google, GitHub, and X OAuth providers.                    |
 
@@ -281,6 +320,8 @@ type HonoGetIp = (c: Context) => Promise<string | null | undefined> | string | n
 
 When `getIp` is omitted, the adapter stores `ip: null` and does not read IP headers automatically. Configuring `session.validation` with `"ip"` requires `getIp` and fails during initialization when it is missing.
 
+`createExpressAuth()` and `createFastifyAuth()` accept the same configuration. Their `getIp` callback receives the native Express or Fastify request instead of a Hono context.
+
 ### Password
 
 #### Argon2id
@@ -453,6 +494,8 @@ users
     └── account_sessions
 ```
 
+[View and copy the required Prisma schema](./src/adapters/prisma/schema.prisma).
+
 The required default delegate names are `prisma.users`, `prisma.user_accounts`, and `prisma.account_sessions`. The fixed Prisma relation fields are:
 
 - `user_accounts.user`;
@@ -555,6 +598,76 @@ access: {
 
 Every configured account and user condition must match. Omitting `access` applies no application-specific account restriction.
 
+### Drizzle MySQL/MariaDB adapter
+
+The Drizzle adapter supports MySQL and MariaDB. Install it inside the API project with the driver used by the application:
+
+```bash
+npm install @gauts/auth drizzle-orm mysql2
+```
+
+Unlike Prisma, Drizzle does not expose model delegates that can be discovered by name. Pass the application's table objects explicitly:
+
+```ts
+import { createDrizzleAdapter } from "@gauts/auth/drizzle";
+import { createHonoAuth } from "@gauts/auth/hono";
+import { db } from "./db.js";
+import { accountSessions, userAccounts, users } from "./schema.js";
+
+export const auth = createHonoAuth({
+    db: createDrizzleAdapter({
+        client: db,
+        models: {
+            accounts: { table: userAccounts },
+            sessions: { table: accountSessions },
+            users: { table: users },
+        },
+    }),
+});
+```
+
+The minimum Drizzle schema uses the same relationship tree and canonical TypeScript field names as the Prisma adapter. [View and copy the required Drizzle MySQL/MariaDB schema](./src/adapters/drizzle/schema.ts).
+
+The adapter queries these tables through explicit SQL joins, so Drizzle `relations()` declarations are not required. Physical SQL column names may use aliases, but the TypeScript keys shown above are part of the adapter contract. Date columns must use `{ mode: "date" }`.
+
+`select` and `access` work exactly like the Prisma adapter and are inferred from the supplied table:
+
+```ts
+const database = createDrizzleAdapter({
+    client: db,
+    models: {
+        accounts: {
+            access: {
+                role: ["OWNER", "ADMIN"],
+                status: ["ACTIVE"],
+            },
+            select: ["role", "status", "timezone"],
+            table: userAccounts,
+        },
+        sessions: { table: accountSessions },
+        users: {
+            access: { status: ["ACTIVE", "PENDING"] },
+            select: ["status"],
+            table: users,
+        },
+    },
+});
+```
+
+| Property                 | Required | Description                                                            |
+| ------------------------ | :------: | ---------------------------------------------------------------------- |
+| `client`                 |    ✅    | Drizzle MySQL client created by the application.                       |
+| `models.users.table`     |    ✅    | Table with `id` and `name` columns.                                    |
+| `models.users.select`    |    ❌    | Additional public scalar fields; `id` and `name` are always included.  |
+| `models.users.access`    |    ❌    | Required values for the owning user/entity.                            |
+| `models.accounts.table`  |    ✅    | Table with `id`, `email`, and `user_id` columns.                       |
+| `models.accounts.select` |    ❌    | Additional public scalar fields; `id` and `email` are always included. |
+| `models.accounts.access` |    ❌    | Required values for the authenticating account.                        |
+| `models.sessions.table`  |    ✅    | Table implementing the complete documented session column contract.    |
+| `models.socials.table`   |    ❌    | Enables social persistence when the optional social table is supplied. |
+
+Private password fields are rejected from `select` and `access` by both TypeScript and runtime validation. The adapter does not load or execute the Prisma adapter, and Prisma is not required in a Drizzle application.
+
 ### Next.js adapter
 
 ```ts
@@ -657,7 +770,7 @@ type Session = {
 };
 ```
 
-The Prisma adapter refines `account` and `user` with the exact additional scalar fields declared in their respective `select` arrays.
+The Prisma and Drizzle adapters refine `account` and `user` with the exact additional scalar fields declared in their respective `select` arrays.
 
 Only `account_id` is copied into the session row. Current account/user data is loaded through the fixed database relations and is never duplicated in the session table.
 
@@ -673,7 +786,7 @@ await auth.createSession({
 });
 ```
 
-`country` is normalized to uppercase and is never used for authentication or client matching. It is not resolved by the package and does not trigger GeoIP work during normal requests. When supplied, the configured session model must provide a nullable `country` column. When omitted, the Prisma adapter does not send the field.
+`country` is normalized to uppercase and is never used for authentication or client matching. It is not resolved by the package and does not trigger GeoIP work during normal requests. When supplied, the configured session model must provide a nullable `country` column. When omitted, the database adapter does not send the field.
 
 ### Methods
 
@@ -689,11 +802,69 @@ await auth.createSession({
 
 `requireSession` authenticates only. Application-specific route permissions remain the application's responsibility.
 
+## Express adapter
+
+```ts
+import { createExpressAuth, type ExpressAuthLocals } from "@gauts/auth/express";
+
+const auth = createExpressAuth({ db });
+
+app.get("/account", auth.requireSession, (_request, response) => {
+    const { account, session, user } = response.locals as ExpressAuthLocals;
+    response.json({ account, session, user });
+});
+```
+
+| Method                                                            | Purpose                                              |
+| ----------------------------------------------------------------- | ---------------------------------------------------- |
+| `auth.createSession({ account_id, request, response, country? })` | Creates the DB session and writes cookies.           |
+| `auth.resolveSession({ request, response })`                      | Resolves the selected account and session.           |
+| `auth.renewSession({ request, response })`                        | Renews when due and writes authoritative cookies.    |
+| `auth.revokeSession({ request, response })`                       | Revokes the current session and clears cookies.      |
+| `auth.clearSession(response)`                                     | Clears cookies without revoking the DB session.      |
+| `auth.getToken(request)`                                          | Reads and validates the opaque session token.        |
+| `auth.requireSession`                                             | Express middleware that populates `response.locals`. |
+
+Express 5 forwards rejected async middleware promises to the application's error handler. The adapter does not install routes or an error handler.
+
+## Fastify adapter
+
+Register the request decorators once before declaring routes:
+
+```ts
+import { createFastifyAuth } from "@gauts/auth/fastify";
+
+const auth = createFastifyAuth({ db });
+
+auth.decorate(app);
+
+app.get("/account", { preHandler: auth.requireSession }, (request) => ({
+    account: request.getDecorator("account"),
+    session: request.getDecorator("session"),
+    user: request.getDecorator("user"),
+}));
+```
+
+| Method                                                         | Purpose                                                        |
+| -------------------------------------------------------------- | -------------------------------------------------------------- |
+| `auth.decorate(app)`                                           | Declares the native request decorators once at startup.        |
+| `auth.createSession({ account_id, request, reply, country? })` | Creates the DB session and writes cookies.                     |
+| `auth.resolveSession({ request, reply })`                      | Resolves the selected account and session.                     |
+| `auth.renewSession({ request, reply })`                        | Renews when due and writes authoritative cookies.              |
+| `auth.revokeSession({ request, reply })`                       | Revokes the current session and clears cookies.                |
+| `auth.clearSession(reply)`                                     | Clears cookies without revoking the DB session.                |
+| `auth.getToken(request)`                                       | Reads and validates the opaque session token.                  |
+| `auth.requireSession`                                          | Fastify `preHandler` that populates native request decorators. |
+
+When social authentication is enabled, `auth.decorate(app)` also declares `social`. The adapter does not register a Fastify plugin or create routes.
+
 ## Social authentication
 
 Social authentication is an optional addon and remains disabled unless `social` is configured. Complete these steps only in applications that need Google, GitHub, or X authentication.
 
-### 1. Add the social Prisma schema
+### 1. Add social persistence
+
+#### Prisma
 
 Add the social relation inside the existing `user_accounts` model in the API schema:
 
@@ -745,6 +916,49 @@ const db = createPrismaAdapter({
 });
 ```
 
+#### Drizzle MySQL/MariaDB
+
+Add the provider table to the API schema:
+
+```ts
+export const socialAccounts = mysqlTable(
+    "social_accounts",
+    {
+        account_id: varchar("account_id", { length: 255 })
+            .notNull()
+            .references(() => userAccounts.id, { onDelete: "cascade" }),
+        created_at: timestamp("created_at", { mode: "date" }).defaultNow().notNull(),
+        id: varchar("id", { length: 255 }).primaryKey(),
+        provider: varchar("provider", { length: 32 }).notNull(),
+        provider_id: varchar("provider_id", { length: 255 }).notNull(),
+    },
+    (table) => [
+        index("social_accounts_account_id_idx").on(table.account_id),
+        uniqueIndex("social_accounts_provider_provider_id_key").on(
+            table.provider,
+            table.provider_id,
+        ),
+        uniqueIndex("social_accounts_account_id_provider_key").on(table.account_id, table.provider),
+    ],
+);
+```
+
+Then supply it to the adapter:
+
+```ts
+const db = createDrizzleAdapter({
+    client,
+    models: {
+        accounts: { table: userAccounts },
+        sessions: { table: accountSessions },
+        socials: { table: socialAccounts },
+        users: { table: users },
+    },
+});
+```
+
+Omitting `models.socials` keeps the Drizzle adapter session-only. The adapter creates the owning user and account in one transaction during default social registration, so that path requires a Drizzle MySQL driver with transaction support. Additional required user/account columns must have database defaults; otherwise the application must provide `registration.createAccount`.
+
 ### 2. Configure the providers
 
 Import only the providers used by the API:
@@ -783,7 +997,7 @@ Register every `callbackUrl` shown above in the corresponding provider dashboard
 
 ### 3. Add the API route and frontend start
 
-Declare one dynamic API route covering every configured provider. `social.handle` is Hono middleware: it completes `start` and expected error responses itself, then calls the application handler only after a successful callback.
+Declare one dynamic API route covering every configured provider. `social.handle` completes `start` and expected error responses itself, then continues to the application handler only after a successful callback.
 
 ```ts
 app.get("/auth/social/:provider/:action", auth.social.handle, async (c) => {
@@ -827,16 +1041,28 @@ social.registered;
 social.returnTo;
 ```
 
+The native equivalents are:
+
+```ts
+// Express
+const social = (response.locals as ExpressSocialLocals).social;
+
+// Fastify
+const social = request.getDecorator<SocialAuthenticated>("social");
+```
+
+See the advanced framework examples for complete social routes and custom registration.
+
 The package does not create the application route, session, notifications, logs, or final success response. Those remain explicit in the route handler.
 
 ### Social configuration
 
-| Property                     | Type / allowed values                |  Required   | Default   | Description                                                                |
-| ---------------------------- | ------------------------------------ | :---------: | --------- | -------------------------------------------------------------------------- |
-| `social.providers`           | `SocialProvider[]`                   |     ✅      | —         | Configured Google, GitHub, or X providers.                                 |
-| `social.cookieName`          | Valid cookie name                    |     ❌      | `"__soc"` | Signed temporary OAuth/registration transaction cookie.                    |
-| `social.registration`        | `SocialRegistrationConfig`           |     ❌      | Disabled  | Enables default or application-specific social registration.               |
-| `registration.createAccount` | Async callback returning `accountId` |     ❌      | Built-in  | Creates required business data when the default structure is insufficient. |
+| Property                     | Type / allowed values                | Required | Default   | Description                                                                |
+| ---------------------------- | ------------------------------------ | :------: | --------- | -------------------------------------------------------------------------- |
+| `social.providers`           | `SocialProvider[]`                   |    ✅    | —         | Configured Google, GitHub, or X providers.                                 |
+| `social.cookieName`          | Valid cookie name                    |    ❌    | `"__soc"` | Signed temporary OAuth/registration transaction cookie.                    |
+| `social.registration`        | `SocialRegistrationConfig`           |    ❌    | Disabled  | Enables default or application-specific social registration.               |
+| `registration.createAccount` | Async callback returning `accountId` |    ❌    | Built-in  | Creates required business data when the default structure is insufficient. |
 
 Provider configuration:
 
@@ -952,7 +1178,7 @@ app.post("/auth/register/social", async (c) => {
 
 ### Core and adapter composition
 
-`createHonoAuth()` is the normal entry point. Use separate composition only when the same core instance is required outside Hono:
+Use the entry point matching the application framework: `createHonoAuth()`, `createExpressAuth()`, or `createFastifyAuth()`. Use separate composition only when the same core instance is required outside the framework adapter:
 
 ```ts
 import { createAuth } from "@gauts/auth";
@@ -1074,7 +1300,7 @@ const socialDb = {
 } satisfies SocialDbAdapter;
 ```
 
-The Prisma adapter already implements both `DbAdapter` and `SocialDbAdapter`.
+The Prisma and Drizzle adapters implement both `DbAdapter` and `SocialDbAdapter` when their optional social model is available.
 
 ## Performance
 

package/dist/adapters/drizzle/config.d.ts

@@ -0,0 +1,11 @@
+import type { AnyMySqlTable } from "drizzle-orm/mysql-core";
+import type { ResolvedDrizzleModels } from "./types.js";
+export declare const DRIZZLE_FIELDS: {
+    readonly accounts: readonly ["id", "email", "user_id"];
+    readonly sessions: readonly ["account_id", "agent", "country", "created_at", "expires_at", "id", "ip", "platform", "revoked_at", "token_hash", "updated_at"];
+    readonly socials: readonly ["account_id", "created_at", "id", "provider", "provider_id"];
+    readonly users: readonly ["id", "name"];
+};
+export declare const resolveDrizzleModels: (input: unknown) => ResolvedDrizzleModels;
+export declare const getDrizzleSource: (table: AnyMySqlTable) => string;
+//# sourceMappingURL=config.d.ts.map

package/dist/adapters/drizzle/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/adapters/drizzle/config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAK5D,OAAO,KAAK,EAA4B,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAkClF,eAAO,MAAM,cAAc;;;;;CAiBjB,CAAC;AA+HX,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,KAAG,qBAmCrD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,aAAa,KAAG,MAEvD,CAAC"}