open-index/open-npm huggingface dataset:
npm package: @open-opo/data-model
Description: The Open OPO - Data Model is a project created to allow better understanding of all data relevant to Organ Donation and Transplants.
Latest version: 0.0.21

# OPO - Data Model

The Open OPO - Data Model is a project created to allow better understanding of all data relevant to Organ Donation and Transplants.

[Latest Documentation Website](https://open-opo.github.io/data-model/)

## Create Docs Website

```bash
"docs:serve": "http-server ./docs",
"docs:build": "typedoc lib/index.ts",
"docs:watch": "typedoc --watch lib/index.ts",
```
npm package: @open-ordinal/bootstrap
Description: Open Ordinal Bootstrap is a on-chain JavaScript library / module that solves the immutable initial loading of an ordinal.
Latest version: 0.9.0

# Open Ordinal Bootstrap

Open Ordinal Bootstrap is a on-chain JavaScript library / module that solves the immutable initial loading of an ordinal.

## Documentation

Head over to [the docs](https://openordinal.dev/docs/open-ordinal-bootstrap/) to read more about this tiny beast.

## Folders

- `dist`: Contain the minified and packaged version of the library. For now this is just used for build validation of the code.
- `docs`: Contain the generated docs.
- `lib`: Contain the build of the library. For now this is just used for build validation of the code.
- `src`: Contain all source code for the library and docs source.
- `test`: Contain the testable version used in a HTML-page.

## Commands

- `npm install`: Get all the libraries that is needed for development and running this library.
- `npm run all`: Run the `build`, `schema` and `docs` in sequence.
- `npm run build`: Builds the `src` to the `lib` folder and then minimize it to the `dist` folder.
- `npm run test`: The the same as `npm run build` and starts a dev-server hosted on port 9999.
- `npm run docs`: Builds the `docs`.

## Inscriptions
All Open Ordinal Bootstrap inscriptions.

### Strcture
Parents Strcture

| Type         | Name         | Inscription Id                                                                                                                                                            |
| ------------ | :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Organization | Open Ordinal | [0bc778d1744d87a782e165c582979f9c64e15a90cc8e77db25b16f4a740b41d4i0](https://ordinals.com/inscription/0bc778d1744d87a782e165c582979f9c64e15a90cc8e77db25b16f4a740b41d4i0) |
| Collection   | Libraries    | [e4431e01cce9d641e6e1380c1401c1cf0aeb242b5c5f5383aa17c813a7347df3i0](https://ordinals.com/inscription/e4431e01cce9d641e6e1380c1401c1cf0aeb242b5c5f5383aa17c813a7347df3i0) |

## Libraries

| Type   | Name                   | Version | Sat                                                         | Inscription Id                                                                                                                                                            |
| ------ | :--------------------- | :------ | :---------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Module | Open Ordinal Bootstrap | 0.9.0   | [1690364215876362](https://ordinals.com/sat/1690364215876362) | [d5592052351c83024a16619c7da5048df783262ec00c69f88261cf65a0f9ca11i0](https://ordinals.com/inscription/d5592052351c83024a16619c7da5048df783262ec00c69f88261cf65a0f9ca11i0) |
npm package: @open-ordinal/metadata
Description: Open Ordinal Metadata (OOMD) is an extensible format designed to standardize and enhance the metadata associated with Ordinals.
Latest version: 0.5.3

# Open Ordinal Metadata

Open Ordinal Metadata (OOMD) is an extensible format designed to standardize and enhance the metadata associated with Ordinals. 

This format is versatile and caters to a wide range of applications, including marketplaces, wallets, indexers, and content delivery networks (CDNs).

### Marketplaces
- Marketplaces can use OOMD to enhance the presentation and discoverability of Ordinals, providing rich metadata to potential buyers.
- Facilitates the listing and discovery of Ordinals with rich metadata, improving the buying and selling experience. Collections and their Ordinals can be identified from Metadata on-chain.

### Wallets
- Providing detailed metadata for better user experience and asset management.
- Wallet applications can leverage OOMD to display detailed metadata about assets, improving user experience and asset management.
- Ensures that wallets can display detailed information about Ordinals and other information connected to the Ordinal.

### Indexers
- Enabling efficient indexing and retrieval of Ordinals.
- Indexers can use OOMD to efficiently index and retrieve Ordinals, enabling fast and accurate searches.
- Allows indexers to catalog and search Ordinals efficiently, making it easier to find specific items.

## Documentation

Head over to [the docs](https://openordinal.dev/docs/open-ordinal-metadata/) to read more about this tiny beast.

## Folders

- `dist`: Contain the minified and packaged version of the library. For now this is just used for build validation of the code.
- `docs`: Contain the generated docs.
- `lib`: Contain the build of the library. For now this is just used for build validation of the code.
- `schema`: Contain schema for the library.
- `src`: Contain all source code for the library and docs source.
- `test`: Contain the testable version used in a HTML-page.

## Commands

- `npm install`: Get all the libraries that is needed for development and running this library.
- `npm run all`: Run the `build`, `schema` and `docs` in sequence.
- `npm run build`: Builds the `src` to the `lib` folder and then minimize it to the `dist` folder.
- `npm run docs`: Builds the `docs`.
- `npm run schema`: Builds the `schema`.
npm package: @open-passkey/angular
Description: Angular components for passkey (WebAuthn/FIDO2) authentication
Latest version: 0.1.2

# @open-passkey/angular

Angular components and service for passkey (WebAuthn/FIDO2) authentication with post-quantum cryptography support.

Provides headless (renderless) components using content projection and a signal-based service wrapping `@open-passkey/sdk`.

## Install

```bash
npm install @open-passkey/angular @open-passkey/sdk
```

## Quick Start

Add passkeys to your Angular app **without running your own backend**. [Locke Gateway](https://gateway.locke.id) is a free hosted passkey server:

```typescript
import { providePasskey } from "@open-passkey/angular";

bootstrapApplication(AppComponent, {
  providers: [
    providePasskey({ provider: "locke-gateway", rpId: "example.com" }),
  ],
});
```

### Self-hosted

If you're running your own passkey server:

```typescript
providePasskey({ baseUrl: "/passkey" })
```

### Register (headless component)

```html
<open-passkey-register
  [userId]="'user-123'"
  [username]="'alice@example.com'"
  (registered)="onRegistered($event)"
  (error)="onError($event)"
>
  <button (click)="register()">Create Passkey</button>
</open-passkey-register>
```

### Login (headless component)

```html
<open-passkey-login
  (authenticated)="onAuthenticated($event)"
  (error)="onError($event)"
>
  <button (click)="login()">Sign in with Passkey</button>
</open-passkey-login>
```

### Service (programmatic)

```typescript
import { PasskeyService } from "@open-passkey/angular";

@Component({ ... })
export class MyComponent {
  private passkey = inject(PasskeyService);

  async register() {
    const result = await this.passkey.register("user-123", "alice@example.com");
  }

  async login() {
    const result = await this.passkey.authenticate();
  }

  async checkSession() {
    const session = await this.passkey.getSession();
  }

  async logout() {
    await this.passkey.logout();
  }
}
```

## Exports

| Export | Type | Description |
|--------|------|-------------|
| `providePasskey(config)` | Provider | App-level configuration |
| `PasskeyService` | Injectable | Programmatic passkey operations + session |
| `PasskeyRegisterComponent` | Component | Headless registration UI |
| `PasskeyLoginComponent` | Component | Headless login UI |

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK (peer dependency) |
| [@open-passkey/express](https://www.npmjs.com/package/@open-passkey/express) | Express server middleware |
| [@open-passkey/nestjs](https://www.npmjs.com/package/@open-passkey/nestjs) | NestJS server module |

## License

MIT
npm package: @open-passkey/astro
Description: Astro API route handlers for passkey/WebAuthn authentication
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/astro

Astro API route handlers for passkey (WebAuthn/FIDO2) authentication with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/astro
```

## Usage

```typescript
// src/lib/passkey.ts
import {
  createPasskeyEndpoints,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/astro";

export const passkey = createPasskeyEndpoints({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
});
```

```typescript
// src/pages/api/passkey/register/begin.ts
import { passkey } from "@/lib/passkey";
export const POST = passkey.registerBegin;
```

```typescript
// src/pages/api/passkey/register/finish.ts
import { passkey } from "@/lib/passkey";
export const POST = passkey.registerFinish;
```

```typescript
// src/pages/api/passkey/login/begin.ts
import { passkey } from "@/lib/passkey";
export const POST = passkey.loginBegin;
```

```typescript
// src/pages/api/passkey/login/finish.ts
import { passkey } from "@/lib/passkey";
export const POST = passkey.loginFinish;
```

### With sessions

```typescript
export const passkey = createPasskeyEndpoints({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000,
  },
});
```

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Framework-agnostic server logic |

## License

MIT
npm package: @open-passkey/authenticator
Description: Software WebAuthn authenticator for credential creation and assertion
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/authenticator

Software WebAuthn authenticator for testing and CI. Produces `attestationObject`, `clientDataJSON`, `authenticatorData`, and `signature` outputs -- the same structures a hardware authenticator would generate.

This is a **testing tool**, not a production library. Use it to write integration tests for your passkey server without needing a real browser or hardware authenticator.

## Install

```bash
npm install @open-passkey/authenticator --save-dev
```

## Usage

### Create a credential (registration)

```typescript
import { createCredential } from "@open-passkey/authenticator";

const result = await createCredential({
  rpId: "example.com",
  rpName: "My App",
  userId: "user-123",
  userName: "alice@example.com",
  challenge: challengeBytes, // Uint8Array
  origin: "https://example.com",
  alg: -7, // ES256
});

// result: {
//   credentialId, rawId, clientDataJSON, attestationObject,
//   publicKey, publicKeyCose, storedCredential
// }
```

### Get an assertion (authentication)

```typescript
import { getAssertion } from "@open-passkey/authenticator";

const result = await getAssertion({
  rpId: "example.com",
  challenge: challengeBytes,
  origin: "https://example.com",
  credential: storedCredential, // from createCredential
});

// result: {
//   credentialId, rawId, clientDataJSON,
//   authenticatorData, signature, userHandle
// }
```

## API

| Function | Description |
|----------|-------------|
| `createCredential(input)` | Simulates `navigator.credentials.create()` |
| `getAssertion(input)` | Simulates `navigator.credentials.get()` |

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/core](https://www.npmjs.com/package/@open-passkey/core) | Core protocol verification (verify what this generates) |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Server handler logic |

## License

MIT
npm package: @open-passkey/express
Description: Express.js passkey/WebAuthn server middleware
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/express

Express.js passkey (WebAuthn/FIDO2) authentication middleware with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/express
```

## Usage

```typescript
import express from "express";
import {
  createPasskeyRouter,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/express";

const app = express();
app.use(express.json());

app.use("/passkey", createPasskeyRouter({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
}));

app.listen(3000);
```

### With sessions

```typescript
app.use("/passkey", createPasskeyRouter({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000,
  },
}));
```

## Routes

| Method | Path | Description |
|--------|------|-------------|
| POST | `/register/begin` | Start registration ceremony |
| POST | `/register/finish` | Complete registration |
| POST | `/login/begin` | Start authentication ceremony |
| POST | `/login/finish` | Complete authentication |
| GET | `/session` | Validate session (when sessions enabled) |
| POST | `/logout` | Clear session (when sessions enabled) |

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |
| [@open-passkey/react](https://www.npmjs.com/package/@open-passkey/react) | React hooks |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Framework-agnostic server logic |

## License

MIT
npm package: @open-passkey/fastify
Description: Fastify passkey/WebAuthn server plugin
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/fastify

Fastify passkey (WebAuthn/FIDO2) authentication plugin with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/fastify
```

## Usage

```typescript
import Fastify from "fastify";
import {
  passkeyPlugin,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/fastify";

const app = Fastify();

app.register(passkeyPlugin, {
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
});

app.listen({ port: 3000 });
```

### With sessions

```typescript
app.register(passkeyPlugin, {
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000,
  },
});
```

## Routes

| Method | Path | Description |
|--------|------|-------------|
| POST | `/register/begin` | Start registration ceremony |
| POST | `/register/finish` | Complete registration |
| POST | `/login/begin` | Start authentication ceremony |
| POST | `/login/finish` | Complete authentication |
| GET | `/session` | Validate session (when sessions enabled) |
| POST | `/logout` | Clear session (when sessions enabled) |

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Framework-agnostic server logic |

## License

MIT
npm package: @open-passkey/hono
Description: Hono passkey/WebAuthn server middleware
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/hono

Hono passkey (WebAuthn/FIDO2) authentication middleware with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/hono
```

## Usage

```typescript
import { Hono } from "hono";
import {
  createPasskeyApp,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/hono";

const app = new Hono();

const passkey = createPasskeyApp({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
});

app.route("/passkey", passkey);

export default app;
```

### With sessions

```typescript
const passkey = createPasskeyApp({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000,
  },
});
```

## Routes

| Method | Path | Description |
|--------|------|-------------|
| POST | `/register/begin` | Start registration ceremony |
| POST | `/register/finish` | Complete registration |
| POST | `/login/begin` | Start authentication ceremony |
| POST | `/login/finish` | Complete authentication |
| GET | `/session` | Validate session (when sessions enabled) |
| POST | `/logout` | Clear session (when sessions enabled) |

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Framework-agnostic server logic |

## License

MIT
npm package: @open-passkey/nestjs
Description: NestJS passkey/WebAuthn server module
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/nestjs

NestJS passkey (WebAuthn/FIDO2) authentication module with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/nestjs
```

## Usage

```typescript
import { Module } from "@nestjs/common";
import {
  PasskeyModule,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/nestjs";

@Module({
  imports: [
    PasskeyModule.register({
      rpId: "example.com",
      rpName: "My App",
      origin: "https://example.com",
      challengeStore: new MemoryChallengeStore(),
      credentialStore: new MemoryCredentialStore(),
    }),
  ],
})
export class AppModule {}
```

### With sessions

```typescript
PasskeyModule.register({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000,
  },
})
```

## Routes

The module registers the following routes via `PasskeyController`:

| Method | Path | Description |
|--------|------|-------------|
| POST | `/register/begin` | Start registration ceremony |
| POST | `/register/finish` | Complete registration |
| POST | `/login/begin` | Start authentication ceremony |
| POST | `/login/finish` | Complete authentication |
| GET | `/session` | Validate session (when sessions enabled) |
| POST | `/logout` | Clear session (when sessions enabled) |

## Exports

- `PasskeyModule` -- NestJS dynamic module
- `PasskeyController` -- route controller
- `PasskeyService` -- injectable service wrapping `Passkey`

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Framework-agnostic server logic |

## License

MIT
npm package: @open-passkey/nextjs
Description: Next.js App Router passkey/WebAuthn server handlers
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/nextjs

Next.js App Router passkey (WebAuthn/FIDO2) authentication handlers with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/nextjs
```

## Usage

```typescript
// lib/passkey.ts
import {
  createPasskeyHandlers,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/nextjs";

export const passkey = createPasskeyHandlers({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
});
```

```typescript
// app/api/passkey/register/begin/route.ts
import { passkey } from "@/lib/passkey";
export const POST = passkey.registerBegin;
```

```typescript
// app/api/passkey/register/finish/route.ts
import { passkey } from "@/lib/passkey";
export const POST = passkey.registerFinish;
```

```typescript
// app/api/passkey/login/begin/route.ts
import { passkey } from "@/lib/passkey";
export const POST = passkey.loginBegin;
```

```typescript
// app/api/passkey/login/finish/route.ts
import { passkey } from "@/lib/passkey";
export const POST = passkey.loginFinish;
```

```typescript
// app/api/passkey/session/route.ts
import { passkey } from "@/lib/passkey";
export const GET = passkey.session;
```

```typescript
// app/api/passkey/logout/route.ts
import { passkey } from "@/lib/passkey";
export const POST = passkey.logout;
```

### With sessions

```typescript
export const passkey = createPasskeyHandlers({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000,
  },
});
```

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |
| [@open-passkey/react](https://www.npmjs.com/package/@open-passkey/react) | React hooks |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Framework-agnostic server logic |

## License

MIT
npm package: @open-passkey/nuxt
Description: Nuxt 3 Nitro passkey/WebAuthn server event handlers
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/nuxt

Nuxt 3 (Nitro) passkey (WebAuthn/FIDO2) authentication event handlers with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/nuxt
```

## Usage

```typescript
// server/utils/passkey.ts
import {
  createPasskeyHandlers,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/nuxt";

export const passkey = createPasskeyHandlers({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
});
```

```typescript
// server/api/passkey/register/begin.post.ts
import { passkey } from "~/server/utils/passkey";
export default defineEventHandler(passkey.registerBegin);
```

```typescript
// server/api/passkey/register/finish.post.ts
import { passkey } from "~/server/utils/passkey";
export default defineEventHandler(passkey.registerFinish);
```

```typescript
// server/api/passkey/login/begin.post.ts
import { passkey } from "~/server/utils/passkey";
export default defineEventHandler(passkey.loginBegin);
```

```typescript
// server/api/passkey/login/finish.post.ts
import { passkey } from "~/server/utils/passkey";
export default defineEventHandler(passkey.loginFinish);
```

### With sessions

```typescript
export const passkey = createPasskeyHandlers({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000,
  },
});
```

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |
| [@open-passkey/vue](https://www.npmjs.com/package/@open-passkey/vue) | Vue 3 composables |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Framework-agnostic server logic |

## License

MIT
npm package: @open-passkey/react
Description: React hooks for passkey (WebAuthn/FIDO2) authentication
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/react

React hooks for passkey (WebAuthn/FIDO2) authentication with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/react @open-passkey/sdk
```

## Quick Start

Add passkeys to your React app **without running your own backend**. [Locke Gateway](https://gateway.locke.id) is a free hosted passkey server:

```tsx
import { PasskeyProvider } from "@open-passkey/react";

function App() {
  return (
    <PasskeyProvider provider="locke-gateway" rpId="example.com">
      <MyApp />
    </PasskeyProvider>
  );
}
```

### Self-hosted

If you're running your own passkey server:

```tsx
<PasskeyProvider baseUrl="/passkey">
  <MyApp />
</PasskeyProvider>
```
```

### Register

```tsx
import { usePasskeyRegister } from "@open-passkey/react";

function RegisterButton() {
  const { register, status, error } = usePasskeyRegister();

  return (
    <div>
      <button
        onClick={() => register("user-123", "alice@example.com")}
        disabled={status === "pending"}
      >
        {status === "pending" ? "Creating passkey..." : "Create Passkey"}
      </button>
      {status === "error" && <p>{error?.message}</p>}
    </div>
  );
}
```

### Login

```tsx
import { usePasskeyLogin } from "@open-passkey/react";

function LoginButton() {
  const { authenticate, status, result, error } = usePasskeyLogin();

  return (
    <div>
      <button
        onClick={() => authenticate()}
        disabled={status === "pending"}
      >
        {status === "pending" ? "Signing in..." : "Sign in with Passkey"}
      </button>
      {status === "success" && <p>Welcome, {result?.userId}</p>}
      {status === "error" && <p>{error?.message}</p>}
    </div>
  );
}
```

### Session

```tsx
import { usePasskeySession } from "@open-passkey/react";
import { useEffect } from "react";

function Dashboard() {
  const { session, loading, checkSession, logout } = usePasskeySession();

  useEffect(() => { checkSession(); }, []);

  if (loading) return <p>Loading...</p>;
  if (!session) return <p>Not logged in</p>;

  return (
    <div>
      <p>Logged in as {session.userId}</p>
      <button onClick={logout}>Logout</button>
    </div>
  );
}
```

## Hooks

| Hook | Returns | Description |
|------|---------|-------------|
| `usePasskeyRegister()` | `{ register, status, result, error }` | Registration ceremony |
| `usePasskeyLogin()` | `{ authenticate, status, result, error }` | Authentication ceremony |
| `usePasskeySession()` | `{ session, loading, checkSession, logout }` | Session management |

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK (peer dependency) |
| [@open-passkey/nextjs](https://www.npmjs.com/package/@open-passkey/nextjs) | Next.js server handlers |
| [@open-passkey/express](https://www.npmjs.com/package/@open-passkey/express) | Express server middleware |

## License

MIT
npm package: @open-passkey/remix
Description: Remix action handlers for passkey/WebAuthn authentication
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/remix

Remix action handlers for passkey (WebAuthn/FIDO2) authentication with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/remix
```

## Usage

```typescript
// app/lib/passkey.server.ts
import {
  createPasskeyActions,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/remix";

export const passkey = createPasskeyActions({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
});
```

```typescript
// app/routes/passkey.register.begin.ts
import { passkey } from "~/lib/passkey.server";
export const action = passkey.registerBegin;
```

```typescript
// app/routes/passkey.register.finish.ts
import { passkey } from "~/lib/passkey.server";
export const action = passkey.registerFinish;
```

```typescript
// app/routes/passkey.login.begin.ts
import { passkey } from "~/lib/passkey.server";
export const action = passkey.loginBegin;
```

```typescript
// app/routes/passkey.login.finish.ts
import { passkey } from "~/lib/passkey.server";
export const action = passkey.loginFinish;
```

### With sessions

```typescript
export const passkey = createPasskeyActions({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000,
  },
});
```

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |
| [@open-passkey/react](https://www.npmjs.com/package/@open-passkey/react) | React hooks |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Framework-agnostic server logic |

## License

MIT
npm package: @open-passkey/server
Description: Framework-agnostic WebAuthn server handler logic
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/server

Framework-agnostic WebAuthn server handler logic with post-quantum cryptography support.

This package contains the shared `Passkey` class, credential/challenge stores, session management, and all ceremony orchestration. Framework-specific packages (Express, Fastify, Next.js, etc.) are thin wrappers around this. Use this directly if you need full control or are integrating with an unsupported framework.

## Install

```bash
npm install @open-passkey/server
```

## Usage

```typescript
import {
  Passkey,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/server";

const passkey = new Passkey({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
});

// Registration ceremony
const regOptions = await passkey.beginRegistration({ userId, username });
const regResult = await passkey.finishRegistration({ userId, credential });

// Authentication ceremony
const authOptions = await passkey.beginAuthentication({ userId });
const authResult = await passkey.finishAuthentication({ userId, credential });
```

### With sessions

```typescript
const passkey = new Passkey({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000, // 24h in ms
  },
});
```

Session tokens are HMAC-SHA256 signed, stateless cookies. The `finishAuthentication` result will include a `sessionToken` string when sessions are configured.

### Custom stores

Implement `ChallengeStore` and `CredentialStore` interfaces for production use (e.g., backed by a database):

```typescript
import type { ChallengeStore, CredentialStore } from "@open-passkey/server";
```

## Supported Algorithms

| Algorithm | COSE alg | Notes |
|-----------|----------|-------|
| ES256 (ECDSA P-256) | -7 | Classical, all browsers |
| ML-DSA-65 (Dilithium3) | -49 | Post-quantum, FIPS 204 |
| ML-DSA-65-ES256 (composite) | -52 | Hybrid PQ |

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/core](https://www.npmjs.com/package/@open-passkey/core) | Core protocol verification |
| [@open-passkey/express](https://www.npmjs.com/package/@open-passkey/express) | Express middleware |
| [@open-passkey/fastify](https://www.npmjs.com/package/@open-passkey/fastify) | Fastify plugin |
| [@open-passkey/hono](https://www.npmjs.com/package/@open-passkey/hono) | Hono middleware |
| [@open-passkey/nextjs](https://www.npmjs.com/package/@open-passkey/nextjs) | Next.js handlers |
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |

## License

MIT
npm package: @open-passkey/solid
Description: SolidJS primitives for passkey (WebAuthn/FIDO2) authentication
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/solid

SolidJS primitives for passkey (WebAuthn/FIDO2) authentication with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/solid @open-passkey/sdk
```

## Quick Start

Add passkeys to your SolidJS app **without running your own backend**. [Locke Gateway](https://gateway.locke.id) is a free hosted passkey server:

```tsx
import { PasskeyProvider } from "@open-passkey/solid";

function App() {
  return (
    <PasskeyProvider provider="locke-gateway" rpId="example.com">
      <MyApp />
    </PasskeyProvider>
  );
}
```

### Self-hosted

If you're running your own passkey server:

```tsx
<PasskeyProvider baseUrl="/passkey">
  <MyApp />
</PasskeyProvider>
```
```

### Register

```tsx
import { createPasskeyRegister } from "@open-passkey/solid";

function RegisterButton() {
  const { register, status, error } = createPasskeyRegister();

  return (
    <div>
      <button
        onClick={() => register("user-123", "alice@example.com")}
        disabled={status() === "pending"}
      >
        {status() === "pending" ? "Creating passkey..." : "Create Passkey"}
      </button>
      {status() === "error" && <p>{error()?.message}</p>}
    </div>
  );
}
```

### Login

```tsx
import { createPasskeyLogin } from "@open-passkey/solid";

function LoginButton() {
  const { authenticate, status, result, error } = createPasskeyLogin();

  return (
    <div>
      <button
        onClick={() => authenticate()}
        disabled={status() === "pending"}
      >
        {status() === "pending" ? "Signing in..." : "Sign in with Passkey"}
      </button>
      {status() === "success" && <p>Welcome, {result()?.userId}</p>}
    </div>
  );
}
```

### Session

```tsx
import { createPasskeySession } from "@open-passkey/solid";
import { onMount, Show } from "solid-js";

function Dashboard() {
  const { session, loading, checkSession, logout } = createPasskeySession();

  onMount(() => checkSession());

  return (
    <Show when={!loading()} fallback={<p>Loading...</p>}>
      <Show when={session()} fallback={<p>Not logged in</p>}>
        <p>Logged in as {session()?.userId}</p>
        <button onClick={logout}>Logout</button>
      </Show>
    </Show>
  );
}
```

## Primitives

| Primitive | Returns | Description |
|-----------|---------|-------------|
| `createPasskeyRegister()` | `{ register, status, result, error }` | Registration ceremony |
| `createPasskeyLogin()` | `{ authenticate, status, result, error }` | Authentication ceremony |
| `createPasskeySession()` | `{ session, loading, checkSession, logout }` | Session management |

All return values (`status`, `result`, `error`, `session`, `loading`) are SolidJS signals (call as functions to read).

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK (peer dependency) |
| [@open-passkey/astro](https://www.npmjs.com/package/@open-passkey/astro) | Astro server handlers |

## License

MIT
npm package: @open-passkey/svelte
Description: Svelte stores for passkey (WebAuthn/FIDO2) authentication
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/svelte

Svelte stores for passkey (WebAuthn/FIDO2) authentication with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/svelte @open-passkey/sdk
```

## Quick Start

Add passkeys to your Svelte app **without running your own backend**. [Locke Gateway](https://gateway.locke.id) is a free hosted passkey server:

```typescript
import { createPasskeyClient } from "@open-passkey/svelte";

const { registerStore, loginStore, sessionStore } = createPasskeyClient({
  provider: "locke-gateway",
  rpId: "example.com",
});
```

### Self-hosted

If you're running your own passkey server:

```typescript
const { registerStore, loginStore, sessionStore } = createPasskeyClient({
  baseUrl: "/passkey",
});
```

### Register

```svelte
<script>
  import { registerStore } from "$lib/passkey";

  function handleRegister() {
    registerStore.register("user-123", "alice@example.com");
  }
</script>

<button
  on:click={handleRegister}
  disabled={$registerStore.status === "pending"}
>
  {$registerStore.status === "pending" ? "Creating passkey..." : "Create Passkey"}
</button>

{#if $registerStore.status === "error"}
  <p>{$registerStore.error?.message}</p>
{/if}
```

### Login

```svelte
<script>
  import { loginStore } from "$lib/passkey";
</script>

<button
  on:click={() => loginStore.authenticate()}
  disabled={$loginStore.status === "pending"}
>
  Sign in with Passkey
</button>

{#if $loginStore.status === "success"}
  <p>Welcome, {$loginStore.result?.userId}</p>
{/if}
```

### Session

```svelte
<script>
  import { onMount } from "svelte";
  import { sessionStore } from "$lib/passkey";

  onMount(() => sessionStore.checkSession());
</script>

{#if $sessionStore.loading}
  <p>Loading...</p>
{:else if $sessionStore.session}
  <p>Logged in as {$sessionStore.session.userId}</p>
  <button on:click={() => sessionStore.logout()}>Logout</button>
{:else}
  <p>Not logged in</p>
{/if}
```

## Stores

`createPasskeyClient(config)` returns:

| Store | Methods | State |
|-------|---------|-------|
| `registerStore` | `register(userId, username)` | `{ status, result, error }` |
| `loginStore` | `authenticate(userId?)` | `{ status, result, error }` |
| `sessionStore` | `checkSession()`, `logout()` | `{ session, loading }` |

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK (peer dependency) |
| [@open-passkey/sveltekit](https://www.npmjs.com/package/@open-passkey/sveltekit) | SvelteKit server handlers |

## License

MIT
npm package: @open-passkey/sveltekit
Description: SvelteKit passkey/WebAuthn server endpoint handlers
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/sveltekit

SvelteKit passkey (WebAuthn/FIDO2) authentication endpoint handlers with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/sveltekit
```

## Usage

```typescript
// src/lib/server/passkey.ts
import {
  createPasskeyHandlers,
  MemoryChallengeStore,
  MemoryCredentialStore,
} from "@open-passkey/sveltekit";

export const passkey = createPasskeyHandlers({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
});
```

```typescript
// src/routes/passkey/register/begin/+server.ts
import { passkey } from "$lib/server/passkey";
export const POST = passkey.registerBegin;
```

```typescript
// src/routes/passkey/register/finish/+server.ts
import { passkey } from "$lib/server/passkey";
export const POST = passkey.registerFinish;
```

```typescript
// src/routes/passkey/login/begin/+server.ts
import { passkey } from "$lib/server/passkey";
export const POST = passkey.loginBegin;
```

```typescript
// src/routes/passkey/login/finish/+server.ts
import { passkey } from "$lib/server/passkey";
export const POST = passkey.loginFinish;
```

### With sessions

```typescript
export const passkey = createPasskeyHandlers({
  rpId: "example.com",
  rpName: "My App",
  origin: "https://example.com",
  challengeStore: new MemoryChallengeStore(),
  credentialStore: new MemoryCredentialStore(),
  session: {
    secret: "your-32+-character-hmac-secret-here",
    duration: 86400000,
  },
});
```

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK |
| [@open-passkey/svelte](https://www.npmjs.com/package/@open-passkey/svelte) | Svelte stores |
| [@open-passkey/server](https://www.npmjs.com/package/@open-passkey/server) | Framework-agnostic server logic |

## License

MIT
npm package: @open-passkey/vue
Description: Vue 3 composables for passkey (WebAuthn/FIDO2) authentication
Author: Locke Identity Networks Inc.
Latest version: 0.1.2

# @open-passkey/vue

Vue 3 composables for passkey (WebAuthn/FIDO2) authentication with post-quantum cryptography support.

## Install

```bash
npm install @open-passkey/vue @open-passkey/sdk
```

## Quick Start

Add passkeys to your Vue app **without running your own backend**. [Locke Gateway](https://gateway.locke.id) is a free hosted passkey server:

```typescript
import { createApp } from "vue";
import { createPasskey } from "@open-passkey/vue";

const app = createApp(App);
app.use(createPasskey({ provider: "locke-gateway", rpId: "example.com" }));
app.mount("#app");
```

### Self-hosted

If you're running your own passkey server:

```typescript
app.use(createPasskey({ baseUrl: "/passkey" }));
```

### Register

```vue
<script setup>
import { usePasskeyRegister } from "@open-passkey/vue";

const { register, status, error } = usePasskeyRegister();
</script>

<template>
  <button
    @click="register('user-123', 'alice@example.com')"
    :disabled="status === 'pending'"
  >
    {{ status === "pending" ? "Creating passkey..." : "Create Passkey" }}
  </button>
  <p v-if="status === 'error'">{{ error?.message }}</p>
</template>
```

### Login

```vue
<script setup>
import { usePasskeyLogin } from "@open-passkey/vue";

const { authenticate, status, result, error } = usePasskeyLogin();
</script>

<template>
  <button @click="authenticate()" :disabled="status === 'pending'">
    Sign in with Passkey
  </button>
  <p v-if="status === 'success'">Welcome, {{ result?.userId }}</p>
</template>
```

### Session

```vue
<script setup>
import { onMounted } from "vue";
import { usePasskeySession } from "@open-passkey/vue";

const { session, loading, checkSession, logout } = usePasskeySession();
onMounted(() => checkSession());
</script>

<template>
  <p v-if="loading">Loading...</p>
  <div v-else-if="session">
    <p>Logged in as {{ session.userId }}</p>
    <button @click="logout">Logout</button>
  </div>
  <p v-else>Not logged in</p>
</template>
```

## Composables

| Composable | Returns | Description |
|------------|---------|-------------|
| `usePasskeyRegister()` | `{ register, status, result, error }` | Registration ceremony |
| `usePasskeyLogin()` | `{ authenticate, status, result, error }` | Authentication ceremony |
| `usePasskeySession()` | `{ session, loading, checkSession, logout }` | Session management |

## Related Packages

| Package | Description |
|---------|-------------|
| [@open-passkey/sdk](https://www.npmjs.com/package/@open-passkey/sdk) | Browser SDK (peer dependency) |
| [@open-passkey/nuxt](https://www.npmjs.com/package/@open-passkey/nuxt) | Nuxt 3 server handlers |

## License

MIT