commit b33fce53ddc381dba5266d9fc4895a5eed662b52 Author: Adam Lamers Date: Sat Mar 28 22:05:24 2026 -0400 initial commit diff --git a/.cursor/rules/spacetimedb-typescript.mdc b/.cursor/rules/spacetimedb-typescript.mdc new file mode 100644 index 0000000..22503fb --- /dev/null +++ b/.cursor/rules/spacetimedb-typescript.mdc @@ -0,0 +1,659 @@ +--- +description: "⛔ MANDATORY: Read this ENTIRE file before writing ANY SpacetimeDB TypeScript code. Contains critical SDK patterns and HALLUCINATED APIs to avoid." +globs: **/*.ts,**/*.tsx,**/*.js,**/*.jsx +alwaysApply: true +--- + +# SpacetimeDB TypeScript SDK + +## ⛔ HALLUCINATED APIs — DO NOT USE + +**These APIs DO NOT EXIST. LLMs frequently hallucinate them.** + +```typescript +// ❌ WRONG PACKAGE — does not exist +import { SpacetimeDBClient } from "@clockworklabs/spacetimedb-sdk"; + +// ❌ WRONG — these methods don't exist +SpacetimeDBClient.connect(...); +SpacetimeDBClient.call("reducer_name", [...]); +connection.call("reducer_name", [arg1, arg2]); + +// ❌ WRONG — positional reducer arguments +conn.reducers.doSomething("value"); // WRONG! + +// ❌ WRONG — static methods on generated types don't exist +User.filterByName('alice'); +Message.findById(123n); +tables.user.filter(u => u.name === 'alice'); // No .filter() on tables object! +``` + +### ✅ CORRECT PATTERNS: + +```typescript +// ✅ CORRECT IMPORTS +import { DbConnection, tables } from './module_bindings'; // Generated! +import { SpacetimeDBProvider, useTable, Identity } from 'spacetimedb/react'; + +// ✅ CORRECT REDUCER CALLS — object syntax, not positional! +conn.reducers.doSomething({ value: 'test' }); +conn.reducers.updateItem({ itemId: 1n, newValue: 42 }); + +// ✅ CORRECT DATA ACCESS — useTable returns [rows, isLoading] +const [items, isLoading] = useTable(tables.item); +``` + +### ⛔ DO NOT: +- **Invent hooks** like `useItems()`, `useData()` — use `useTable(tables.tableName)` +- **Import from fake packages** — only `spacetimedb`, `spacetimedb/react`, `./module_bindings` + +--- + +## 1) Common Mistakes Table + +### Server-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| Missing `package.json` | Create `package.json` | "could not detect language" | +| Missing `tsconfig.json` | Create `tsconfig.json` | "TsconfigNotFound" | +| Entrypoint not at `src/index.ts` | Use `src/index.ts` | Module won't bundle | +| `indexes` in COLUMNS (2nd arg) | `indexes` in OPTIONS (1st arg) | "reading 'tag'" error | +| Index without `algorithm` | `algorithm: 'btree'` | "reading 'tag'" error | +| `filter({ ownerId })` | `filter(ownerId)` | "does not exist in type 'Range'" | +| `.filter()` on unique column | `.find()` on unique column | TypeError | +| `insert({ ...without id })` | `insert({ id: 0n, ... })` | "Property 'id' is missing" | +| `const id = table.insert(...)` | `const row = table.insert(...)` | `.insert()` returns ROW, not ID | +| `.unique()` + explicit index | Just use `.unique()` | "name is used for multiple entities" | +| Index on `.primaryKey()` column | Don't — already indexed | "name is used for multiple entities" | +| Same index name in multiple tables | Prefix with table name | "name is used for multiple entities" | +| `.indexName.filter()` after removing index | Use `.iter()` + manual filter | "Cannot read properties of undefined" | +| Import spacetimedb from index.ts | Import from schema.ts | "Cannot access before initialization" | +| Multi-column index `.filter()` | **⚠️ BROKEN** — use single-column | PANIC or silent empty results | +| `JSON.stringify({ id: row.id })` | Convert BigInt first: `{ id: row.id.toString() }` | "Do not know how to serialize a BigInt" | +| `ScheduleAt.Time(timestamp)` | `ScheduleAt.time(timestamp)` (lowercase) | "ScheduleAt.Time is not a function" | +| `ctx.db.foo.myIndexName.filter()` | Use exact name: `ctx.db.foo.my_index_name.filter()` | "Cannot read properties of undefined" | +| `.iter()` in views | Use index lookups | Severe performance issues (re-evaluates on any change) | +| `ctx.db` in procedures | `ctx.withTx(tx => tx.db...)` | Procedures need explicit transactions | +| `ctx.myTable` in procedure tx | `tx.db.myTable` | Wrong context variable | + +### Client-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| `@spacetimedb/sdk` | `spacetimedb` | 404 / missing subpath | +| `conn.reducers.foo("val")` | `conn.reducers.foo({ param: "val" })` | Wrong reducer syntax | +| Inline `connectionBuilder` | `useMemo(() => ..., [])` | Reconnects every render | +| `const rows = useTable(table)` | `const [rows, isLoading] = useTable(table)` | Tuple destructuring | +| Optimistic UI updates | Let subscriptions drive state | Desync issues | +| `` | `connectionBuilder={...}` | Wrong prop name | + +--- + +## 2) Table Definition (CRITICAL) + +**`table()` takes TWO arguments: `table(OPTIONS, COLUMNS)`** + +```typescript +import { schema, table, t } from 'spacetimedb/server'; + +// ❌ WRONG — indexes in COLUMNS causes "reading 'tag'" error +export const Task = table({ name: 'task' }, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] // ❌ WRONG! +}); + +// ✅ RIGHT — indexes in OPTIONS (first argument) +export const Task = table({ + name: 'task', + public: true, + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + title: t.string(), + createdAt: t.timestamp(), +}); +``` + +### Column types +```typescript +t.identity() // User identity (primary key for per-user tables) +t.u64() // Unsigned 64-bit integer (use for IDs) +t.string() // Text +t.bool() // Boolean +t.timestamp() // Timestamp (use ctx.timestamp for current time) +t.scheduleAt() // For scheduled tables only + +// Product types (nested objects) — use t.object, NOT t.struct +const Point = t.object('Point', { x: t.i32(), y: t.i32() }); + +// Sum types (tagged unions) — use t.enum, NOT t.sum +const Shape = t.enum('Shape', { circle: t.i32(), rectangle: Point }); +// Values use { tag: 'circle', value: 10 } or { tag: 'rectangle', value: { x: 1, y: 2 } } + +// Modifiers +t.string().optional() // Nullable +t.u64().primaryKey() // Primary key +t.u64().primaryKey().autoInc() // Auto-increment primary key +``` + +> ⚠️ **BIGINT SYNTAX:** All `u64`, `i64`, and ID fields use JavaScript BigInt. +> - Literals: `0n`, `1n`, `100n` (NOT `0`, `1`, `100`) +> - Comparisons: `row.id === 5n` (NOT `row.id === 5`) +> - Arithmetic: `row.count + 1n` (NOT `row.count + 1`) + +### Auto-increment placeholder +```typescript +// ✅ MUST provide 0n placeholder for auto-inc fields +ctx.db.task.insert({ id: 0n, ownerId: ctx.sender, title: 'New', createdAt: ctx.timestamp }); +``` + +### Insert returns ROW, not ID +```typescript +// ❌ WRONG +const id = ctx.db.task.insert({ ... }); + +// ✅ RIGHT +const row = ctx.db.task.insert({ ... }); +const newId = row.id; // Extract .id from returned row +``` + +### Schema export (CRITICAL) +```typescript +// At end of schema.ts — schema() takes exactly ONE argument: an object +const spacetimedb = schema({ table1, table2, table3 }); +export default spacetimedb; + +// ❌ WRONG — never pass tables directly or as multiple args +schema(myTable); // WRONG! +schema(t1, t2, t3); // WRONG! +``` + +--- + +## 3) Index Access + +### TypeScript Query Patterns + +```typescript +// 1. PRIMARY KEY — use .pkColumn.find() +const user = ctx.db.user.identity.find(ctx.sender); +const msg = ctx.db.message.id.find(messageId); + +// 2. EXPLICIT INDEX — use .indexName.filter(value) +const msgs = [...ctx.db.message.message_room_id.filter(roomId)]; + +// 3. NO INDEX — use .iter() + manual filter +for (const m of ctx.db.roomMember.iter()) { + if (m.roomId === roomId) { /* ... */ } +} +``` + +### Index Definition Syntax + +```typescript +// In table OPTIONS (first argument), not columns +export const Message = table({ + name: 'message', + public: true, + indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + roomId: t.u64(), + // ... +}); +``` + +### Naming conventions + +**Table names — automatic transformation:** +- Schema: `table({ name: 'my_messages' })` +- Access: `ctx.db.myMessages` (automatic snake_case → camelCase) + +**Index names — NO transformation, use EXACTLY as defined:** +```typescript +// Schema definition +indexes: [{ name: 'canvas_member_canvas_id', algorithm: 'btree', columns: ['canvasId'] }] + +// ❌ WRONG — don't assume camelCase transformation +ctx.db.canvasMember.canvasMember_canvas_id.filter(...) // WRONG! +ctx.db.canvasMember.canvasMemberCanvasId.filter(...) // WRONG! + +// ✅ RIGHT — use exact name from schema +ctx.db.canvasMember.canvas_member_canvas_id.filter(...) +``` + +> ⚠️ **Index names are used VERBATIM** — pick a convention (snake_case or camelCase) and stick with it. + +**Index naming pattern — use `{tableName}_{columnName}`:** +```typescript +// ✅ GOOD — unique names across entire module +indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +indexes: [{ name: 'reaction_message_id', algorithm: 'btree', columns: ['messageId'] }] + +// ❌ BAD — will collide if multiple tables use same index name +indexes: [{ name: 'by_owner', ... }] // in Task table +indexes: [{ name: 'by_owner', ... }] // in Note table — CONFLICT! +``` + +**Client-side table names:** +- Check generated `module_bindings/index.ts` for exact export names +- Usage: `useTable(tables.MyMessages)` or `tables.myMessages` (varies by SDK version) + +### Filter vs Find +```typescript +// Filter takes VALUE directly, not object — returns iterator +const rows = [...ctx.db.task.by_owner.filter(ownerId)]; + +// Unique columns use .find() — returns single row or undefined +const row = ctx.db.player.identity.find(ctx.sender); +``` + +### ⚠️ Multi-column indexes are BROKEN +```typescript +// ❌ DON'T — causes PANIC +ctx.db.scores.by_player_level.filter(playerId); + +// ✅ DO — use single-column index + manual filter +for (const row of ctx.db.scores.by_player.filter(playerId)) { + if (row.level === targetLevel) { /* ... */ } +} +``` + +--- + +## 4) Reducers + +### Definition syntax (CRITICAL) +**Reducer name comes from the export — NOT from a string argument.** Use `reducer(params, fn)` or `reducer(fn)`. + +```typescript +import spacetimedb from './schema'; +import { t, SenderError } from 'spacetimedb/server'; + +// ✅ CORRECT — export const name = spacetimedb.reducer(params, fn) +export const reducer_name = spacetimedb.reducer({ param1: t.string(), param2: t.u64() }, (ctx, { param1, param2 }) => { + // Validation + if (!param1) throw new SenderError('param1 required'); + + // Access tables via ctx.db + const row = ctx.db.myTable.primaryKey.find(param2); + + // Mutations + ctx.db.myTable.insert({ ... }); + ctx.db.myTable.primaryKey.update({ ...row, newField: value }); + ctx.db.myTable.primaryKey.delete(param2); +}); + +// No params: export const init = spacetimedb.reducer((ctx) => { ... }); +``` + +```typescript +// ❌ WRONG — reducer('name', params, fn) does NOT exist +spacetimedb.reducer('reducer_name', { param1: t.string() }, (ctx, { param1 }) => { ... }); +``` + +### Update pattern (CRITICAL) +```typescript +// ✅ CORRECT — spread existing row, override specific fields +const existing = ctx.db.task.id.find(taskId); +if (!existing) throw new SenderError('Task not found'); +ctx.db.task.id.update({ ...existing, title: newTitle, updatedAt: ctx.timestamp }); + +// ❌ WRONG — partial update nulls out other fields! +ctx.db.task.id.update({ id: taskId, title: newTitle }); +``` + +### Delete pattern +```typescript +// Delete by primary key VALUE (not row object) +ctx.db.task.id.delete(taskId); // taskId is the u64 value +ctx.db.player.identity.delete(ctx.sender); // delete by identity +``` + +### Lifecycle hooks +```typescript +spacetimedb.clientConnected((ctx) => { + // ctx.sender is the connecting identity + // Create/update user record, set online status, etc. +}); + +spacetimedb.clientDisconnected((ctx) => { + // Clean up: set offline status, remove ephemeral data, etc. +}); +``` + +### Snake_case to camelCase conversion +- Server: `export const do_something = spacetimedb.reducer(...)` — name from export +- Client: `conn.reducers.doSomething({ ... })` + +### Object syntax required +```typescript +// ❌ WRONG - positional +conn.reducers.doSomething('value'); + +// ✅ RIGHT - object +conn.reducers.doSomething({ param: 'value' }); +``` + +--- + +## 5) Scheduled Tables + +```typescript +// 1. Define table first (scheduled: () => reducer — pass the exported reducer) +export const CleanupJob = table({ + name: 'cleanup_job', + scheduled: () => run_cleanup // reducer defined below +}, { + scheduledId: t.u64().primaryKey().autoInc(), + scheduledAt: t.scheduleAt(), + targetId: t.u64(), // Your custom data +}); + +// 2. Define scheduled reducer (receives full row as arg) +export const run_cleanup = spacetimedb.reducer({ arg: CleanupJob.rowType }, (ctx, { arg }) => { + // arg.scheduledId, arg.targetId available + // Row is auto-deleted after reducer completes +}); + +// Schedule a job +import { ScheduleAt } from 'spacetimedb'; +const futureTime = ctx.timestamp.microsSinceUnixEpoch + 60_000_000n; // 60 seconds +ctx.db.cleanupJob.insert({ + scheduledId: 0n, + scheduledAt: ScheduleAt.time(futureTime), + targetId: someId +}); + +// Cancel a job by deleting the row +ctx.db.cleanupJob.scheduledId.delete(jobId); +``` + +--- + +## 6) Timestamps + +### Server-side +```typescript +import { Timestamp, ScheduleAt } from 'spacetimedb'; + +// Current time +ctx.db.item.insert({ id: 0n, createdAt: ctx.timestamp }); + +// Future time (add microseconds) +const future = ctx.timestamp.microsSinceUnixEpoch + 300_000_000n; // 5 minutes +``` + +### Client-side (CRITICAL) +**Timestamps are objects, not numbers:** +```typescript +// ❌ WRONG +const date = new Date(row.createdAt); +const date = new Date(Number(row.createdAt / 1000n)); + +// ✅ RIGHT +const date = new Date(Number(row.createdAt.microsSinceUnixEpoch / 1000n)); +``` + +### ScheduleAt on client +```typescript +// ScheduleAt is a tagged union +if (scheduleAt.tag === 'Time') { + const date = new Date(Number(scheduleAt.value.microsSinceUnixEpoch / 1000n)); +} +``` + +--- + +## 7) Data Visibility & Subscriptions + +**`public: true` exposes ALL rows to ALL clients.** + +| Scenario | Pattern | +|----------|---------| +| Everyone sees all rows | `public: true` | +| Users see only their data | Private table + filtered subscription | + +### Subscription patterns (client-side) +```typescript +// Subscribe to ALL public tables (simplest) +conn.subscriptionBuilder().subscribeToAll(); + +// Subscribe to specific tables with SQL +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM message', + 'SELECT * FROM room WHERE is_public = true', +]); + +// Handle subscription lifecycle +conn.subscriptionBuilder() + .onApplied(() => console.log('Initial data loaded')) + .onError((e) => console.error('Subscription failed:', e)) + .subscribeToAll(); +``` + +### Private table + view pattern (RECOMMENDED) + +**Views are the recommended approach** for controlling data visibility. They provide: +- Server-side filtering (reduces network traffic) +- Real-time updates when underlying data changes +- Full control over what data clients can access + +> ⚠️ **Do NOT use Row Level Security (RLS)** — it is deprecated. + +> ⚠️ **CRITICAL:** Procedural views (views that compute results in code) can ONLY access data via index lookups, NOT `.iter()`. +> If you need a view that scans/filters across many rows (including the entire table), return a **query** built with the query builder (`ctx.from...`). + +```typescript +// Private table with index on ownerId +export const PrivateData = table( + { name: 'private_data', + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] + }, + { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + secret: t.string() + } +); + +// ❌ BAD — .iter() causes performance issues (re-evaluates on ANY row change) +spacetimedb.view( + { name: 'my_data_slow', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.iter()] // Works but VERY slow at scale +); + +// ✅ GOOD — index lookup enables targeted invalidation +spacetimedb.view( + { name: 'my_data', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.by_owner.filter(ctx.sender)] +); +``` + +### Query builder view pattern (can scan) + +```typescript +// Query-builder views return a query; the SQL engine maintains the result incrementally. +// This can scan the whole table if needed (e.g. leaderboard-style queries). +spacetimedb.anonymousView( + { name: 'top_players', public: true }, + t.array(Player.rowType), + (ctx) => + ctx.from.player + .where(p => p.score.gt(1000)) +); +``` + +### ViewContext vs AnonymousViewContext +```typescript +// ViewContext — has ctx.sender, result varies per user (computed per-subscriber) +spacetimedb.view({ name: 'my_items', public: true }, t.array(Item.rowType), (ctx) => { + return [...ctx.db.item.by_owner.filter(ctx.sender)]; +}); + +// AnonymousViewContext — no ctx.sender, same result for everyone (shared, better perf) +spacetimedb.anonymousView({ name: 'leaderboard', public: true }, t.array(LeaderboardRow), (ctx) => { + return [...ctx.db.player.by_score.filter(/* top scores */)]; +}); +``` + +**Views require explicit subscription:** +```typescript +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM public_table', + 'SELECT * FROM my_data', // Views need explicit SQL! +]); +``` + +--- + +## 8) React Integration + +### Key patterns +```typescript +// Memoize connectionBuilder to prevent reconnects on re-render +const builder = useMemo(() => + DbConnection.builder() + .withUri(SPACETIMEDB_URI) + .withDatabaseName(MODULE_NAME) + .withToken(localStorage.getItem('auth_token') || undefined) + .onConnect(onConnect) + .onConnectError(onConnectError), + [] // Empty deps - only create once +); + +// useTable returns tuple [rows, isLoading] +const [rows, isLoading] = useTable(tables.myTable); + +// Compare identities using toHexString() +const isOwner = row.ownerId.toHexString() === myIdentity.toHexString(); +``` + +--- + +## 9) Procedures (Beta) + +**Procedures are for side effects (HTTP requests, etc.) that reducers can't do.** + +⚠️ Procedures are currently in beta. API may change. + +### Defining a procedure +**Procedure name comes from the export — NOT from a string argument.** Use `procedure(params, ret, fn)` or `procedure(ret, fn)`. + +```typescript +// ✅ CORRECT — export const name = spacetimedb.procedure(params, ret, fn) +export const fetch_external_data = spacetimedb.procedure( + { url: t.string() }, + t.string(), // return type + (ctx, { url }) => { + const response = ctx.http.fetch(url); + return response.text(); + } +); +``` + +### Database access in procedures + +⚠️ **CRITICAL: Procedures don't have `ctx.db`. Use `ctx.withTx()` for database access.** + +```typescript +spacetimedb.procedure({ url: t.string() }, t.unit(), (ctx, { url }) => { + // Fetch external data (outside transaction) + const response = ctx.http.fetch(url); + const data = response.text(); + + // ❌ WRONG — ctx.db doesn't exist in procedures + ctx.db.myTable.insert({ ... }); + + // ✅ RIGHT — use ctx.withTx() for database access + ctx.withTx(tx => { + tx.db.myTable.insert({ + id: 0n, + content: data, + fetchedAt: tx.timestamp, + fetchedBy: tx.sender, + }); + }); + + return {}; +}); +``` + +### Key differences from reducers +| Reducers | Procedures | +|----------|------------| +| `ctx.db` available directly | Must use `ctx.withTx(tx => tx.db...)` | +| Automatic transaction | Manual transaction management | +| No HTTP/network | `ctx.http.fetch()` available | +| No return values to caller | Can return data to caller | + +--- + +## 10) Project Structure + +### Server (`backend/spacetimedb/`) +``` +src/schema.ts → Tables, export spacetimedb +src/index.ts → Reducers, lifecycle, import schema +package.json → { "type": "module", "dependencies": { "spacetimedb": "^1.11.0" } } +tsconfig.json → Standard config +``` + +### Avoiding circular imports +``` +schema.ts → defines tables AND exports spacetimedb +index.ts → imports spacetimedb from ./schema, defines reducers +``` + +### Client (`client/`) +``` +src/module_bindings/ → Generated (spacetime generate) +src/main.tsx → Provider, connection setup +src/App.tsx → UI components +src/config.ts → MODULE_NAME, SPACETIMEDB_URI +``` + +--- + +## 11) Commands + +```bash +# Start local server +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear database and republish +spacetime publish --clear-database -y --module-path + +# Generate bindings +spacetime generate --lang typescript --out-dir /src/module_bindings --module-path + +# View logs +spacetime logs +``` + +--- + +## 12) Hard Requirements + +**TypeScript-specific:** + +1. **`schema({ table })`** — takes exactly one object; never `schema(table)` or `schema(t1, t2, t3)` +2. **Reducer/procedure names from exports** — `export const name = spacetimedb.reducer(params, fn)`; never `reducer('name', ...)` +3. **Reducer calls use object syntax** — `{ param: 'value' }` not positional args +4. **Import `DbConnection` from `./module_bindings`** — not from `spacetimedb` +5. **DO NOT edit generated bindings** — regenerate with `spacetime generate` +6. **Indexes go in OPTIONS (1st arg)** — not in COLUMNS (2nd arg) of `table()` +7. **Use BigInt for u64/i64 fields** — `0n`, `1n`, not `0`, `1` +8. **Reducers are transactional** — they do not return data +9. **Reducers must be deterministic** — no filesystem, network, timers, random +10. **Views should use index lookups** — `.iter()` causes severe performance issues +11. **Procedures need `ctx.withTx()`** — `ctx.db` doesn't exist in procedures +12. **Sum type values** — use `{ tag: 'variant', value: payload }` not `{ variant: payload }` diff --git a/.cursor/rules/spacetimedb.mdc b/.cursor/rules/spacetimedb.mdc new file mode 100644 index 0000000..31cb456 --- /dev/null +++ b/.cursor/rules/spacetimedb.mdc @@ -0,0 +1,116 @@ +--- +description: "⛔ MANDATORY: Core SpacetimeDB concepts (all languages)." +globs: **/*.ts,**/*.tsx,**/*.js,**/*.jsx,**/*.rs,**/*.cs +alwaysApply: true +--- +# SpacetimeDB Rules (All Languages) + +## Migrating from 1.0 to 2.0? + +**If you are migrating existing SpacetimeDB 1.0 code to 2.0, apply `spacetimedb-migration-2.0.mdc` first.** It documents breaking changes (reducer callbacks → event tables, `name`→`accessor`, `sender()` method, etc.) and should be considered before other rules. + +--- + +## Language-Specific Rules + +| Language | Rule File | +|----------|-----------| +| **TypeScript/React** | `spacetimedb-typescript.mdc` (MANDATORY) | +| **Rust** | `spacetimedb-rust.mdc` (MANDATORY) | +| **C#** | `spacetimedb-csharp.mdc` (MANDATORY) | +| **Migrating 1.0 → 2.0** | `spacetimedb-migration-2.0.mdc` | + +--- + +## Core Concepts + +1. **Reducers are transactional** — they do not return data to callers +2. **Reducers must be deterministic** — no filesystem, network, timers, or random +3. **Read data via tables/subscriptions** — not reducer return values +4. **Auto-increment IDs are not sequential** — gaps are normal, don't use for ordering +5. **`ctx.sender` is the authenticated principal** — never trust identity args + +--- + +## Feature Implementation Checklist + +When implementing a feature that spans backend and client: + +1. **Backend:** Define table(s) to store the data +2. **Backend:** Define reducer(s) to mutate the data +3. **Client:** Subscribe to the table(s) +4. **Client:** Call the reducer(s) from UI — **don't forget this step!** +5. **Client:** Render the data from the table(s) + +**Common mistake:** Building backend tables/reducers but forgetting to wire up the client to call them. + +--- + +## Index System + +SpacetimeDB automatically creates indexes for: +- Primary key columns +- Columns marked as unique + +You can add explicit indexes on non-unique columns for query performance. + +**Index names must be unique across your entire module (all tables).** If two tables have indexes with the same declared name → conflict error. + +**Schema ↔ Code coupling:** +- Your query code references indexes by name +- If you add/remove/rename an index in the schema, update all code that uses it +- Removing an index without updating queries causes runtime errors + +--- + +## Commands + +```bash +# Login to allow remote database deployment e.g. to maincloud +spacetime login + +# Start local SpacetimeDB +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear and republish +spacetime publish --clear-database -y --module-path + +# Generate client bindings +spacetime generate --lang --out-dir --module-path + +# View logs +spacetime logs +``` + +--- + +## Deployment + +- Maincloud is the spacetimedb hosted cloud and the default location for module publishing +- The default server marked by *** in `spacetime server list` should be used when publishing +- If the default server is maincloud you should publish to maincloud +- Publishing to maincloud is free of charge +- When publishing to maincloud the database dashboard will be at the url: https://spacetimedb.com/@/ +- The database owner can view utilization and performance metrics on the dashboard + +--- + +## Debugging Checklist + +1. Is SpacetimeDB server running? (`spacetime start`) +2. Is the module published? (`spacetime publish`) +3. Are client bindings generated? (`spacetime generate`) +4. Check server logs for errors (`spacetime logs `) +5. **Is the reducer actually being called from the client?** + +--- + +## Editing Behavior + +- Make the smallest change necessary +- Do NOT touch unrelated files, configs, or dependencies +- Do NOT invent new SpacetimeDB APIs — use only what exists in docs or this repo +- Do NOT add restrictions the prompt didn't ask for — if "users can do X", implement X for all users diff --git a/.env.local b/.env.local new file mode 100644 index 0000000..08915e6 --- /dev/null +++ b/.env.local @@ -0,0 +1,23 @@ +# Generic / backend +SPACETIMEDB_DB_NAME=my-spacetime-app-jdhdg +SPACETIMEDB_HOST=https://maincloud.spacetimedb.com + +# Vite +VITE_SPACETIMEDB_DB_NAME=my-spacetime-app-jdhdg +VITE_SPACETIMEDB_HOST=https://maincloud.spacetimedb.com + +# Next.js +NEXT_PUBLIC_SPACETIMEDB_DB_NAME=my-spacetime-app-jdhdg +NEXT_PUBLIC_SPACETIMEDB_HOST=https://maincloud.spacetimedb.com + +# Create React App +REACT_APP_SPACETIMEDB_DB_NAME=my-spacetime-app-jdhdg +REACT_APP_SPACETIMEDB_HOST=https://maincloud.spacetimedb.com + +# Expo +EXPO_PUBLIC_SPACETIMEDB_DB_NAME=my-spacetime-app-jdhdg +EXPO_PUBLIC_SPACETIMEDB_HOST=https://maincloud.spacetimedb.com + +# SvelteKit +PUBLIC_SPACETIMEDB_DB_NAME=my-spacetime-app-jdhdg +PUBLIC_SPACETIMEDB_HOST=https://maincloud.spacetimedb.com diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md new file mode 100644 index 0000000..c58f00b --- /dev/null +++ b/.github/copilot-instructions.md @@ -0,0 +1,766 @@ +# SpacetimeDB Rules (All Languages) + +## Migrating from 1.0 to 2.0? + +**If you are migrating existing SpacetimeDB 1.0 code to 2.0, apply `spacetimedb-migration-2.0.mdc` first.** It documents breaking changes (reducer callbacks → event tables, `name`→`accessor`, `sender()` method, etc.) and should be considered before other rules. + +--- + +## Language-Specific Rules + +| Language | Rule File | +|----------|-----------| +| **TypeScript/React** | `spacetimedb-typescript.mdc` (MANDATORY) | +| **Rust** | `spacetimedb-rust.mdc` (MANDATORY) | +| **C#** | `spacetimedb-csharp.mdc` (MANDATORY) | +| **Migrating 1.0 → 2.0** | `spacetimedb-migration-2.0.mdc` | + +--- + +## Core Concepts + +1. **Reducers are transactional** — they do not return data to callers +2. **Reducers must be deterministic** — no filesystem, network, timers, or random +3. **Read data via tables/subscriptions** — not reducer return values +4. **Auto-increment IDs are not sequential** — gaps are normal, don't use for ordering +5. **`ctx.sender` is the authenticated principal** — never trust identity args + +--- + +## Feature Implementation Checklist + +When implementing a feature that spans backend and client: + +1. **Backend:** Define table(s) to store the data +2. **Backend:** Define reducer(s) to mutate the data +3. **Client:** Subscribe to the table(s) +4. **Client:** Call the reducer(s) from UI — **don't forget this step!** +5. **Client:** Render the data from the table(s) + +**Common mistake:** Building backend tables/reducers but forgetting to wire up the client to call them. + +--- + +## Index System + +SpacetimeDB automatically creates indexes for: +- Primary key columns +- Columns marked as unique + +You can add explicit indexes on non-unique columns for query performance. + +**Index names must be unique across your entire module (all tables).** If two tables have indexes with the same declared name → conflict error. + +**Schema ↔ Code coupling:** +- Your query code references indexes by name +- If you add/remove/rename an index in the schema, update all code that uses it +- Removing an index without updating queries causes runtime errors + +--- + +## Commands + +```bash +# Login to allow remote database deployment e.g. to maincloud +spacetime login + +# Start local SpacetimeDB +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear and republish +spacetime publish --clear-database -y --module-path + +# Generate client bindings +spacetime generate --lang --out-dir --module-path + +# View logs +spacetime logs +``` + +--- + +## Deployment + +- Maincloud is the spacetimedb hosted cloud and the default location for module publishing +- The default server marked by *** in `spacetime server list` should be used when publishing +- If the default server is maincloud you should publish to maincloud +- Publishing to maincloud is free of charge +- When publishing to maincloud the database dashboard will be at the url: https://spacetimedb.com/@/ +- The database owner can view utilization and performance metrics on the dashboard + +--- + +## Debugging Checklist + +1. Is SpacetimeDB server running? (`spacetime start`) +2. Is the module published? (`spacetime publish`) +3. Are client bindings generated? (`spacetime generate`) +4. Check server logs for errors (`spacetime logs `) +5. **Is the reducer actually being called from the client?** + +--- + +## Editing Behavior + +- Make the smallest change necessary +- Do NOT touch unrelated files, configs, or dependencies +- Do NOT invent new SpacetimeDB APIs — use only what exists in docs or this repo +- Do NOT add restrictions the prompt didn't ask for — if "users can do X", implement X for all users + + +# SpacetimeDB TypeScript SDK + +## ⛔ HALLUCINATED APIs — DO NOT USE + +**These APIs DO NOT EXIST. LLMs frequently hallucinate them.** + +```typescript +// ❌ WRONG PACKAGE — does not exist +import { SpacetimeDBClient } from "@clockworklabs/spacetimedb-sdk"; + +// ❌ WRONG — these methods don't exist +SpacetimeDBClient.connect(...); +SpacetimeDBClient.call("reducer_name", [...]); +connection.call("reducer_name", [arg1, arg2]); + +// ❌ WRONG — positional reducer arguments +conn.reducers.doSomething("value"); // WRONG! + +// ❌ WRONG — static methods on generated types don't exist +User.filterByName('alice'); +Message.findById(123n); +tables.user.filter(u => u.name === 'alice'); // No .filter() on tables object! +``` + +### ✅ CORRECT PATTERNS: + +```typescript +// ✅ CORRECT IMPORTS +import { DbConnection, tables } from './module_bindings'; // Generated! +import { SpacetimeDBProvider, useTable, Identity } from 'spacetimedb/react'; + +// ✅ CORRECT REDUCER CALLS — object syntax, not positional! +conn.reducers.doSomething({ value: 'test' }); +conn.reducers.updateItem({ itemId: 1n, newValue: 42 }); + +// ✅ CORRECT DATA ACCESS — useTable returns [rows, isLoading] +const [items, isLoading] = useTable(tables.item); +``` + +### ⛔ DO NOT: +- **Invent hooks** like `useItems()`, `useData()` — use `useTable(tables.tableName)` +- **Import from fake packages** — only `spacetimedb`, `spacetimedb/react`, `./module_bindings` + +--- + +## 1) Common Mistakes Table + +### Server-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| Missing `package.json` | Create `package.json` | "could not detect language" | +| Missing `tsconfig.json` | Create `tsconfig.json` | "TsconfigNotFound" | +| Entrypoint not at `src/index.ts` | Use `src/index.ts` | Module won't bundle | +| `indexes` in COLUMNS (2nd arg) | `indexes` in OPTIONS (1st arg) | "reading 'tag'" error | +| Index without `algorithm` | `algorithm: 'btree'` | "reading 'tag'" error | +| `filter({ ownerId })` | `filter(ownerId)` | "does not exist in type 'Range'" | +| `.filter()` on unique column | `.find()` on unique column | TypeError | +| `insert({ ...without id })` | `insert({ id: 0n, ... })` | "Property 'id' is missing" | +| `const id = table.insert(...)` | `const row = table.insert(...)` | `.insert()` returns ROW, not ID | +| `.unique()` + explicit index | Just use `.unique()` | "name is used for multiple entities" | +| Index on `.primaryKey()` column | Don't — already indexed | "name is used for multiple entities" | +| Same index name in multiple tables | Prefix with table name | "name is used for multiple entities" | +| `.indexName.filter()` after removing index | Use `.iter()` + manual filter | "Cannot read properties of undefined" | +| Import spacetimedb from index.ts | Import from schema.ts | "Cannot access before initialization" | +| Multi-column index `.filter()` | **⚠️ BROKEN** — use single-column | PANIC or silent empty results | +| `JSON.stringify({ id: row.id })` | Convert BigInt first: `{ id: row.id.toString() }` | "Do not know how to serialize a BigInt" | +| `ScheduleAt.Time(timestamp)` | `ScheduleAt.time(timestamp)` (lowercase) | "ScheduleAt.Time is not a function" | +| `ctx.db.foo.myIndexName.filter()` | Use exact name: `ctx.db.foo.my_index_name.filter()` | "Cannot read properties of undefined" | +| `.iter()` in views | Use index lookups | Severe performance issues (re-evaluates on any change) | +| `ctx.db` in procedures | `ctx.withTx(tx => tx.db...)` | Procedures need explicit transactions | +| `ctx.myTable` in procedure tx | `tx.db.myTable` | Wrong context variable | + +### Client-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| `@spacetimedb/sdk` | `spacetimedb` | 404 / missing subpath | +| `conn.reducers.foo("val")` | `conn.reducers.foo({ param: "val" })` | Wrong reducer syntax | +| Inline `connectionBuilder` | `useMemo(() => ..., [])` | Reconnects every render | +| `const rows = useTable(table)` | `const [rows, isLoading] = useTable(table)` | Tuple destructuring | +| Optimistic UI updates | Let subscriptions drive state | Desync issues | +| `` | `connectionBuilder={...}` | Wrong prop name | + +--- + +## 2) Table Definition (CRITICAL) + +**`table()` takes TWO arguments: `table(OPTIONS, COLUMNS)`** + +```typescript +import { schema, table, t } from 'spacetimedb/server'; + +// ❌ WRONG — indexes in COLUMNS causes "reading 'tag'" error +export const Task = table({ name: 'task' }, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] // ❌ WRONG! +}); + +// ✅ RIGHT — indexes in OPTIONS (first argument) +export const Task = table({ + name: 'task', + public: true, + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + title: t.string(), + createdAt: t.timestamp(), +}); +``` + +### Column types +```typescript +t.identity() // User identity (primary key for per-user tables) +t.u64() // Unsigned 64-bit integer (use for IDs) +t.string() // Text +t.bool() // Boolean +t.timestamp() // Timestamp (use ctx.timestamp for current time) +t.scheduleAt() // For scheduled tables only + +// Product types (nested objects) — use t.object, NOT t.struct +const Point = t.object('Point', { x: t.i32(), y: t.i32() }); + +// Sum types (tagged unions) — use t.enum, NOT t.sum +const Shape = t.enum('Shape', { circle: t.i32(), rectangle: Point }); +// Values use { tag: 'circle', value: 10 } or { tag: 'rectangle', value: { x: 1, y: 2 } } + +// Modifiers +t.string().optional() // Nullable +t.u64().primaryKey() // Primary key +t.u64().primaryKey().autoInc() // Auto-increment primary key +``` + +> ⚠️ **BIGINT SYNTAX:** All `u64`, `i64`, and ID fields use JavaScript BigInt. +> - Literals: `0n`, `1n`, `100n` (NOT `0`, `1`, `100`) +> - Comparisons: `row.id === 5n` (NOT `row.id === 5`) +> - Arithmetic: `row.count + 1n` (NOT `row.count + 1`) + +### Auto-increment placeholder +```typescript +// ✅ MUST provide 0n placeholder for auto-inc fields +ctx.db.task.insert({ id: 0n, ownerId: ctx.sender, title: 'New', createdAt: ctx.timestamp }); +``` + +### Insert returns ROW, not ID +```typescript +// ❌ WRONG +const id = ctx.db.task.insert({ ... }); + +// ✅ RIGHT +const row = ctx.db.task.insert({ ... }); +const newId = row.id; // Extract .id from returned row +``` + +### Schema export (CRITICAL) +```typescript +// At end of schema.ts — schema() takes exactly ONE argument: an object +const spacetimedb = schema({ table1, table2, table3 }); +export default spacetimedb; + +// ❌ WRONG — never pass tables directly or as multiple args +schema(myTable); // WRONG! +schema(t1, t2, t3); // WRONG! +``` + +--- + +## 3) Index Access + +### TypeScript Query Patterns + +```typescript +// 1. PRIMARY KEY — use .pkColumn.find() +const user = ctx.db.user.identity.find(ctx.sender); +const msg = ctx.db.message.id.find(messageId); + +// 2. EXPLICIT INDEX — use .indexName.filter(value) +const msgs = [...ctx.db.message.message_room_id.filter(roomId)]; + +// 3. NO INDEX — use .iter() + manual filter +for (const m of ctx.db.roomMember.iter()) { + if (m.roomId === roomId) { /* ... */ } +} +``` + +### Index Definition Syntax + +```typescript +// In table OPTIONS (first argument), not columns +export const Message = table({ + name: 'message', + public: true, + indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + roomId: t.u64(), + // ... +}); +``` + +### Naming conventions + +**Table names — automatic transformation:** +- Schema: `table({ name: 'my_messages' })` +- Access: `ctx.db.myMessages` (automatic snake_case → camelCase) + +**Index names — NO transformation, use EXACTLY as defined:** +```typescript +// Schema definition +indexes: [{ name: 'canvas_member_canvas_id', algorithm: 'btree', columns: ['canvasId'] }] + +// ❌ WRONG — don't assume camelCase transformation +ctx.db.canvasMember.canvasMember_canvas_id.filter(...) // WRONG! +ctx.db.canvasMember.canvasMemberCanvasId.filter(...) // WRONG! + +// ✅ RIGHT — use exact name from schema +ctx.db.canvasMember.canvas_member_canvas_id.filter(...) +``` + +> ⚠️ **Index names are used VERBATIM** — pick a convention (snake_case or camelCase) and stick with it. + +**Index naming pattern — use `{tableName}_{columnName}`:** +```typescript +// ✅ GOOD — unique names across entire module +indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +indexes: [{ name: 'reaction_message_id', algorithm: 'btree', columns: ['messageId'] }] + +// ❌ BAD — will collide if multiple tables use same index name +indexes: [{ name: 'by_owner', ... }] // in Task table +indexes: [{ name: 'by_owner', ... }] // in Note table — CONFLICT! +``` + +**Client-side table names:** +- Check generated `module_bindings/index.ts` for exact export names +- Usage: `useTable(tables.MyMessages)` or `tables.myMessages` (varies by SDK version) + +### Filter vs Find +```typescript +// Filter takes VALUE directly, not object — returns iterator +const rows = [...ctx.db.task.by_owner.filter(ownerId)]; + +// Unique columns use .find() — returns single row or undefined +const row = ctx.db.player.identity.find(ctx.sender); +``` + +### ⚠️ Multi-column indexes are BROKEN +```typescript +// ❌ DON'T — causes PANIC +ctx.db.scores.by_player_level.filter(playerId); + +// ✅ DO — use single-column index + manual filter +for (const row of ctx.db.scores.by_player.filter(playerId)) { + if (row.level === targetLevel) { /* ... */ } +} +``` + +--- + +## 4) Reducers + +### Definition syntax (CRITICAL) +**Reducer name comes from the export — NOT from a string argument.** Use `reducer(params, fn)` or `reducer(fn)`. + +```typescript +import spacetimedb from './schema'; +import { t, SenderError } from 'spacetimedb/server'; + +// ✅ CORRECT — export const name = spacetimedb.reducer(params, fn) +export const reducer_name = spacetimedb.reducer({ param1: t.string(), param2: t.u64() }, (ctx, { param1, param2 }) => { + // Validation + if (!param1) throw new SenderError('param1 required'); + + // Access tables via ctx.db + const row = ctx.db.myTable.primaryKey.find(param2); + + // Mutations + ctx.db.myTable.insert({ ... }); + ctx.db.myTable.primaryKey.update({ ...row, newField: value }); + ctx.db.myTable.primaryKey.delete(param2); +}); + +// No params: export const init = spacetimedb.reducer((ctx) => { ... }); +``` + +```typescript +// ❌ WRONG — reducer('name', params, fn) does NOT exist +spacetimedb.reducer('reducer_name', { param1: t.string() }, (ctx, { param1 }) => { ... }); +``` + +### Update pattern (CRITICAL) +```typescript +// ✅ CORRECT — spread existing row, override specific fields +const existing = ctx.db.task.id.find(taskId); +if (!existing) throw new SenderError('Task not found'); +ctx.db.task.id.update({ ...existing, title: newTitle, updatedAt: ctx.timestamp }); + +// ❌ WRONG — partial update nulls out other fields! +ctx.db.task.id.update({ id: taskId, title: newTitle }); +``` + +### Delete pattern +```typescript +// Delete by primary key VALUE (not row object) +ctx.db.task.id.delete(taskId); // taskId is the u64 value +ctx.db.player.identity.delete(ctx.sender); // delete by identity +``` + +### Lifecycle hooks +```typescript +spacetimedb.clientConnected((ctx) => { + // ctx.sender is the connecting identity + // Create/update user record, set online status, etc. +}); + +spacetimedb.clientDisconnected((ctx) => { + // Clean up: set offline status, remove ephemeral data, etc. +}); +``` + +### Snake_case to camelCase conversion +- Server: `export const do_something = spacetimedb.reducer(...)` — name from export +- Client: `conn.reducers.doSomething({ ... })` + +### Object syntax required +```typescript +// ❌ WRONG - positional +conn.reducers.doSomething('value'); + +// ✅ RIGHT - object +conn.reducers.doSomething({ param: 'value' }); +``` + +--- + +## 5) Scheduled Tables + +```typescript +// 1. Define table first (scheduled: () => reducer — pass the exported reducer) +export const CleanupJob = table({ + name: 'cleanup_job', + scheduled: () => run_cleanup // reducer defined below +}, { + scheduledId: t.u64().primaryKey().autoInc(), + scheduledAt: t.scheduleAt(), + targetId: t.u64(), // Your custom data +}); + +// 2. Define scheduled reducer (receives full row as arg) +export const run_cleanup = spacetimedb.reducer({ arg: CleanupJob.rowType }, (ctx, { arg }) => { + // arg.scheduledId, arg.targetId available + // Row is auto-deleted after reducer completes +}); + +// Schedule a job +import { ScheduleAt } from 'spacetimedb'; +const futureTime = ctx.timestamp.microsSinceUnixEpoch + 60_000_000n; // 60 seconds +ctx.db.cleanupJob.insert({ + scheduledId: 0n, + scheduledAt: ScheduleAt.time(futureTime), + targetId: someId +}); + +// Cancel a job by deleting the row +ctx.db.cleanupJob.scheduledId.delete(jobId); +``` + +--- + +## 6) Timestamps + +### Server-side +```typescript +import { Timestamp, ScheduleAt } from 'spacetimedb'; + +// Current time +ctx.db.item.insert({ id: 0n, createdAt: ctx.timestamp }); + +// Future time (add microseconds) +const future = ctx.timestamp.microsSinceUnixEpoch + 300_000_000n; // 5 minutes +``` + +### Client-side (CRITICAL) +**Timestamps are objects, not numbers:** +```typescript +// ❌ WRONG +const date = new Date(row.createdAt); +const date = new Date(Number(row.createdAt / 1000n)); + +// ✅ RIGHT +const date = new Date(Number(row.createdAt.microsSinceUnixEpoch / 1000n)); +``` + +### ScheduleAt on client +```typescript +// ScheduleAt is a tagged union +if (scheduleAt.tag === 'Time') { + const date = new Date(Number(scheduleAt.value.microsSinceUnixEpoch / 1000n)); +} +``` + +--- + +## 7) Data Visibility & Subscriptions + +**`public: true` exposes ALL rows to ALL clients.** + +| Scenario | Pattern | +|----------|---------| +| Everyone sees all rows | `public: true` | +| Users see only their data | Private table + filtered subscription | + +### Subscription patterns (client-side) +```typescript +// Subscribe to ALL public tables (simplest) +conn.subscriptionBuilder().subscribeToAll(); + +// Subscribe to specific tables with SQL +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM message', + 'SELECT * FROM room WHERE is_public = true', +]); + +// Handle subscription lifecycle +conn.subscriptionBuilder() + .onApplied(() => console.log('Initial data loaded')) + .onError((e) => console.error('Subscription failed:', e)) + .subscribeToAll(); +``` + +### Private table + view pattern (RECOMMENDED) + +**Views are the recommended approach** for controlling data visibility. They provide: +- Server-side filtering (reduces network traffic) +- Real-time updates when underlying data changes +- Full control over what data clients can access + +> ⚠️ **Do NOT use Row Level Security (RLS)** — it is deprecated. + +> ⚠️ **CRITICAL:** Procedural views (views that compute results in code) can ONLY access data via index lookups, NOT `.iter()`. +> If you need a view that scans/filters across many rows (including the entire table), return a **query** built with the query builder (`ctx.from...`). + +```typescript +// Private table with index on ownerId +export const PrivateData = table( + { name: 'private_data', + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] + }, + { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + secret: t.string() + } +); + +// ❌ BAD — .iter() causes performance issues (re-evaluates on ANY row change) +spacetimedb.view( + { name: 'my_data_slow', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.iter()] // Works but VERY slow at scale +); + +// ✅ GOOD — index lookup enables targeted invalidation +spacetimedb.view( + { name: 'my_data', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.by_owner.filter(ctx.sender)] +); +``` + +### Query builder view pattern (can scan) + +```typescript +// Query-builder views return a query; the SQL engine maintains the result incrementally. +// This can scan the whole table if needed (e.g. leaderboard-style queries). +spacetimedb.anonymousView( + { name: 'top_players', public: true }, + t.array(Player.rowType), + (ctx) => + ctx.from.player + .where(p => p.score.gt(1000)) +); +``` + +### ViewContext vs AnonymousViewContext +```typescript +// ViewContext — has ctx.sender, result varies per user (computed per-subscriber) +spacetimedb.view({ name: 'my_items', public: true }, t.array(Item.rowType), (ctx) => { + return [...ctx.db.item.by_owner.filter(ctx.sender)]; +}); + +// AnonymousViewContext — no ctx.sender, same result for everyone (shared, better perf) +spacetimedb.anonymousView({ name: 'leaderboard', public: true }, t.array(LeaderboardRow), (ctx) => { + return [...ctx.db.player.by_score.filter(/* top scores */)]; +}); +``` + +**Views require explicit subscription:** +```typescript +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM public_table', + 'SELECT * FROM my_data', // Views need explicit SQL! +]); +``` + +--- + +## 8) React Integration + +### Key patterns +```typescript +// Memoize connectionBuilder to prevent reconnects on re-render +const builder = useMemo(() => + DbConnection.builder() + .withUri(SPACETIMEDB_URI) + .withDatabaseName(MODULE_NAME) + .withToken(localStorage.getItem('auth_token') || undefined) + .onConnect(onConnect) + .onConnectError(onConnectError), + [] // Empty deps - only create once +); + +// useTable returns tuple [rows, isLoading] +const [rows, isLoading] = useTable(tables.myTable); + +// Compare identities using toHexString() +const isOwner = row.ownerId.toHexString() === myIdentity.toHexString(); +``` + +--- + +## 9) Procedures (Beta) + +**Procedures are for side effects (HTTP requests, etc.) that reducers can't do.** + +⚠️ Procedures are currently in beta. API may change. + +### Defining a procedure +**Procedure name comes from the export — NOT from a string argument.** Use `procedure(params, ret, fn)` or `procedure(ret, fn)`. + +```typescript +// ✅ CORRECT — export const name = spacetimedb.procedure(params, ret, fn) +export const fetch_external_data = spacetimedb.procedure( + { url: t.string() }, + t.string(), // return type + (ctx, { url }) => { + const response = ctx.http.fetch(url); + return response.text(); + } +); +``` + +### Database access in procedures + +⚠️ **CRITICAL: Procedures don't have `ctx.db`. Use `ctx.withTx()` for database access.** + +```typescript +spacetimedb.procedure({ url: t.string() }, t.unit(), (ctx, { url }) => { + // Fetch external data (outside transaction) + const response = ctx.http.fetch(url); + const data = response.text(); + + // ❌ WRONG — ctx.db doesn't exist in procedures + ctx.db.myTable.insert({ ... }); + + // ✅ RIGHT — use ctx.withTx() for database access + ctx.withTx(tx => { + tx.db.myTable.insert({ + id: 0n, + content: data, + fetchedAt: tx.timestamp, + fetchedBy: tx.sender, + }); + }); + + return {}; +}); +``` + +### Key differences from reducers +| Reducers | Procedures | +|----------|------------| +| `ctx.db` available directly | Must use `ctx.withTx(tx => tx.db...)` | +| Automatic transaction | Manual transaction management | +| No HTTP/network | `ctx.http.fetch()` available | +| No return values to caller | Can return data to caller | + +--- + +## 10) Project Structure + +### Server (`backend/spacetimedb/`) +``` +src/schema.ts → Tables, export spacetimedb +src/index.ts → Reducers, lifecycle, import schema +package.json → { "type": "module", "dependencies": { "spacetimedb": "^1.11.0" } } +tsconfig.json → Standard config +``` + +### Avoiding circular imports +``` +schema.ts → defines tables AND exports spacetimedb +index.ts → imports spacetimedb from ./schema, defines reducers +``` + +### Client (`client/`) +``` +src/module_bindings/ → Generated (spacetime generate) +src/main.tsx → Provider, connection setup +src/App.tsx → UI components +src/config.ts → MODULE_NAME, SPACETIMEDB_URI +``` + +--- + +## 11) Commands + +```bash +# Start local server +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear database and republish +spacetime publish --clear-database -y --module-path + +# Generate bindings +spacetime generate --lang typescript --out-dir /src/module_bindings --module-path + +# View logs +spacetime logs +``` + +--- + +## 12) Hard Requirements + +**TypeScript-specific:** + +1. **`schema({ table })`** — takes exactly one object; never `schema(table)` or `schema(t1, t2, t3)` +2. **Reducer/procedure names from exports** — `export const name = spacetimedb.reducer(params, fn)`; never `reducer('name', ...)` +3. **Reducer calls use object syntax** — `{ param: 'value' }` not positional args +4. **Import `DbConnection` from `./module_bindings`** — not from `spacetimedb` +5. **DO NOT edit generated bindings** — regenerate with `spacetime generate` +6. **Indexes go in OPTIONS (1st arg)** — not in COLUMNS (2nd arg) of `table()` +7. **Use BigInt for u64/i64 fields** — `0n`, `1n`, not `0`, `1` +8. **Reducers are transactional** — they do not return data +9. **Reducers must be deterministic** — no filesystem, network, timers, random +10. **Views should use index lookups** — `.iter()` causes severe performance issues +11. **Procedures need `ctx.withTx()`** — `ctx.db` doesn't exist in procedures +12. **Sum type values** — use `{ tag: 'variant', value: payload }` not `{ variant: payload }` diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..60090f2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,47 @@ + +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +lerna-debug.log* +.pnpm-debug.log* + +# Runtime data +pids +*.pid +*.seed +*.pid.lock + +# Dependency directory +node_modules/ +jspm_packages/ + +# Build output +dist/ +out/ +build/ + +# IDEs and editors +.idea +.vscode/ +*.iml +*~ + +# Misc +.DS_Store +*.env.local +.env.development.local +.env.test.local +.env.production.local + +# Vite +.vite/ + +# SpacetimeDB build output +spacetimedb/dist/ + +# Ignore this file +.gitignore + diff --git a/.windsurfrules b/.windsurfrules new file mode 100644 index 0000000..c58f00b --- /dev/null +++ b/.windsurfrules @@ -0,0 +1,766 @@ +# SpacetimeDB Rules (All Languages) + +## Migrating from 1.0 to 2.0? + +**If you are migrating existing SpacetimeDB 1.0 code to 2.0, apply `spacetimedb-migration-2.0.mdc` first.** It documents breaking changes (reducer callbacks → event tables, `name`→`accessor`, `sender()` method, etc.) and should be considered before other rules. + +--- + +## Language-Specific Rules + +| Language | Rule File | +|----------|-----------| +| **TypeScript/React** | `spacetimedb-typescript.mdc` (MANDATORY) | +| **Rust** | `spacetimedb-rust.mdc` (MANDATORY) | +| **C#** | `spacetimedb-csharp.mdc` (MANDATORY) | +| **Migrating 1.0 → 2.0** | `spacetimedb-migration-2.0.mdc` | + +--- + +## Core Concepts + +1. **Reducers are transactional** — they do not return data to callers +2. **Reducers must be deterministic** — no filesystem, network, timers, or random +3. **Read data via tables/subscriptions** — not reducer return values +4. **Auto-increment IDs are not sequential** — gaps are normal, don't use for ordering +5. **`ctx.sender` is the authenticated principal** — never trust identity args + +--- + +## Feature Implementation Checklist + +When implementing a feature that spans backend and client: + +1. **Backend:** Define table(s) to store the data +2. **Backend:** Define reducer(s) to mutate the data +3. **Client:** Subscribe to the table(s) +4. **Client:** Call the reducer(s) from UI — **don't forget this step!** +5. **Client:** Render the data from the table(s) + +**Common mistake:** Building backend tables/reducers but forgetting to wire up the client to call them. + +--- + +## Index System + +SpacetimeDB automatically creates indexes for: +- Primary key columns +- Columns marked as unique + +You can add explicit indexes on non-unique columns for query performance. + +**Index names must be unique across your entire module (all tables).** If two tables have indexes with the same declared name → conflict error. + +**Schema ↔ Code coupling:** +- Your query code references indexes by name +- If you add/remove/rename an index in the schema, update all code that uses it +- Removing an index without updating queries causes runtime errors + +--- + +## Commands + +```bash +# Login to allow remote database deployment e.g. to maincloud +spacetime login + +# Start local SpacetimeDB +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear and republish +spacetime publish --clear-database -y --module-path + +# Generate client bindings +spacetime generate --lang --out-dir --module-path + +# View logs +spacetime logs +``` + +--- + +## Deployment + +- Maincloud is the spacetimedb hosted cloud and the default location for module publishing +- The default server marked by *** in `spacetime server list` should be used when publishing +- If the default server is maincloud you should publish to maincloud +- Publishing to maincloud is free of charge +- When publishing to maincloud the database dashboard will be at the url: https://spacetimedb.com/@/ +- The database owner can view utilization and performance metrics on the dashboard + +--- + +## Debugging Checklist + +1. Is SpacetimeDB server running? (`spacetime start`) +2. Is the module published? (`spacetime publish`) +3. Are client bindings generated? (`spacetime generate`) +4. Check server logs for errors (`spacetime logs `) +5. **Is the reducer actually being called from the client?** + +--- + +## Editing Behavior + +- Make the smallest change necessary +- Do NOT touch unrelated files, configs, or dependencies +- Do NOT invent new SpacetimeDB APIs — use only what exists in docs or this repo +- Do NOT add restrictions the prompt didn't ask for — if "users can do X", implement X for all users + + +# SpacetimeDB TypeScript SDK + +## ⛔ HALLUCINATED APIs — DO NOT USE + +**These APIs DO NOT EXIST. LLMs frequently hallucinate them.** + +```typescript +// ❌ WRONG PACKAGE — does not exist +import { SpacetimeDBClient } from "@clockworklabs/spacetimedb-sdk"; + +// ❌ WRONG — these methods don't exist +SpacetimeDBClient.connect(...); +SpacetimeDBClient.call("reducer_name", [...]); +connection.call("reducer_name", [arg1, arg2]); + +// ❌ WRONG — positional reducer arguments +conn.reducers.doSomething("value"); // WRONG! + +// ❌ WRONG — static methods on generated types don't exist +User.filterByName('alice'); +Message.findById(123n); +tables.user.filter(u => u.name === 'alice'); // No .filter() on tables object! +``` + +### ✅ CORRECT PATTERNS: + +```typescript +// ✅ CORRECT IMPORTS +import { DbConnection, tables } from './module_bindings'; // Generated! +import { SpacetimeDBProvider, useTable, Identity } from 'spacetimedb/react'; + +// ✅ CORRECT REDUCER CALLS — object syntax, not positional! +conn.reducers.doSomething({ value: 'test' }); +conn.reducers.updateItem({ itemId: 1n, newValue: 42 }); + +// ✅ CORRECT DATA ACCESS — useTable returns [rows, isLoading] +const [items, isLoading] = useTable(tables.item); +``` + +### ⛔ DO NOT: +- **Invent hooks** like `useItems()`, `useData()` — use `useTable(tables.tableName)` +- **Import from fake packages** — only `spacetimedb`, `spacetimedb/react`, `./module_bindings` + +--- + +## 1) Common Mistakes Table + +### Server-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| Missing `package.json` | Create `package.json` | "could not detect language" | +| Missing `tsconfig.json` | Create `tsconfig.json` | "TsconfigNotFound" | +| Entrypoint not at `src/index.ts` | Use `src/index.ts` | Module won't bundle | +| `indexes` in COLUMNS (2nd arg) | `indexes` in OPTIONS (1st arg) | "reading 'tag'" error | +| Index without `algorithm` | `algorithm: 'btree'` | "reading 'tag'" error | +| `filter({ ownerId })` | `filter(ownerId)` | "does not exist in type 'Range'" | +| `.filter()` on unique column | `.find()` on unique column | TypeError | +| `insert({ ...without id })` | `insert({ id: 0n, ... })` | "Property 'id' is missing" | +| `const id = table.insert(...)` | `const row = table.insert(...)` | `.insert()` returns ROW, not ID | +| `.unique()` + explicit index | Just use `.unique()` | "name is used for multiple entities" | +| Index on `.primaryKey()` column | Don't — already indexed | "name is used for multiple entities" | +| Same index name in multiple tables | Prefix with table name | "name is used for multiple entities" | +| `.indexName.filter()` after removing index | Use `.iter()` + manual filter | "Cannot read properties of undefined" | +| Import spacetimedb from index.ts | Import from schema.ts | "Cannot access before initialization" | +| Multi-column index `.filter()` | **⚠️ BROKEN** — use single-column | PANIC or silent empty results | +| `JSON.stringify({ id: row.id })` | Convert BigInt first: `{ id: row.id.toString() }` | "Do not know how to serialize a BigInt" | +| `ScheduleAt.Time(timestamp)` | `ScheduleAt.time(timestamp)` (lowercase) | "ScheduleAt.Time is not a function" | +| `ctx.db.foo.myIndexName.filter()` | Use exact name: `ctx.db.foo.my_index_name.filter()` | "Cannot read properties of undefined" | +| `.iter()` in views | Use index lookups | Severe performance issues (re-evaluates on any change) | +| `ctx.db` in procedures | `ctx.withTx(tx => tx.db...)` | Procedures need explicit transactions | +| `ctx.myTable` in procedure tx | `tx.db.myTable` | Wrong context variable | + +### Client-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| `@spacetimedb/sdk` | `spacetimedb` | 404 / missing subpath | +| `conn.reducers.foo("val")` | `conn.reducers.foo({ param: "val" })` | Wrong reducer syntax | +| Inline `connectionBuilder` | `useMemo(() => ..., [])` | Reconnects every render | +| `const rows = useTable(table)` | `const [rows, isLoading] = useTable(table)` | Tuple destructuring | +| Optimistic UI updates | Let subscriptions drive state | Desync issues | +| `` | `connectionBuilder={...}` | Wrong prop name | + +--- + +## 2) Table Definition (CRITICAL) + +**`table()` takes TWO arguments: `table(OPTIONS, COLUMNS)`** + +```typescript +import { schema, table, t } from 'spacetimedb/server'; + +// ❌ WRONG — indexes in COLUMNS causes "reading 'tag'" error +export const Task = table({ name: 'task' }, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] // ❌ WRONG! +}); + +// ✅ RIGHT — indexes in OPTIONS (first argument) +export const Task = table({ + name: 'task', + public: true, + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + title: t.string(), + createdAt: t.timestamp(), +}); +``` + +### Column types +```typescript +t.identity() // User identity (primary key for per-user tables) +t.u64() // Unsigned 64-bit integer (use for IDs) +t.string() // Text +t.bool() // Boolean +t.timestamp() // Timestamp (use ctx.timestamp for current time) +t.scheduleAt() // For scheduled tables only + +// Product types (nested objects) — use t.object, NOT t.struct +const Point = t.object('Point', { x: t.i32(), y: t.i32() }); + +// Sum types (tagged unions) — use t.enum, NOT t.sum +const Shape = t.enum('Shape', { circle: t.i32(), rectangle: Point }); +// Values use { tag: 'circle', value: 10 } or { tag: 'rectangle', value: { x: 1, y: 2 } } + +// Modifiers +t.string().optional() // Nullable +t.u64().primaryKey() // Primary key +t.u64().primaryKey().autoInc() // Auto-increment primary key +``` + +> ⚠️ **BIGINT SYNTAX:** All `u64`, `i64`, and ID fields use JavaScript BigInt. +> - Literals: `0n`, `1n`, `100n` (NOT `0`, `1`, `100`) +> - Comparisons: `row.id === 5n` (NOT `row.id === 5`) +> - Arithmetic: `row.count + 1n` (NOT `row.count + 1`) + +### Auto-increment placeholder +```typescript +// ✅ MUST provide 0n placeholder for auto-inc fields +ctx.db.task.insert({ id: 0n, ownerId: ctx.sender, title: 'New', createdAt: ctx.timestamp }); +``` + +### Insert returns ROW, not ID +```typescript +// ❌ WRONG +const id = ctx.db.task.insert({ ... }); + +// ✅ RIGHT +const row = ctx.db.task.insert({ ... }); +const newId = row.id; // Extract .id from returned row +``` + +### Schema export (CRITICAL) +```typescript +// At end of schema.ts — schema() takes exactly ONE argument: an object +const spacetimedb = schema({ table1, table2, table3 }); +export default spacetimedb; + +// ❌ WRONG — never pass tables directly or as multiple args +schema(myTable); // WRONG! +schema(t1, t2, t3); // WRONG! +``` + +--- + +## 3) Index Access + +### TypeScript Query Patterns + +```typescript +// 1. PRIMARY KEY — use .pkColumn.find() +const user = ctx.db.user.identity.find(ctx.sender); +const msg = ctx.db.message.id.find(messageId); + +// 2. EXPLICIT INDEX — use .indexName.filter(value) +const msgs = [...ctx.db.message.message_room_id.filter(roomId)]; + +// 3. NO INDEX — use .iter() + manual filter +for (const m of ctx.db.roomMember.iter()) { + if (m.roomId === roomId) { /* ... */ } +} +``` + +### Index Definition Syntax + +```typescript +// In table OPTIONS (first argument), not columns +export const Message = table({ + name: 'message', + public: true, + indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + roomId: t.u64(), + // ... +}); +``` + +### Naming conventions + +**Table names — automatic transformation:** +- Schema: `table({ name: 'my_messages' })` +- Access: `ctx.db.myMessages` (automatic snake_case → camelCase) + +**Index names — NO transformation, use EXACTLY as defined:** +```typescript +// Schema definition +indexes: [{ name: 'canvas_member_canvas_id', algorithm: 'btree', columns: ['canvasId'] }] + +// ❌ WRONG — don't assume camelCase transformation +ctx.db.canvasMember.canvasMember_canvas_id.filter(...) // WRONG! +ctx.db.canvasMember.canvasMemberCanvasId.filter(...) // WRONG! + +// ✅ RIGHT — use exact name from schema +ctx.db.canvasMember.canvas_member_canvas_id.filter(...) +``` + +> ⚠️ **Index names are used VERBATIM** — pick a convention (snake_case or camelCase) and stick with it. + +**Index naming pattern — use `{tableName}_{columnName}`:** +```typescript +// ✅ GOOD — unique names across entire module +indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +indexes: [{ name: 'reaction_message_id', algorithm: 'btree', columns: ['messageId'] }] + +// ❌ BAD — will collide if multiple tables use same index name +indexes: [{ name: 'by_owner', ... }] // in Task table +indexes: [{ name: 'by_owner', ... }] // in Note table — CONFLICT! +``` + +**Client-side table names:** +- Check generated `module_bindings/index.ts` for exact export names +- Usage: `useTable(tables.MyMessages)` or `tables.myMessages` (varies by SDK version) + +### Filter vs Find +```typescript +// Filter takes VALUE directly, not object — returns iterator +const rows = [...ctx.db.task.by_owner.filter(ownerId)]; + +// Unique columns use .find() — returns single row or undefined +const row = ctx.db.player.identity.find(ctx.sender); +``` + +### ⚠️ Multi-column indexes are BROKEN +```typescript +// ❌ DON'T — causes PANIC +ctx.db.scores.by_player_level.filter(playerId); + +// ✅ DO — use single-column index + manual filter +for (const row of ctx.db.scores.by_player.filter(playerId)) { + if (row.level === targetLevel) { /* ... */ } +} +``` + +--- + +## 4) Reducers + +### Definition syntax (CRITICAL) +**Reducer name comes from the export — NOT from a string argument.** Use `reducer(params, fn)` or `reducer(fn)`. + +```typescript +import spacetimedb from './schema'; +import { t, SenderError } from 'spacetimedb/server'; + +// ✅ CORRECT — export const name = spacetimedb.reducer(params, fn) +export const reducer_name = spacetimedb.reducer({ param1: t.string(), param2: t.u64() }, (ctx, { param1, param2 }) => { + // Validation + if (!param1) throw new SenderError('param1 required'); + + // Access tables via ctx.db + const row = ctx.db.myTable.primaryKey.find(param2); + + // Mutations + ctx.db.myTable.insert({ ... }); + ctx.db.myTable.primaryKey.update({ ...row, newField: value }); + ctx.db.myTable.primaryKey.delete(param2); +}); + +// No params: export const init = spacetimedb.reducer((ctx) => { ... }); +``` + +```typescript +// ❌ WRONG — reducer('name', params, fn) does NOT exist +spacetimedb.reducer('reducer_name', { param1: t.string() }, (ctx, { param1 }) => { ... }); +``` + +### Update pattern (CRITICAL) +```typescript +// ✅ CORRECT — spread existing row, override specific fields +const existing = ctx.db.task.id.find(taskId); +if (!existing) throw new SenderError('Task not found'); +ctx.db.task.id.update({ ...existing, title: newTitle, updatedAt: ctx.timestamp }); + +// ❌ WRONG — partial update nulls out other fields! +ctx.db.task.id.update({ id: taskId, title: newTitle }); +``` + +### Delete pattern +```typescript +// Delete by primary key VALUE (not row object) +ctx.db.task.id.delete(taskId); // taskId is the u64 value +ctx.db.player.identity.delete(ctx.sender); // delete by identity +``` + +### Lifecycle hooks +```typescript +spacetimedb.clientConnected((ctx) => { + // ctx.sender is the connecting identity + // Create/update user record, set online status, etc. +}); + +spacetimedb.clientDisconnected((ctx) => { + // Clean up: set offline status, remove ephemeral data, etc. +}); +``` + +### Snake_case to camelCase conversion +- Server: `export const do_something = spacetimedb.reducer(...)` — name from export +- Client: `conn.reducers.doSomething({ ... })` + +### Object syntax required +```typescript +// ❌ WRONG - positional +conn.reducers.doSomething('value'); + +// ✅ RIGHT - object +conn.reducers.doSomething({ param: 'value' }); +``` + +--- + +## 5) Scheduled Tables + +```typescript +// 1. Define table first (scheduled: () => reducer — pass the exported reducer) +export const CleanupJob = table({ + name: 'cleanup_job', + scheduled: () => run_cleanup // reducer defined below +}, { + scheduledId: t.u64().primaryKey().autoInc(), + scheduledAt: t.scheduleAt(), + targetId: t.u64(), // Your custom data +}); + +// 2. Define scheduled reducer (receives full row as arg) +export const run_cleanup = spacetimedb.reducer({ arg: CleanupJob.rowType }, (ctx, { arg }) => { + // arg.scheduledId, arg.targetId available + // Row is auto-deleted after reducer completes +}); + +// Schedule a job +import { ScheduleAt } from 'spacetimedb'; +const futureTime = ctx.timestamp.microsSinceUnixEpoch + 60_000_000n; // 60 seconds +ctx.db.cleanupJob.insert({ + scheduledId: 0n, + scheduledAt: ScheduleAt.time(futureTime), + targetId: someId +}); + +// Cancel a job by deleting the row +ctx.db.cleanupJob.scheduledId.delete(jobId); +``` + +--- + +## 6) Timestamps + +### Server-side +```typescript +import { Timestamp, ScheduleAt } from 'spacetimedb'; + +// Current time +ctx.db.item.insert({ id: 0n, createdAt: ctx.timestamp }); + +// Future time (add microseconds) +const future = ctx.timestamp.microsSinceUnixEpoch + 300_000_000n; // 5 minutes +``` + +### Client-side (CRITICAL) +**Timestamps are objects, not numbers:** +```typescript +// ❌ WRONG +const date = new Date(row.createdAt); +const date = new Date(Number(row.createdAt / 1000n)); + +// ✅ RIGHT +const date = new Date(Number(row.createdAt.microsSinceUnixEpoch / 1000n)); +``` + +### ScheduleAt on client +```typescript +// ScheduleAt is a tagged union +if (scheduleAt.tag === 'Time') { + const date = new Date(Number(scheduleAt.value.microsSinceUnixEpoch / 1000n)); +} +``` + +--- + +## 7) Data Visibility & Subscriptions + +**`public: true` exposes ALL rows to ALL clients.** + +| Scenario | Pattern | +|----------|---------| +| Everyone sees all rows | `public: true` | +| Users see only their data | Private table + filtered subscription | + +### Subscription patterns (client-side) +```typescript +// Subscribe to ALL public tables (simplest) +conn.subscriptionBuilder().subscribeToAll(); + +// Subscribe to specific tables with SQL +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM message', + 'SELECT * FROM room WHERE is_public = true', +]); + +// Handle subscription lifecycle +conn.subscriptionBuilder() + .onApplied(() => console.log('Initial data loaded')) + .onError((e) => console.error('Subscription failed:', e)) + .subscribeToAll(); +``` + +### Private table + view pattern (RECOMMENDED) + +**Views are the recommended approach** for controlling data visibility. They provide: +- Server-side filtering (reduces network traffic) +- Real-time updates when underlying data changes +- Full control over what data clients can access + +> ⚠️ **Do NOT use Row Level Security (RLS)** — it is deprecated. + +> ⚠️ **CRITICAL:** Procedural views (views that compute results in code) can ONLY access data via index lookups, NOT `.iter()`. +> If you need a view that scans/filters across many rows (including the entire table), return a **query** built with the query builder (`ctx.from...`). + +```typescript +// Private table with index on ownerId +export const PrivateData = table( + { name: 'private_data', + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] + }, + { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + secret: t.string() + } +); + +// ❌ BAD — .iter() causes performance issues (re-evaluates on ANY row change) +spacetimedb.view( + { name: 'my_data_slow', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.iter()] // Works but VERY slow at scale +); + +// ✅ GOOD — index lookup enables targeted invalidation +spacetimedb.view( + { name: 'my_data', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.by_owner.filter(ctx.sender)] +); +``` + +### Query builder view pattern (can scan) + +```typescript +// Query-builder views return a query; the SQL engine maintains the result incrementally. +// This can scan the whole table if needed (e.g. leaderboard-style queries). +spacetimedb.anonymousView( + { name: 'top_players', public: true }, + t.array(Player.rowType), + (ctx) => + ctx.from.player + .where(p => p.score.gt(1000)) +); +``` + +### ViewContext vs AnonymousViewContext +```typescript +// ViewContext — has ctx.sender, result varies per user (computed per-subscriber) +spacetimedb.view({ name: 'my_items', public: true }, t.array(Item.rowType), (ctx) => { + return [...ctx.db.item.by_owner.filter(ctx.sender)]; +}); + +// AnonymousViewContext — no ctx.sender, same result for everyone (shared, better perf) +spacetimedb.anonymousView({ name: 'leaderboard', public: true }, t.array(LeaderboardRow), (ctx) => { + return [...ctx.db.player.by_score.filter(/* top scores */)]; +}); +``` + +**Views require explicit subscription:** +```typescript +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM public_table', + 'SELECT * FROM my_data', // Views need explicit SQL! +]); +``` + +--- + +## 8) React Integration + +### Key patterns +```typescript +// Memoize connectionBuilder to prevent reconnects on re-render +const builder = useMemo(() => + DbConnection.builder() + .withUri(SPACETIMEDB_URI) + .withDatabaseName(MODULE_NAME) + .withToken(localStorage.getItem('auth_token') || undefined) + .onConnect(onConnect) + .onConnectError(onConnectError), + [] // Empty deps - only create once +); + +// useTable returns tuple [rows, isLoading] +const [rows, isLoading] = useTable(tables.myTable); + +// Compare identities using toHexString() +const isOwner = row.ownerId.toHexString() === myIdentity.toHexString(); +``` + +--- + +## 9) Procedures (Beta) + +**Procedures are for side effects (HTTP requests, etc.) that reducers can't do.** + +⚠️ Procedures are currently in beta. API may change. + +### Defining a procedure +**Procedure name comes from the export — NOT from a string argument.** Use `procedure(params, ret, fn)` or `procedure(ret, fn)`. + +```typescript +// ✅ CORRECT — export const name = spacetimedb.procedure(params, ret, fn) +export const fetch_external_data = spacetimedb.procedure( + { url: t.string() }, + t.string(), // return type + (ctx, { url }) => { + const response = ctx.http.fetch(url); + return response.text(); + } +); +``` + +### Database access in procedures + +⚠️ **CRITICAL: Procedures don't have `ctx.db`. Use `ctx.withTx()` for database access.** + +```typescript +spacetimedb.procedure({ url: t.string() }, t.unit(), (ctx, { url }) => { + // Fetch external data (outside transaction) + const response = ctx.http.fetch(url); + const data = response.text(); + + // ❌ WRONG — ctx.db doesn't exist in procedures + ctx.db.myTable.insert({ ... }); + + // ✅ RIGHT — use ctx.withTx() for database access + ctx.withTx(tx => { + tx.db.myTable.insert({ + id: 0n, + content: data, + fetchedAt: tx.timestamp, + fetchedBy: tx.sender, + }); + }); + + return {}; +}); +``` + +### Key differences from reducers +| Reducers | Procedures | +|----------|------------| +| `ctx.db` available directly | Must use `ctx.withTx(tx => tx.db...)` | +| Automatic transaction | Manual transaction management | +| No HTTP/network | `ctx.http.fetch()` available | +| No return values to caller | Can return data to caller | + +--- + +## 10) Project Structure + +### Server (`backend/spacetimedb/`) +``` +src/schema.ts → Tables, export spacetimedb +src/index.ts → Reducers, lifecycle, import schema +package.json → { "type": "module", "dependencies": { "spacetimedb": "^1.11.0" } } +tsconfig.json → Standard config +``` + +### Avoiding circular imports +``` +schema.ts → defines tables AND exports spacetimedb +index.ts → imports spacetimedb from ./schema, defines reducers +``` + +### Client (`client/`) +``` +src/module_bindings/ → Generated (spacetime generate) +src/main.tsx → Provider, connection setup +src/App.tsx → UI components +src/config.ts → MODULE_NAME, SPACETIMEDB_URI +``` + +--- + +## 11) Commands + +```bash +# Start local server +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear database and republish +spacetime publish --clear-database -y --module-path + +# Generate bindings +spacetime generate --lang typescript --out-dir /src/module_bindings --module-path + +# View logs +spacetime logs +``` + +--- + +## 12) Hard Requirements + +**TypeScript-specific:** + +1. **`schema({ table })`** — takes exactly one object; never `schema(table)` or `schema(t1, t2, t3)` +2. **Reducer/procedure names from exports** — `export const name = spacetimedb.reducer(params, fn)`; never `reducer('name', ...)` +3. **Reducer calls use object syntax** — `{ param: 'value' }` not positional args +4. **Import `DbConnection` from `./module_bindings`** — not from `spacetimedb` +5. **DO NOT edit generated bindings** — regenerate with `spacetime generate` +6. **Indexes go in OPTIONS (1st arg)** — not in COLUMNS (2nd arg) of `table()` +7. **Use BigInt for u64/i64 fields** — `0n`, `1n`, not `0`, `1` +8. **Reducers are transactional** — they do not return data +9. **Reducers must be deterministic** — no filesystem, network, timers, random +10. **Views should use index lookups** — `.iter()` causes severe performance issues +11. **Procedures need `ctx.withTx()`** — `ctx.db` doesn't exist in procedures +12. **Sum type values** — use `{ tag: 'variant', value: payload }` not `{ variant: payload }` diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..c58f00b --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,766 @@ +# SpacetimeDB Rules (All Languages) + +## Migrating from 1.0 to 2.0? + +**If you are migrating existing SpacetimeDB 1.0 code to 2.0, apply `spacetimedb-migration-2.0.mdc` first.** It documents breaking changes (reducer callbacks → event tables, `name`→`accessor`, `sender()` method, etc.) and should be considered before other rules. + +--- + +## Language-Specific Rules + +| Language | Rule File | +|----------|-----------| +| **TypeScript/React** | `spacetimedb-typescript.mdc` (MANDATORY) | +| **Rust** | `spacetimedb-rust.mdc` (MANDATORY) | +| **C#** | `spacetimedb-csharp.mdc` (MANDATORY) | +| **Migrating 1.0 → 2.0** | `spacetimedb-migration-2.0.mdc` | + +--- + +## Core Concepts + +1. **Reducers are transactional** — they do not return data to callers +2. **Reducers must be deterministic** — no filesystem, network, timers, or random +3. **Read data via tables/subscriptions** — not reducer return values +4. **Auto-increment IDs are not sequential** — gaps are normal, don't use for ordering +5. **`ctx.sender` is the authenticated principal** — never trust identity args + +--- + +## Feature Implementation Checklist + +When implementing a feature that spans backend and client: + +1. **Backend:** Define table(s) to store the data +2. **Backend:** Define reducer(s) to mutate the data +3. **Client:** Subscribe to the table(s) +4. **Client:** Call the reducer(s) from UI — **don't forget this step!** +5. **Client:** Render the data from the table(s) + +**Common mistake:** Building backend tables/reducers but forgetting to wire up the client to call them. + +--- + +## Index System + +SpacetimeDB automatically creates indexes for: +- Primary key columns +- Columns marked as unique + +You can add explicit indexes on non-unique columns for query performance. + +**Index names must be unique across your entire module (all tables).** If two tables have indexes with the same declared name → conflict error. + +**Schema ↔ Code coupling:** +- Your query code references indexes by name +- If you add/remove/rename an index in the schema, update all code that uses it +- Removing an index without updating queries causes runtime errors + +--- + +## Commands + +```bash +# Login to allow remote database deployment e.g. to maincloud +spacetime login + +# Start local SpacetimeDB +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear and republish +spacetime publish --clear-database -y --module-path + +# Generate client bindings +spacetime generate --lang --out-dir --module-path + +# View logs +spacetime logs +``` + +--- + +## Deployment + +- Maincloud is the spacetimedb hosted cloud and the default location for module publishing +- The default server marked by *** in `spacetime server list` should be used when publishing +- If the default server is maincloud you should publish to maincloud +- Publishing to maincloud is free of charge +- When publishing to maincloud the database dashboard will be at the url: https://spacetimedb.com/@/ +- The database owner can view utilization and performance metrics on the dashboard + +--- + +## Debugging Checklist + +1. Is SpacetimeDB server running? (`spacetime start`) +2. Is the module published? (`spacetime publish`) +3. Are client bindings generated? (`spacetime generate`) +4. Check server logs for errors (`spacetime logs `) +5. **Is the reducer actually being called from the client?** + +--- + +## Editing Behavior + +- Make the smallest change necessary +- Do NOT touch unrelated files, configs, or dependencies +- Do NOT invent new SpacetimeDB APIs — use only what exists in docs or this repo +- Do NOT add restrictions the prompt didn't ask for — if "users can do X", implement X for all users + + +# SpacetimeDB TypeScript SDK + +## ⛔ HALLUCINATED APIs — DO NOT USE + +**These APIs DO NOT EXIST. LLMs frequently hallucinate them.** + +```typescript +// ❌ WRONG PACKAGE — does not exist +import { SpacetimeDBClient } from "@clockworklabs/spacetimedb-sdk"; + +// ❌ WRONG — these methods don't exist +SpacetimeDBClient.connect(...); +SpacetimeDBClient.call("reducer_name", [...]); +connection.call("reducer_name", [arg1, arg2]); + +// ❌ WRONG — positional reducer arguments +conn.reducers.doSomething("value"); // WRONG! + +// ❌ WRONG — static methods on generated types don't exist +User.filterByName('alice'); +Message.findById(123n); +tables.user.filter(u => u.name === 'alice'); // No .filter() on tables object! +``` + +### ✅ CORRECT PATTERNS: + +```typescript +// ✅ CORRECT IMPORTS +import { DbConnection, tables } from './module_bindings'; // Generated! +import { SpacetimeDBProvider, useTable, Identity } from 'spacetimedb/react'; + +// ✅ CORRECT REDUCER CALLS — object syntax, not positional! +conn.reducers.doSomething({ value: 'test' }); +conn.reducers.updateItem({ itemId: 1n, newValue: 42 }); + +// ✅ CORRECT DATA ACCESS — useTable returns [rows, isLoading] +const [items, isLoading] = useTable(tables.item); +``` + +### ⛔ DO NOT: +- **Invent hooks** like `useItems()`, `useData()` — use `useTable(tables.tableName)` +- **Import from fake packages** — only `spacetimedb`, `spacetimedb/react`, `./module_bindings` + +--- + +## 1) Common Mistakes Table + +### Server-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| Missing `package.json` | Create `package.json` | "could not detect language" | +| Missing `tsconfig.json` | Create `tsconfig.json` | "TsconfigNotFound" | +| Entrypoint not at `src/index.ts` | Use `src/index.ts` | Module won't bundle | +| `indexes` in COLUMNS (2nd arg) | `indexes` in OPTIONS (1st arg) | "reading 'tag'" error | +| Index without `algorithm` | `algorithm: 'btree'` | "reading 'tag'" error | +| `filter({ ownerId })` | `filter(ownerId)` | "does not exist in type 'Range'" | +| `.filter()` on unique column | `.find()` on unique column | TypeError | +| `insert({ ...without id })` | `insert({ id: 0n, ... })` | "Property 'id' is missing" | +| `const id = table.insert(...)` | `const row = table.insert(...)` | `.insert()` returns ROW, not ID | +| `.unique()` + explicit index | Just use `.unique()` | "name is used for multiple entities" | +| Index on `.primaryKey()` column | Don't — already indexed | "name is used for multiple entities" | +| Same index name in multiple tables | Prefix with table name | "name is used for multiple entities" | +| `.indexName.filter()` after removing index | Use `.iter()` + manual filter | "Cannot read properties of undefined" | +| Import spacetimedb from index.ts | Import from schema.ts | "Cannot access before initialization" | +| Multi-column index `.filter()` | **⚠️ BROKEN** — use single-column | PANIC or silent empty results | +| `JSON.stringify({ id: row.id })` | Convert BigInt first: `{ id: row.id.toString() }` | "Do not know how to serialize a BigInt" | +| `ScheduleAt.Time(timestamp)` | `ScheduleAt.time(timestamp)` (lowercase) | "ScheduleAt.Time is not a function" | +| `ctx.db.foo.myIndexName.filter()` | Use exact name: `ctx.db.foo.my_index_name.filter()` | "Cannot read properties of undefined" | +| `.iter()` in views | Use index lookups | Severe performance issues (re-evaluates on any change) | +| `ctx.db` in procedures | `ctx.withTx(tx => tx.db...)` | Procedures need explicit transactions | +| `ctx.myTable` in procedure tx | `tx.db.myTable` | Wrong context variable | + +### Client-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| `@spacetimedb/sdk` | `spacetimedb` | 404 / missing subpath | +| `conn.reducers.foo("val")` | `conn.reducers.foo({ param: "val" })` | Wrong reducer syntax | +| Inline `connectionBuilder` | `useMemo(() => ..., [])` | Reconnects every render | +| `const rows = useTable(table)` | `const [rows, isLoading] = useTable(table)` | Tuple destructuring | +| Optimistic UI updates | Let subscriptions drive state | Desync issues | +| `` | `connectionBuilder={...}` | Wrong prop name | + +--- + +## 2) Table Definition (CRITICAL) + +**`table()` takes TWO arguments: `table(OPTIONS, COLUMNS)`** + +```typescript +import { schema, table, t } from 'spacetimedb/server'; + +// ❌ WRONG — indexes in COLUMNS causes "reading 'tag'" error +export const Task = table({ name: 'task' }, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] // ❌ WRONG! +}); + +// ✅ RIGHT — indexes in OPTIONS (first argument) +export const Task = table({ + name: 'task', + public: true, + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + title: t.string(), + createdAt: t.timestamp(), +}); +``` + +### Column types +```typescript +t.identity() // User identity (primary key for per-user tables) +t.u64() // Unsigned 64-bit integer (use for IDs) +t.string() // Text +t.bool() // Boolean +t.timestamp() // Timestamp (use ctx.timestamp for current time) +t.scheduleAt() // For scheduled tables only + +// Product types (nested objects) — use t.object, NOT t.struct +const Point = t.object('Point', { x: t.i32(), y: t.i32() }); + +// Sum types (tagged unions) — use t.enum, NOT t.sum +const Shape = t.enum('Shape', { circle: t.i32(), rectangle: Point }); +// Values use { tag: 'circle', value: 10 } or { tag: 'rectangle', value: { x: 1, y: 2 } } + +// Modifiers +t.string().optional() // Nullable +t.u64().primaryKey() // Primary key +t.u64().primaryKey().autoInc() // Auto-increment primary key +``` + +> ⚠️ **BIGINT SYNTAX:** All `u64`, `i64`, and ID fields use JavaScript BigInt. +> - Literals: `0n`, `1n`, `100n` (NOT `0`, `1`, `100`) +> - Comparisons: `row.id === 5n` (NOT `row.id === 5`) +> - Arithmetic: `row.count + 1n` (NOT `row.count + 1`) + +### Auto-increment placeholder +```typescript +// ✅ MUST provide 0n placeholder for auto-inc fields +ctx.db.task.insert({ id: 0n, ownerId: ctx.sender, title: 'New', createdAt: ctx.timestamp }); +``` + +### Insert returns ROW, not ID +```typescript +// ❌ WRONG +const id = ctx.db.task.insert({ ... }); + +// ✅ RIGHT +const row = ctx.db.task.insert({ ... }); +const newId = row.id; // Extract .id from returned row +``` + +### Schema export (CRITICAL) +```typescript +// At end of schema.ts — schema() takes exactly ONE argument: an object +const spacetimedb = schema({ table1, table2, table3 }); +export default spacetimedb; + +// ❌ WRONG — never pass tables directly or as multiple args +schema(myTable); // WRONG! +schema(t1, t2, t3); // WRONG! +``` + +--- + +## 3) Index Access + +### TypeScript Query Patterns + +```typescript +// 1. PRIMARY KEY — use .pkColumn.find() +const user = ctx.db.user.identity.find(ctx.sender); +const msg = ctx.db.message.id.find(messageId); + +// 2. EXPLICIT INDEX — use .indexName.filter(value) +const msgs = [...ctx.db.message.message_room_id.filter(roomId)]; + +// 3. NO INDEX — use .iter() + manual filter +for (const m of ctx.db.roomMember.iter()) { + if (m.roomId === roomId) { /* ... */ } +} +``` + +### Index Definition Syntax + +```typescript +// In table OPTIONS (first argument), not columns +export const Message = table({ + name: 'message', + public: true, + indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + roomId: t.u64(), + // ... +}); +``` + +### Naming conventions + +**Table names — automatic transformation:** +- Schema: `table({ name: 'my_messages' })` +- Access: `ctx.db.myMessages` (automatic snake_case → camelCase) + +**Index names — NO transformation, use EXACTLY as defined:** +```typescript +// Schema definition +indexes: [{ name: 'canvas_member_canvas_id', algorithm: 'btree', columns: ['canvasId'] }] + +// ❌ WRONG — don't assume camelCase transformation +ctx.db.canvasMember.canvasMember_canvas_id.filter(...) // WRONG! +ctx.db.canvasMember.canvasMemberCanvasId.filter(...) // WRONG! + +// ✅ RIGHT — use exact name from schema +ctx.db.canvasMember.canvas_member_canvas_id.filter(...) +``` + +> ⚠️ **Index names are used VERBATIM** — pick a convention (snake_case or camelCase) and stick with it. + +**Index naming pattern — use `{tableName}_{columnName}`:** +```typescript +// ✅ GOOD — unique names across entire module +indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +indexes: [{ name: 'reaction_message_id', algorithm: 'btree', columns: ['messageId'] }] + +// ❌ BAD — will collide if multiple tables use same index name +indexes: [{ name: 'by_owner', ... }] // in Task table +indexes: [{ name: 'by_owner', ... }] // in Note table — CONFLICT! +``` + +**Client-side table names:** +- Check generated `module_bindings/index.ts` for exact export names +- Usage: `useTable(tables.MyMessages)` or `tables.myMessages` (varies by SDK version) + +### Filter vs Find +```typescript +// Filter takes VALUE directly, not object — returns iterator +const rows = [...ctx.db.task.by_owner.filter(ownerId)]; + +// Unique columns use .find() — returns single row or undefined +const row = ctx.db.player.identity.find(ctx.sender); +``` + +### ⚠️ Multi-column indexes are BROKEN +```typescript +// ❌ DON'T — causes PANIC +ctx.db.scores.by_player_level.filter(playerId); + +// ✅ DO — use single-column index + manual filter +for (const row of ctx.db.scores.by_player.filter(playerId)) { + if (row.level === targetLevel) { /* ... */ } +} +``` + +--- + +## 4) Reducers + +### Definition syntax (CRITICAL) +**Reducer name comes from the export — NOT from a string argument.** Use `reducer(params, fn)` or `reducer(fn)`. + +```typescript +import spacetimedb from './schema'; +import { t, SenderError } from 'spacetimedb/server'; + +// ✅ CORRECT — export const name = spacetimedb.reducer(params, fn) +export const reducer_name = spacetimedb.reducer({ param1: t.string(), param2: t.u64() }, (ctx, { param1, param2 }) => { + // Validation + if (!param1) throw new SenderError('param1 required'); + + // Access tables via ctx.db + const row = ctx.db.myTable.primaryKey.find(param2); + + // Mutations + ctx.db.myTable.insert({ ... }); + ctx.db.myTable.primaryKey.update({ ...row, newField: value }); + ctx.db.myTable.primaryKey.delete(param2); +}); + +// No params: export const init = spacetimedb.reducer((ctx) => { ... }); +``` + +```typescript +// ❌ WRONG — reducer('name', params, fn) does NOT exist +spacetimedb.reducer('reducer_name', { param1: t.string() }, (ctx, { param1 }) => { ... }); +``` + +### Update pattern (CRITICAL) +```typescript +// ✅ CORRECT — spread existing row, override specific fields +const existing = ctx.db.task.id.find(taskId); +if (!existing) throw new SenderError('Task not found'); +ctx.db.task.id.update({ ...existing, title: newTitle, updatedAt: ctx.timestamp }); + +// ❌ WRONG — partial update nulls out other fields! +ctx.db.task.id.update({ id: taskId, title: newTitle }); +``` + +### Delete pattern +```typescript +// Delete by primary key VALUE (not row object) +ctx.db.task.id.delete(taskId); // taskId is the u64 value +ctx.db.player.identity.delete(ctx.sender); // delete by identity +``` + +### Lifecycle hooks +```typescript +spacetimedb.clientConnected((ctx) => { + // ctx.sender is the connecting identity + // Create/update user record, set online status, etc. +}); + +spacetimedb.clientDisconnected((ctx) => { + // Clean up: set offline status, remove ephemeral data, etc. +}); +``` + +### Snake_case to camelCase conversion +- Server: `export const do_something = spacetimedb.reducer(...)` — name from export +- Client: `conn.reducers.doSomething({ ... })` + +### Object syntax required +```typescript +// ❌ WRONG - positional +conn.reducers.doSomething('value'); + +// ✅ RIGHT - object +conn.reducers.doSomething({ param: 'value' }); +``` + +--- + +## 5) Scheduled Tables + +```typescript +// 1. Define table first (scheduled: () => reducer — pass the exported reducer) +export const CleanupJob = table({ + name: 'cleanup_job', + scheduled: () => run_cleanup // reducer defined below +}, { + scheduledId: t.u64().primaryKey().autoInc(), + scheduledAt: t.scheduleAt(), + targetId: t.u64(), // Your custom data +}); + +// 2. Define scheduled reducer (receives full row as arg) +export const run_cleanup = spacetimedb.reducer({ arg: CleanupJob.rowType }, (ctx, { arg }) => { + // arg.scheduledId, arg.targetId available + // Row is auto-deleted after reducer completes +}); + +// Schedule a job +import { ScheduleAt } from 'spacetimedb'; +const futureTime = ctx.timestamp.microsSinceUnixEpoch + 60_000_000n; // 60 seconds +ctx.db.cleanupJob.insert({ + scheduledId: 0n, + scheduledAt: ScheduleAt.time(futureTime), + targetId: someId +}); + +// Cancel a job by deleting the row +ctx.db.cleanupJob.scheduledId.delete(jobId); +``` + +--- + +## 6) Timestamps + +### Server-side +```typescript +import { Timestamp, ScheduleAt } from 'spacetimedb'; + +// Current time +ctx.db.item.insert({ id: 0n, createdAt: ctx.timestamp }); + +// Future time (add microseconds) +const future = ctx.timestamp.microsSinceUnixEpoch + 300_000_000n; // 5 minutes +``` + +### Client-side (CRITICAL) +**Timestamps are objects, not numbers:** +```typescript +// ❌ WRONG +const date = new Date(row.createdAt); +const date = new Date(Number(row.createdAt / 1000n)); + +// ✅ RIGHT +const date = new Date(Number(row.createdAt.microsSinceUnixEpoch / 1000n)); +``` + +### ScheduleAt on client +```typescript +// ScheduleAt is a tagged union +if (scheduleAt.tag === 'Time') { + const date = new Date(Number(scheduleAt.value.microsSinceUnixEpoch / 1000n)); +} +``` + +--- + +## 7) Data Visibility & Subscriptions + +**`public: true` exposes ALL rows to ALL clients.** + +| Scenario | Pattern | +|----------|---------| +| Everyone sees all rows | `public: true` | +| Users see only their data | Private table + filtered subscription | + +### Subscription patterns (client-side) +```typescript +// Subscribe to ALL public tables (simplest) +conn.subscriptionBuilder().subscribeToAll(); + +// Subscribe to specific tables with SQL +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM message', + 'SELECT * FROM room WHERE is_public = true', +]); + +// Handle subscription lifecycle +conn.subscriptionBuilder() + .onApplied(() => console.log('Initial data loaded')) + .onError((e) => console.error('Subscription failed:', e)) + .subscribeToAll(); +``` + +### Private table + view pattern (RECOMMENDED) + +**Views are the recommended approach** for controlling data visibility. They provide: +- Server-side filtering (reduces network traffic) +- Real-time updates when underlying data changes +- Full control over what data clients can access + +> ⚠️ **Do NOT use Row Level Security (RLS)** — it is deprecated. + +> ⚠️ **CRITICAL:** Procedural views (views that compute results in code) can ONLY access data via index lookups, NOT `.iter()`. +> If you need a view that scans/filters across many rows (including the entire table), return a **query** built with the query builder (`ctx.from...`). + +```typescript +// Private table with index on ownerId +export const PrivateData = table( + { name: 'private_data', + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] + }, + { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + secret: t.string() + } +); + +// ❌ BAD — .iter() causes performance issues (re-evaluates on ANY row change) +spacetimedb.view( + { name: 'my_data_slow', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.iter()] // Works but VERY slow at scale +); + +// ✅ GOOD — index lookup enables targeted invalidation +spacetimedb.view( + { name: 'my_data', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.by_owner.filter(ctx.sender)] +); +``` + +### Query builder view pattern (can scan) + +```typescript +// Query-builder views return a query; the SQL engine maintains the result incrementally. +// This can scan the whole table if needed (e.g. leaderboard-style queries). +spacetimedb.anonymousView( + { name: 'top_players', public: true }, + t.array(Player.rowType), + (ctx) => + ctx.from.player + .where(p => p.score.gt(1000)) +); +``` + +### ViewContext vs AnonymousViewContext +```typescript +// ViewContext — has ctx.sender, result varies per user (computed per-subscriber) +spacetimedb.view({ name: 'my_items', public: true }, t.array(Item.rowType), (ctx) => { + return [...ctx.db.item.by_owner.filter(ctx.sender)]; +}); + +// AnonymousViewContext — no ctx.sender, same result for everyone (shared, better perf) +spacetimedb.anonymousView({ name: 'leaderboard', public: true }, t.array(LeaderboardRow), (ctx) => { + return [...ctx.db.player.by_score.filter(/* top scores */)]; +}); +``` + +**Views require explicit subscription:** +```typescript +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM public_table', + 'SELECT * FROM my_data', // Views need explicit SQL! +]); +``` + +--- + +## 8) React Integration + +### Key patterns +```typescript +// Memoize connectionBuilder to prevent reconnects on re-render +const builder = useMemo(() => + DbConnection.builder() + .withUri(SPACETIMEDB_URI) + .withDatabaseName(MODULE_NAME) + .withToken(localStorage.getItem('auth_token') || undefined) + .onConnect(onConnect) + .onConnectError(onConnectError), + [] // Empty deps - only create once +); + +// useTable returns tuple [rows, isLoading] +const [rows, isLoading] = useTable(tables.myTable); + +// Compare identities using toHexString() +const isOwner = row.ownerId.toHexString() === myIdentity.toHexString(); +``` + +--- + +## 9) Procedures (Beta) + +**Procedures are for side effects (HTTP requests, etc.) that reducers can't do.** + +⚠️ Procedures are currently in beta. API may change. + +### Defining a procedure +**Procedure name comes from the export — NOT from a string argument.** Use `procedure(params, ret, fn)` or `procedure(ret, fn)`. + +```typescript +// ✅ CORRECT — export const name = spacetimedb.procedure(params, ret, fn) +export const fetch_external_data = spacetimedb.procedure( + { url: t.string() }, + t.string(), // return type + (ctx, { url }) => { + const response = ctx.http.fetch(url); + return response.text(); + } +); +``` + +### Database access in procedures + +⚠️ **CRITICAL: Procedures don't have `ctx.db`. Use `ctx.withTx()` for database access.** + +```typescript +spacetimedb.procedure({ url: t.string() }, t.unit(), (ctx, { url }) => { + // Fetch external data (outside transaction) + const response = ctx.http.fetch(url); + const data = response.text(); + + // ❌ WRONG — ctx.db doesn't exist in procedures + ctx.db.myTable.insert({ ... }); + + // ✅ RIGHT — use ctx.withTx() for database access + ctx.withTx(tx => { + tx.db.myTable.insert({ + id: 0n, + content: data, + fetchedAt: tx.timestamp, + fetchedBy: tx.sender, + }); + }); + + return {}; +}); +``` + +### Key differences from reducers +| Reducers | Procedures | +|----------|------------| +| `ctx.db` available directly | Must use `ctx.withTx(tx => tx.db...)` | +| Automatic transaction | Manual transaction management | +| No HTTP/network | `ctx.http.fetch()` available | +| No return values to caller | Can return data to caller | + +--- + +## 10) Project Structure + +### Server (`backend/spacetimedb/`) +``` +src/schema.ts → Tables, export spacetimedb +src/index.ts → Reducers, lifecycle, import schema +package.json → { "type": "module", "dependencies": { "spacetimedb": "^1.11.0" } } +tsconfig.json → Standard config +``` + +### Avoiding circular imports +``` +schema.ts → defines tables AND exports spacetimedb +index.ts → imports spacetimedb from ./schema, defines reducers +``` + +### Client (`client/`) +``` +src/module_bindings/ → Generated (spacetime generate) +src/main.tsx → Provider, connection setup +src/App.tsx → UI components +src/config.ts → MODULE_NAME, SPACETIMEDB_URI +``` + +--- + +## 11) Commands + +```bash +# Start local server +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear database and republish +spacetime publish --clear-database -y --module-path + +# Generate bindings +spacetime generate --lang typescript --out-dir /src/module_bindings --module-path + +# View logs +spacetime logs +``` + +--- + +## 12) Hard Requirements + +**TypeScript-specific:** + +1. **`schema({ table })`** — takes exactly one object; never `schema(table)` or `schema(t1, t2, t3)` +2. **Reducer/procedure names from exports** — `export const name = spacetimedb.reducer(params, fn)`; never `reducer('name', ...)` +3. **Reducer calls use object syntax** — `{ param: 'value' }` not positional args +4. **Import `DbConnection` from `./module_bindings`** — not from `spacetimedb` +5. **DO NOT edit generated bindings** — regenerate with `spacetime generate` +6. **Indexes go in OPTIONS (1st arg)** — not in COLUMNS (2nd arg) of `table()` +7. **Use BigInt for u64/i64 fields** — `0n`, `1n`, not `0`, `1` +8. **Reducers are transactional** — they do not return data +9. **Reducers must be deterministic** — no filesystem, network, timers, random +10. **Views should use index lookups** — `.iter()` causes severe performance issues +11. **Procedures need `ctx.withTx()`** — `ctx.db` doesn't exist in procedures +12. **Sum type values** — use `{ tag: 'variant', value: payload }` not `{ variant: payload }` diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..ecc61b6 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,29 @@ +# quickstart-chat + +## 0.0.1 + +### Patch Changes + +- Updated dependencies [[`cf7b7d8`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/cf7b7d89a1547fb3863f6641f5b2eb40a27c05d8), [`941cf4e`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/941cf4eba6b7df934d74696b373b89cc62764673), [`a501f5c`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/a501f5ccf9a0a926eb4f345ddeb01ffcb872d67e), [`9032269`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/9032269004d4dae587c39ccd85da0a32fb9a0114), [`6547882`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/6547882bb28ed9a1ca436335745e9997328026ff), [`5d7304b`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/5d7304bd3e05dd7a032cfb7069aab97b881f0179)]: + - @clockworklabs/spacetimedb-sdk@1.2.0 + +## 0.0.3-rc1.0 + +### Patch Changes + +- Updated dependencies [[`cf7b7d8`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/cf7b7d89a1547fb3863f6641f5b2eb40a27c05d8), [`a501f5c`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/a501f5ccf9a0a926eb4f345ddeb01ffcb872d67e), [`9032269`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/9032269004d4dae587c39ccd85da0a32fb9a0114), [`6547882`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/6547882bb28ed9a1ca436335745e9997328026ff), [`5d7304b`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/5d7304bd3e05dd7a032cfb7069aab97b881f0179)]: + - @clockworklabs/spacetimedb-sdk@1.0.0-rc1.0 + +## 0.0.2 + +### Patch Changes + +- Updated dependencies [[`2f6c82c`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/2f6c82c724b9f9407c7bedee13252ca8ffab8f7d), [`b9db9b6`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/b9db9b6e46d8c98b29327d97c12c07b7a2fc96bf), [`79c278b`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/79c278be71b2dfd82106ada983fd81d395b1d912)]: + - @clockworklabs/spacetimedb-sdk@0.12.1 + +## 0.0.1 + +### Patch Changes + +- Updated dependencies [[`5adb557`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/5adb55776c81d0760cf0268df0fa5dee600f0ef8), [`ab1f463`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/ab1f463d7da6e530a6cd47e2433141bfd16addd1), [`b8c944c`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/b8c944cd23d3b53c72131803a775127bf0a95213), [`17227c0`](https://github.com/clockworklabs/spacetimedb-typescript-sdk/commit/17227c0f65def3a9d5e767756ccf46777210041a)]: + - @clockworklabs/spacetimedb-sdk@0.12.0 diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..c58f00b --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,766 @@ +# SpacetimeDB Rules (All Languages) + +## Migrating from 1.0 to 2.0? + +**If you are migrating existing SpacetimeDB 1.0 code to 2.0, apply `spacetimedb-migration-2.0.mdc` first.** It documents breaking changes (reducer callbacks → event tables, `name`→`accessor`, `sender()` method, etc.) and should be considered before other rules. + +--- + +## Language-Specific Rules + +| Language | Rule File | +|----------|-----------| +| **TypeScript/React** | `spacetimedb-typescript.mdc` (MANDATORY) | +| **Rust** | `spacetimedb-rust.mdc` (MANDATORY) | +| **C#** | `spacetimedb-csharp.mdc` (MANDATORY) | +| **Migrating 1.0 → 2.0** | `spacetimedb-migration-2.0.mdc` | + +--- + +## Core Concepts + +1. **Reducers are transactional** — they do not return data to callers +2. **Reducers must be deterministic** — no filesystem, network, timers, or random +3. **Read data via tables/subscriptions** — not reducer return values +4. **Auto-increment IDs are not sequential** — gaps are normal, don't use for ordering +5. **`ctx.sender` is the authenticated principal** — never trust identity args + +--- + +## Feature Implementation Checklist + +When implementing a feature that spans backend and client: + +1. **Backend:** Define table(s) to store the data +2. **Backend:** Define reducer(s) to mutate the data +3. **Client:** Subscribe to the table(s) +4. **Client:** Call the reducer(s) from UI — **don't forget this step!** +5. **Client:** Render the data from the table(s) + +**Common mistake:** Building backend tables/reducers but forgetting to wire up the client to call them. + +--- + +## Index System + +SpacetimeDB automatically creates indexes for: +- Primary key columns +- Columns marked as unique + +You can add explicit indexes on non-unique columns for query performance. + +**Index names must be unique across your entire module (all tables).** If two tables have indexes with the same declared name → conflict error. + +**Schema ↔ Code coupling:** +- Your query code references indexes by name +- If you add/remove/rename an index in the schema, update all code that uses it +- Removing an index without updating queries causes runtime errors + +--- + +## Commands + +```bash +# Login to allow remote database deployment e.g. to maincloud +spacetime login + +# Start local SpacetimeDB +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear and republish +spacetime publish --clear-database -y --module-path + +# Generate client bindings +spacetime generate --lang --out-dir --module-path + +# View logs +spacetime logs +``` + +--- + +## Deployment + +- Maincloud is the spacetimedb hosted cloud and the default location for module publishing +- The default server marked by *** in `spacetime server list` should be used when publishing +- If the default server is maincloud you should publish to maincloud +- Publishing to maincloud is free of charge +- When publishing to maincloud the database dashboard will be at the url: https://spacetimedb.com/@/ +- The database owner can view utilization and performance metrics on the dashboard + +--- + +## Debugging Checklist + +1. Is SpacetimeDB server running? (`spacetime start`) +2. Is the module published? (`spacetime publish`) +3. Are client bindings generated? (`spacetime generate`) +4. Check server logs for errors (`spacetime logs `) +5. **Is the reducer actually being called from the client?** + +--- + +## Editing Behavior + +- Make the smallest change necessary +- Do NOT touch unrelated files, configs, or dependencies +- Do NOT invent new SpacetimeDB APIs — use only what exists in docs or this repo +- Do NOT add restrictions the prompt didn't ask for — if "users can do X", implement X for all users + + +# SpacetimeDB TypeScript SDK + +## ⛔ HALLUCINATED APIs — DO NOT USE + +**These APIs DO NOT EXIST. LLMs frequently hallucinate them.** + +```typescript +// ❌ WRONG PACKAGE — does not exist +import { SpacetimeDBClient } from "@clockworklabs/spacetimedb-sdk"; + +// ❌ WRONG — these methods don't exist +SpacetimeDBClient.connect(...); +SpacetimeDBClient.call("reducer_name", [...]); +connection.call("reducer_name", [arg1, arg2]); + +// ❌ WRONG — positional reducer arguments +conn.reducers.doSomething("value"); // WRONG! + +// ❌ WRONG — static methods on generated types don't exist +User.filterByName('alice'); +Message.findById(123n); +tables.user.filter(u => u.name === 'alice'); // No .filter() on tables object! +``` + +### ✅ CORRECT PATTERNS: + +```typescript +// ✅ CORRECT IMPORTS +import { DbConnection, tables } from './module_bindings'; // Generated! +import { SpacetimeDBProvider, useTable, Identity } from 'spacetimedb/react'; + +// ✅ CORRECT REDUCER CALLS — object syntax, not positional! +conn.reducers.doSomething({ value: 'test' }); +conn.reducers.updateItem({ itemId: 1n, newValue: 42 }); + +// ✅ CORRECT DATA ACCESS — useTable returns [rows, isLoading] +const [items, isLoading] = useTable(tables.item); +``` + +### ⛔ DO NOT: +- **Invent hooks** like `useItems()`, `useData()` — use `useTable(tables.tableName)` +- **Import from fake packages** — only `spacetimedb`, `spacetimedb/react`, `./module_bindings` + +--- + +## 1) Common Mistakes Table + +### Server-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| Missing `package.json` | Create `package.json` | "could not detect language" | +| Missing `tsconfig.json` | Create `tsconfig.json` | "TsconfigNotFound" | +| Entrypoint not at `src/index.ts` | Use `src/index.ts` | Module won't bundle | +| `indexes` in COLUMNS (2nd arg) | `indexes` in OPTIONS (1st arg) | "reading 'tag'" error | +| Index without `algorithm` | `algorithm: 'btree'` | "reading 'tag'" error | +| `filter({ ownerId })` | `filter(ownerId)` | "does not exist in type 'Range'" | +| `.filter()` on unique column | `.find()` on unique column | TypeError | +| `insert({ ...without id })` | `insert({ id: 0n, ... })` | "Property 'id' is missing" | +| `const id = table.insert(...)` | `const row = table.insert(...)` | `.insert()` returns ROW, not ID | +| `.unique()` + explicit index | Just use `.unique()` | "name is used for multiple entities" | +| Index on `.primaryKey()` column | Don't — already indexed | "name is used for multiple entities" | +| Same index name in multiple tables | Prefix with table name | "name is used for multiple entities" | +| `.indexName.filter()` after removing index | Use `.iter()` + manual filter | "Cannot read properties of undefined" | +| Import spacetimedb from index.ts | Import from schema.ts | "Cannot access before initialization" | +| Multi-column index `.filter()` | **⚠️ BROKEN** — use single-column | PANIC or silent empty results | +| `JSON.stringify({ id: row.id })` | Convert BigInt first: `{ id: row.id.toString() }` | "Do not know how to serialize a BigInt" | +| `ScheduleAt.Time(timestamp)` | `ScheduleAt.time(timestamp)` (lowercase) | "ScheduleAt.Time is not a function" | +| `ctx.db.foo.myIndexName.filter()` | Use exact name: `ctx.db.foo.my_index_name.filter()` | "Cannot read properties of undefined" | +| `.iter()` in views | Use index lookups | Severe performance issues (re-evaluates on any change) | +| `ctx.db` in procedures | `ctx.withTx(tx => tx.db...)` | Procedures need explicit transactions | +| `ctx.myTable` in procedure tx | `tx.db.myTable` | Wrong context variable | + +### Client-side errors + +| Wrong | Right | Error | +|-------|-------|-------| +| `@spacetimedb/sdk` | `spacetimedb` | 404 / missing subpath | +| `conn.reducers.foo("val")` | `conn.reducers.foo({ param: "val" })` | Wrong reducer syntax | +| Inline `connectionBuilder` | `useMemo(() => ..., [])` | Reconnects every render | +| `const rows = useTable(table)` | `const [rows, isLoading] = useTable(table)` | Tuple destructuring | +| Optimistic UI updates | Let subscriptions drive state | Desync issues | +| `` | `connectionBuilder={...}` | Wrong prop name | + +--- + +## 2) Table Definition (CRITICAL) + +**`table()` takes TWO arguments: `table(OPTIONS, COLUMNS)`** + +```typescript +import { schema, table, t } from 'spacetimedb/server'; + +// ❌ WRONG — indexes in COLUMNS causes "reading 'tag'" error +export const Task = table({ name: 'task' }, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] // ❌ WRONG! +}); + +// ✅ RIGHT — indexes in OPTIONS (first argument) +export const Task = table({ + name: 'task', + public: true, + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + title: t.string(), + createdAt: t.timestamp(), +}); +``` + +### Column types +```typescript +t.identity() // User identity (primary key for per-user tables) +t.u64() // Unsigned 64-bit integer (use for IDs) +t.string() // Text +t.bool() // Boolean +t.timestamp() // Timestamp (use ctx.timestamp for current time) +t.scheduleAt() // For scheduled tables only + +// Product types (nested objects) — use t.object, NOT t.struct +const Point = t.object('Point', { x: t.i32(), y: t.i32() }); + +// Sum types (tagged unions) — use t.enum, NOT t.sum +const Shape = t.enum('Shape', { circle: t.i32(), rectangle: Point }); +// Values use { tag: 'circle', value: 10 } or { tag: 'rectangle', value: { x: 1, y: 2 } } + +// Modifiers +t.string().optional() // Nullable +t.u64().primaryKey() // Primary key +t.u64().primaryKey().autoInc() // Auto-increment primary key +``` + +> ⚠️ **BIGINT SYNTAX:** All `u64`, `i64`, and ID fields use JavaScript BigInt. +> - Literals: `0n`, `1n`, `100n` (NOT `0`, `1`, `100`) +> - Comparisons: `row.id === 5n` (NOT `row.id === 5`) +> - Arithmetic: `row.count + 1n` (NOT `row.count + 1`) + +### Auto-increment placeholder +```typescript +// ✅ MUST provide 0n placeholder for auto-inc fields +ctx.db.task.insert({ id: 0n, ownerId: ctx.sender, title: 'New', createdAt: ctx.timestamp }); +``` + +### Insert returns ROW, not ID +```typescript +// ❌ WRONG +const id = ctx.db.task.insert({ ... }); + +// ✅ RIGHT +const row = ctx.db.task.insert({ ... }); +const newId = row.id; // Extract .id from returned row +``` + +### Schema export (CRITICAL) +```typescript +// At end of schema.ts — schema() takes exactly ONE argument: an object +const spacetimedb = schema({ table1, table2, table3 }); +export default spacetimedb; + +// ❌ WRONG — never pass tables directly or as multiple args +schema(myTable); // WRONG! +schema(t1, t2, t3); // WRONG! +``` + +--- + +## 3) Index Access + +### TypeScript Query Patterns + +```typescript +// 1. PRIMARY KEY — use .pkColumn.find() +const user = ctx.db.user.identity.find(ctx.sender); +const msg = ctx.db.message.id.find(messageId); + +// 2. EXPLICIT INDEX — use .indexName.filter(value) +const msgs = [...ctx.db.message.message_room_id.filter(roomId)]; + +// 3. NO INDEX — use .iter() + manual filter +for (const m of ctx.db.roomMember.iter()) { + if (m.roomId === roomId) { /* ... */ } +} +``` + +### Index Definition Syntax + +```typescript +// In table OPTIONS (first argument), not columns +export const Message = table({ + name: 'message', + public: true, + indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +}, { + id: t.u64().primaryKey().autoInc(), + roomId: t.u64(), + // ... +}); +``` + +### Naming conventions + +**Table names — automatic transformation:** +- Schema: `table({ name: 'my_messages' })` +- Access: `ctx.db.myMessages` (automatic snake_case → camelCase) + +**Index names — NO transformation, use EXACTLY as defined:** +```typescript +// Schema definition +indexes: [{ name: 'canvas_member_canvas_id', algorithm: 'btree', columns: ['canvasId'] }] + +// ❌ WRONG — don't assume camelCase transformation +ctx.db.canvasMember.canvasMember_canvas_id.filter(...) // WRONG! +ctx.db.canvasMember.canvasMemberCanvasId.filter(...) // WRONG! + +// ✅ RIGHT — use exact name from schema +ctx.db.canvasMember.canvas_member_canvas_id.filter(...) +``` + +> ⚠️ **Index names are used VERBATIM** — pick a convention (snake_case or camelCase) and stick with it. + +**Index naming pattern — use `{tableName}_{columnName}`:** +```typescript +// ✅ GOOD — unique names across entire module +indexes: [{ name: 'message_room_id', algorithm: 'btree', columns: ['roomId'] }] +indexes: [{ name: 'reaction_message_id', algorithm: 'btree', columns: ['messageId'] }] + +// ❌ BAD — will collide if multiple tables use same index name +indexes: [{ name: 'by_owner', ... }] // in Task table +indexes: [{ name: 'by_owner', ... }] // in Note table — CONFLICT! +``` + +**Client-side table names:** +- Check generated `module_bindings/index.ts` for exact export names +- Usage: `useTable(tables.MyMessages)` or `tables.myMessages` (varies by SDK version) + +### Filter vs Find +```typescript +// Filter takes VALUE directly, not object — returns iterator +const rows = [...ctx.db.task.by_owner.filter(ownerId)]; + +// Unique columns use .find() — returns single row or undefined +const row = ctx.db.player.identity.find(ctx.sender); +``` + +### ⚠️ Multi-column indexes are BROKEN +```typescript +// ❌ DON'T — causes PANIC +ctx.db.scores.by_player_level.filter(playerId); + +// ✅ DO — use single-column index + manual filter +for (const row of ctx.db.scores.by_player.filter(playerId)) { + if (row.level === targetLevel) { /* ... */ } +} +``` + +--- + +## 4) Reducers + +### Definition syntax (CRITICAL) +**Reducer name comes from the export — NOT from a string argument.** Use `reducer(params, fn)` or `reducer(fn)`. + +```typescript +import spacetimedb from './schema'; +import { t, SenderError } from 'spacetimedb/server'; + +// ✅ CORRECT — export const name = spacetimedb.reducer(params, fn) +export const reducer_name = spacetimedb.reducer({ param1: t.string(), param2: t.u64() }, (ctx, { param1, param2 }) => { + // Validation + if (!param1) throw new SenderError('param1 required'); + + // Access tables via ctx.db + const row = ctx.db.myTable.primaryKey.find(param2); + + // Mutations + ctx.db.myTable.insert({ ... }); + ctx.db.myTable.primaryKey.update({ ...row, newField: value }); + ctx.db.myTable.primaryKey.delete(param2); +}); + +// No params: export const init = spacetimedb.reducer((ctx) => { ... }); +``` + +```typescript +// ❌ WRONG — reducer('name', params, fn) does NOT exist +spacetimedb.reducer('reducer_name', { param1: t.string() }, (ctx, { param1 }) => { ... }); +``` + +### Update pattern (CRITICAL) +```typescript +// ✅ CORRECT — spread existing row, override specific fields +const existing = ctx.db.task.id.find(taskId); +if (!existing) throw new SenderError('Task not found'); +ctx.db.task.id.update({ ...existing, title: newTitle, updatedAt: ctx.timestamp }); + +// ❌ WRONG — partial update nulls out other fields! +ctx.db.task.id.update({ id: taskId, title: newTitle }); +``` + +### Delete pattern +```typescript +// Delete by primary key VALUE (not row object) +ctx.db.task.id.delete(taskId); // taskId is the u64 value +ctx.db.player.identity.delete(ctx.sender); // delete by identity +``` + +### Lifecycle hooks +```typescript +spacetimedb.clientConnected((ctx) => { + // ctx.sender is the connecting identity + // Create/update user record, set online status, etc. +}); + +spacetimedb.clientDisconnected((ctx) => { + // Clean up: set offline status, remove ephemeral data, etc. +}); +``` + +### Snake_case to camelCase conversion +- Server: `export const do_something = spacetimedb.reducer(...)` — name from export +- Client: `conn.reducers.doSomething({ ... })` + +### Object syntax required +```typescript +// ❌ WRONG - positional +conn.reducers.doSomething('value'); + +// ✅ RIGHT - object +conn.reducers.doSomething({ param: 'value' }); +``` + +--- + +## 5) Scheduled Tables + +```typescript +// 1. Define table first (scheduled: () => reducer — pass the exported reducer) +export const CleanupJob = table({ + name: 'cleanup_job', + scheduled: () => run_cleanup // reducer defined below +}, { + scheduledId: t.u64().primaryKey().autoInc(), + scheduledAt: t.scheduleAt(), + targetId: t.u64(), // Your custom data +}); + +// 2. Define scheduled reducer (receives full row as arg) +export const run_cleanup = spacetimedb.reducer({ arg: CleanupJob.rowType }, (ctx, { arg }) => { + // arg.scheduledId, arg.targetId available + // Row is auto-deleted after reducer completes +}); + +// Schedule a job +import { ScheduleAt } from 'spacetimedb'; +const futureTime = ctx.timestamp.microsSinceUnixEpoch + 60_000_000n; // 60 seconds +ctx.db.cleanupJob.insert({ + scheduledId: 0n, + scheduledAt: ScheduleAt.time(futureTime), + targetId: someId +}); + +// Cancel a job by deleting the row +ctx.db.cleanupJob.scheduledId.delete(jobId); +``` + +--- + +## 6) Timestamps + +### Server-side +```typescript +import { Timestamp, ScheduleAt } from 'spacetimedb'; + +// Current time +ctx.db.item.insert({ id: 0n, createdAt: ctx.timestamp }); + +// Future time (add microseconds) +const future = ctx.timestamp.microsSinceUnixEpoch + 300_000_000n; // 5 minutes +``` + +### Client-side (CRITICAL) +**Timestamps are objects, not numbers:** +```typescript +// ❌ WRONG +const date = new Date(row.createdAt); +const date = new Date(Number(row.createdAt / 1000n)); + +// ✅ RIGHT +const date = new Date(Number(row.createdAt.microsSinceUnixEpoch / 1000n)); +``` + +### ScheduleAt on client +```typescript +// ScheduleAt is a tagged union +if (scheduleAt.tag === 'Time') { + const date = new Date(Number(scheduleAt.value.microsSinceUnixEpoch / 1000n)); +} +``` + +--- + +## 7) Data Visibility & Subscriptions + +**`public: true` exposes ALL rows to ALL clients.** + +| Scenario | Pattern | +|----------|---------| +| Everyone sees all rows | `public: true` | +| Users see only their data | Private table + filtered subscription | + +### Subscription patterns (client-side) +```typescript +// Subscribe to ALL public tables (simplest) +conn.subscriptionBuilder().subscribeToAll(); + +// Subscribe to specific tables with SQL +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM message', + 'SELECT * FROM room WHERE is_public = true', +]); + +// Handle subscription lifecycle +conn.subscriptionBuilder() + .onApplied(() => console.log('Initial data loaded')) + .onError((e) => console.error('Subscription failed:', e)) + .subscribeToAll(); +``` + +### Private table + view pattern (RECOMMENDED) + +**Views are the recommended approach** for controlling data visibility. They provide: +- Server-side filtering (reduces network traffic) +- Real-time updates when underlying data changes +- Full control over what data clients can access + +> ⚠️ **Do NOT use Row Level Security (RLS)** — it is deprecated. + +> ⚠️ **CRITICAL:** Procedural views (views that compute results in code) can ONLY access data via index lookups, NOT `.iter()`. +> If you need a view that scans/filters across many rows (including the entire table), return a **query** built with the query builder (`ctx.from...`). + +```typescript +// Private table with index on ownerId +export const PrivateData = table( + { name: 'private_data', + indexes: [{ name: 'by_owner', algorithm: 'btree', columns: ['ownerId'] }] + }, + { + id: t.u64().primaryKey().autoInc(), + ownerId: t.identity(), + secret: t.string() + } +); + +// ❌ BAD — .iter() causes performance issues (re-evaluates on ANY row change) +spacetimedb.view( + { name: 'my_data_slow', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.iter()] // Works but VERY slow at scale +); + +// ✅ GOOD — index lookup enables targeted invalidation +spacetimedb.view( + { name: 'my_data', public: true }, + t.array(PrivateData.rowType), + (ctx) => [...ctx.db.privateData.by_owner.filter(ctx.sender)] +); +``` + +### Query builder view pattern (can scan) + +```typescript +// Query-builder views return a query; the SQL engine maintains the result incrementally. +// This can scan the whole table if needed (e.g. leaderboard-style queries). +spacetimedb.anonymousView( + { name: 'top_players', public: true }, + t.array(Player.rowType), + (ctx) => + ctx.from.player + .where(p => p.score.gt(1000)) +); +``` + +### ViewContext vs AnonymousViewContext +```typescript +// ViewContext — has ctx.sender, result varies per user (computed per-subscriber) +spacetimedb.view({ name: 'my_items', public: true }, t.array(Item.rowType), (ctx) => { + return [...ctx.db.item.by_owner.filter(ctx.sender)]; +}); + +// AnonymousViewContext — no ctx.sender, same result for everyone (shared, better perf) +spacetimedb.anonymousView({ name: 'leaderboard', public: true }, t.array(LeaderboardRow), (ctx) => { + return [...ctx.db.player.by_score.filter(/* top scores */)]; +}); +``` + +**Views require explicit subscription:** +```typescript +conn.subscriptionBuilder().subscribe([ + 'SELECT * FROM public_table', + 'SELECT * FROM my_data', // Views need explicit SQL! +]); +``` + +--- + +## 8) React Integration + +### Key patterns +```typescript +// Memoize connectionBuilder to prevent reconnects on re-render +const builder = useMemo(() => + DbConnection.builder() + .withUri(SPACETIMEDB_URI) + .withDatabaseName(MODULE_NAME) + .withToken(localStorage.getItem('auth_token') || undefined) + .onConnect(onConnect) + .onConnectError(onConnectError), + [] // Empty deps - only create once +); + +// useTable returns tuple [rows, isLoading] +const [rows, isLoading] = useTable(tables.myTable); + +// Compare identities using toHexString() +const isOwner = row.ownerId.toHexString() === myIdentity.toHexString(); +``` + +--- + +## 9) Procedures (Beta) + +**Procedures are for side effects (HTTP requests, etc.) that reducers can't do.** + +⚠️ Procedures are currently in beta. API may change. + +### Defining a procedure +**Procedure name comes from the export — NOT from a string argument.** Use `procedure(params, ret, fn)` or `procedure(ret, fn)`. + +```typescript +// ✅ CORRECT — export const name = spacetimedb.procedure(params, ret, fn) +export const fetch_external_data = spacetimedb.procedure( + { url: t.string() }, + t.string(), // return type + (ctx, { url }) => { + const response = ctx.http.fetch(url); + return response.text(); + } +); +``` + +### Database access in procedures + +⚠️ **CRITICAL: Procedures don't have `ctx.db`. Use `ctx.withTx()` for database access.** + +```typescript +spacetimedb.procedure({ url: t.string() }, t.unit(), (ctx, { url }) => { + // Fetch external data (outside transaction) + const response = ctx.http.fetch(url); + const data = response.text(); + + // ❌ WRONG — ctx.db doesn't exist in procedures + ctx.db.myTable.insert({ ... }); + + // ✅ RIGHT — use ctx.withTx() for database access + ctx.withTx(tx => { + tx.db.myTable.insert({ + id: 0n, + content: data, + fetchedAt: tx.timestamp, + fetchedBy: tx.sender, + }); + }); + + return {}; +}); +``` + +### Key differences from reducers +| Reducers | Procedures | +|----------|------------| +| `ctx.db` available directly | Must use `ctx.withTx(tx => tx.db...)` | +| Automatic transaction | Manual transaction management | +| No HTTP/network | `ctx.http.fetch()` available | +| No return values to caller | Can return data to caller | + +--- + +## 10) Project Structure + +### Server (`backend/spacetimedb/`) +``` +src/schema.ts → Tables, export spacetimedb +src/index.ts → Reducers, lifecycle, import schema +package.json → { "type": "module", "dependencies": { "spacetimedb": "^1.11.0" } } +tsconfig.json → Standard config +``` + +### Avoiding circular imports +``` +schema.ts → defines tables AND exports spacetimedb +index.ts → imports spacetimedb from ./schema, defines reducers +``` + +### Client (`client/`) +``` +src/module_bindings/ → Generated (spacetime generate) +src/main.tsx → Provider, connection setup +src/App.tsx → UI components +src/config.ts → MODULE_NAME, SPACETIMEDB_URI +``` + +--- + +## 11) Commands + +```bash +# Start local server +spacetime start + +# Publish module +spacetime publish --module-path + +# Clear database and republish +spacetime publish --clear-database -y --module-path + +# Generate bindings +spacetime generate --lang typescript --out-dir /src/module_bindings --module-path + +# View logs +spacetime logs +``` + +--- + +## 12) Hard Requirements + +**TypeScript-specific:** + +1. **`schema({ table })`** — takes exactly one object; never `schema(table)` or `schema(t1, t2, t3)` +2. **Reducer/procedure names from exports** — `export const name = spacetimedb.reducer(params, fn)`; never `reducer('name', ...)` +3. **Reducer calls use object syntax** — `{ param: 'value' }` not positional args +4. **Import `DbConnection` from `./module_bindings`** — not from `spacetimedb` +5. **DO NOT edit generated bindings** — regenerate with `spacetime generate` +6. **Indexes go in OPTIONS (1st arg)** — not in COLUMNS (2nd arg) of `table()` +7. **Use BigInt for u64/i64 fields** — `0n`, `1n`, not `0`, `1` +8. **Reducers are transactional** — they do not return data +9. **Reducers must be deterministic** — no filesystem, network, timers, random +10. **Views should use index lookups** — `.iter()` causes severe performance issues +11. **Procedures need `ctx.withTx()`** — `ctx.db` doesn't exist in procedures +12. **Sum type values** — use `{ tag: 'variant', value: payload }` not `{ variant: payload }` diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..982d9c5 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2025 Clockwork Labs, Inc + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/README.md b/README.md new file mode 100644 index 0000000..92a1c58 --- /dev/null +++ b/README.md @@ -0,0 +1,67 @@ +# SpacetimeDB TypeScript Quickstart Chat + +This is a simple chat application that demonstrates how to use SpacetimeDB with TypeScript and React. The chat application is a simple chat room where users can send messages to each other. The chat application uses SpacetimeDB to store the chat messages. + +It is based directly on the plain React + TypeScript + Vite template. You can follow the quickstart guide for how creating this project from scratch at [SpacetimeDB TypeScript Quickstart](https://spacetimedb.com/docs/sdks/typescript/quickstart). + +You can follow the instructions for creating your own SpacetimeDB module here: [SpacetimeDB Rust Module Quickstart](https://spacetimedb.com/docs/modules/rust/quickstart). Place the module in the `quickstart-chat/server` directory for compability with this project. + +In order to run this example, you need to: + +- `pnpm build` in the root directory (`spacetimedb-typescriptsdk`) +- `pnpm install` in this directory +- `pnpm build` in this directory +- `pnpm dev` in this directory to run the example + +Below is copied from the original template README: + +# React + TypeScript + Vite + +This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules. + +Currently, two official plugins are available: + +- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh +- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh + +## Expanding the ESLint configuration + +If you are developing a production application, we recommend updating the configuration to enable type aware lint rules: + +- Configure the top-level `parserOptions` property like this: + +```js +export default tseslint.config({ + languageOptions: { + // other options... + parserOptions: { + project: ['./tsconfig.node.json', './tsconfig.app.json'], + tsconfigRootDir: import.meta.dirname, + }, + }, +}); +``` + +- Replace `tseslint.configs.recommended` to `tseslint.configs.recommendedTypeChecked` or `tseslint.configs.strictTypeChecked` +- Optionally add `...tseslint.configs.stylisticTypeChecked` +- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and update the config: + +```js +// eslint.config.js +import react from 'eslint-plugin-react'; + +export default tseslint.config({ + // Set the react version + settings: { react: { version: '18.3' } }, + plugins: { + // Add the react plugin + react, + }, + rules: { + // other rules... + // Enable its recommended rules + ...react.configs.recommended.rules, + ...react.configs['jsx-runtime'].rules, + }, +}); +``` diff --git a/dist/assets/index-DnMf931V.js b/dist/assets/index-DnMf931V.js new file mode 100644 index 0000000..5ea303c --- /dev/null +++ b/dist/assets/index-DnMf931V.js @@ -0,0 +1,86 @@ +(function(){const n=document.createElement("link").relList;if(n&&n.supports&&n.supports("modulepreload"))return;for(const c of document.querySelectorAll('link[rel="modulepreload"]'))a(c);new MutationObserver(c=>{for(const f of c)if(f.type==="childList")for(const p of f.addedNodes)p.tagName==="LINK"&&p.rel==="modulepreload"&&a(p)}).observe(document,{childList:!0,subtree:!0});function s(c){const f={};return c.integrity&&(f.integrity=c.integrity),c.referrerPolicy&&(f.referrerPolicy=c.referrerPolicy),c.crossOrigin==="use-credentials"?f.credentials="include":c.crossOrigin==="anonymous"?f.credentials="omit":f.credentials="same-origin",f}function a(c){if(c.ep)return;c.ep=!0;const f=s(c);fetch(c.href,f)}})();function yh(r){return r&&r.__esModule&&Object.prototype.hasOwnProperty.call(r,"default")?r.default:r}var ru={exports:{}},ws={},nu={exports:{}},ve={};var Nf;function xm(){if(Nf)return ve;Nf=1;var r=Symbol.for("react.element"),n=Symbol.for("react.portal"),s=Symbol.for("react.fragment"),a=Symbol.for("react.strict_mode"),c=Symbol.for("react.profiler"),f=Symbol.for("react.provider"),p=Symbol.for("react.context"),v=Symbol.for("react.forward_ref"),y=Symbol.for("react.suspense"),x=Symbol.for("react.memo"),R=Symbol.for("react.lazy"),N=Symbol.iterator;function j(w){return w===null||typeof w!="object"?null:(w=N&&w[N]||w["@@iterator"],typeof w=="function"?w:null)}var O={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},q=Object.assign,Q={};function $(w,E,ee){this.props=w,this.context=E,this.refs=Q,this.updater=ee||O}$.prototype.isReactComponent={},$.prototype.setState=function(w,E){if(typeof w!="object"&&typeof w!="function"&&w!=null)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,w,E,"setState")},$.prototype.forceUpdate=function(w){this.updater.enqueueForceUpdate(this,w,"forceUpdate")};function fe(){}fe.prototype=$.prototype;function T(w,E,ee){this.props=w,this.context=E,this.refs=Q,this.updater=ee||O}var A=T.prototype=new fe;A.constructor=T,q(A,$.prototype),A.isPureReactComponent=!0;var L=Array.isArray,J=Object.prototype.hasOwnProperty,Y={current:null},ge={key:!0,ref:!0,__self:!0,__source:!0};function me(w,E,ee){var ne,te={},le=null,ie=null;if(E!=null)for(ne in E.ref!==void 0&&(ie=E.ref),E.key!==void 0&&(le=""+E.key),E)J.call(E,ne)&&!ge.hasOwnProperty(ne)&&(te[ne]=E[ne]);var he=arguments.length-2;if(he===1)te.children=ee;else if(1>>1,E=M[w];if(0>>1;wc(te,z))lec(ie,te)?(M[w]=ie,M[le]=z,w=le):(M[w]=te,M[ne]=z,w=ne);else if(lec(ie,z))M[w]=ie,M[le]=z,w=le;else break e}}return H}function c(M,H){var z=M.sortIndex-H.sortIndex;return z!==0?z:M.id-H.id}if(typeof performance=="object"&&typeof performance.now=="function"){var f=performance;r.unstable_now=function(){return f.now()}}else{var p=Date,v=p.now();r.unstable_now=function(){return p.now()-v}}var y=[],x=[],R=1,N=null,j=3,O=!1,q=!1,Q=!1,$=typeof setTimeout=="function"?setTimeout:null,fe=typeof clearTimeout=="function"?clearTimeout:null,T=typeof setImmediate<"u"?setImmediate:null;typeof navigator<"u"&&navigator.scheduling!==void 0&&navigator.scheduling.isInputPending!==void 0&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function A(M){for(var H=s(x);H!==null;){if(H.callback===null)a(x);else if(H.startTime<=M)a(x),H.sortIndex=H.expirationTime,n(y,H);else break;H=s(x)}}function L(M){if(Q=!1,A(M),!q)if(s(y)!==null)q=!0,P(J);else{var H=s(x);H!==null&&W(L,H.startTime-M)}}function J(M,H){q=!1,Q&&(Q=!1,fe(me),me=-1),O=!0;var z=j;try{for(A(H),N=s(y);N!==null&&(!(N.expirationTime>H)||M&&!We());){var w=N.callback;if(typeof w=="function"){N.callback=null,j=N.priorityLevel;var E=w(N.expirationTime<=H);H=r.unstable_now(),typeof E=="function"?N.callback=E:N===s(y)&&a(y),A(H)}else a(y);N=s(y)}if(N!==null)var ee=!0;else{var ne=s(x);ne!==null&&W(L,ne.startTime-H),ee=!1}return ee}finally{N=null,j=z,O=!1}}var Y=!1,ge=null,me=-1,ue=5,Re=-1;function We(){return!(r.unstable_now()-ReM||125w?(M.sortIndex=z,n(x,M),s(y)===null&&M===s(x)&&(Q?(fe(me),me=-1):Q=!0,W(L,z-w))):(M.sortIndex=E,n(y,M),q||O||(q=!0,P(J))),M},r.unstable_shouldYield=We,r.unstable_wrapCallback=function(M){var H=j;return function(){var z=j;j=H;try{return M.apply(this,arguments)}finally{j=z}}}})(ou)),ou}var jf;function Cm(){return jf||(jf=1,su.exports=bm()),su.exports}var Of;function Tm(){if(Of)return wt;Of=1;var r=Au(),n=Cm();function s(e){for(var t="https://reactjs.org/docs/error-decoder.html?invariant="+e,i=1;i"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),y=Object.prototype.hasOwnProperty,x=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,R={},N={};function j(e){return y.call(N,e)?!0:y.call(R,e)?!1:x.test(e)?N[e]=!0:(R[e]=!0,!1)}function O(e,t,i,o){if(i!==null&&i.type===0)return!1;switch(typeof t){case"function":case"symbol":return!0;case"boolean":return o?!1:i!==null?!i.acceptsBooleans:(e=e.toLowerCase().slice(0,5),e!=="data-"&&e!=="aria-");default:return!1}}function q(e,t,i,o){if(t===null||typeof t>"u"||O(e,t,i,o))return!0;if(o)return!1;if(i!==null)switch(i.type){case 3:return!t;case 4:return t===!1;case 5:return isNaN(t);case 6:return isNaN(t)||1>t}return!1}function Q(e,t,i,o,l,u,h){this.acceptsBooleans=t===2||t===3||t===4,this.attributeName=o,this.attributeNamespace=l,this.mustUseProperty=i,this.propertyName=e,this.type=t,this.sanitizeURL=u,this.removeEmptyString=h}var $={};"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(e){$[e]=new Q(e,0,!1,e,null,!1,!1)}),[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(e){var t=e[0];$[t]=new Q(t,1,!1,e[1],null,!1,!1)}),["contentEditable","draggable","spellCheck","value"].forEach(function(e){$[e]=new Q(e,2,!1,e.toLowerCase(),null,!1,!1)}),["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(e){$[e]=new Q(e,2,!1,e,null,!1,!1)}),"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(e){$[e]=new Q(e,3,!1,e.toLowerCase(),null,!1,!1)}),["checked","multiple","muted","selected"].forEach(function(e){$[e]=new Q(e,3,!0,e,null,!1,!1)}),["capture","download"].forEach(function(e){$[e]=new Q(e,4,!1,e,null,!1,!1)}),["cols","rows","size","span"].forEach(function(e){$[e]=new Q(e,6,!1,e,null,!1,!1)}),["rowSpan","start"].forEach(function(e){$[e]=new Q(e,5,!1,e.toLowerCase(),null,!1,!1)});var fe=/[\-:]([a-z])/g;function T(e){return e[1].toUpperCase()}"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(e){var t=e.replace(fe,T);$[t]=new Q(t,1,!1,e,null,!1,!1)}),"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(e){var t=e.replace(fe,T);$[t]=new Q(t,1,!1,e,"http://www.w3.org/1999/xlink",!1,!1)}),["xml:base","xml:lang","xml:space"].forEach(function(e){var t=e.replace(fe,T);$[t]=new Q(t,1,!1,e,"http://www.w3.org/XML/1998/namespace",!1,!1)}),["tabIndex","crossOrigin"].forEach(function(e){$[e]=new Q(e,1,!1,e.toLowerCase(),null,!1,!1)}),$.xlinkHref=new Q("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1),["src","href","action","formAction"].forEach(function(e){$[e]=new Q(e,1,!1,e.toLowerCase(),null,!0,!0)});function A(e,t,i,o){var l=$.hasOwnProperty(t)?$[t]:null;(l!==null?l.type!==0:o||!(2m||l[h]!==u[m]){var _=` +`+l[h].replace(" at new "," at ");return e.displayName&&_.includes("")&&(_=_.replace("",e.displayName)),_}while(1<=h&&0<=m);break}}}finally{ee=!1,Error.prepareStackTrace=i}return(e=e?e.displayName||e.name:"")?E(e):""}function te(e){switch(e.tag){case 5:return E(e.type);case 16:return E("Lazy");case 13:return E("Suspense");case 19:return E("SuspenseList");case 0:case 2:case 15:return e=ne(e.type,!1),e;case 11:return e=ne(e.type.render,!1),e;case 1:return e=ne(e.type,!0),e;default:return""}}function le(e){if(e==null)return null;if(typeof e=="function")return e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case ge:return"Fragment";case Y:return"Portal";case ue:return"Profiler";case me:return"StrictMode";case Me:return"Suspense";case it:return"SuspenseList"}if(typeof e=="object")switch(e.$$typeof){case We:return(e.displayName||"Context")+".Consumer";case Re:return(e._context.displayName||"Context")+".Provider";case Le:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case ke:return t=e.displayName||null,t!==null?t:le(e.type)||"Memo";case P:t=e._payload,e=e._init;try{return le(e(t))}catch{}}return null}function ie(e){var t=e.type;switch(e.tag){case 24:return"Cache";case 9:return(t.displayName||"Context")+".Consumer";case 10:return(t._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return e=t.render,e=e.displayName||e.name||"",t.displayName||(e!==""?"ForwardRef("+e+")":"ForwardRef");case 7:return"Fragment";case 5:return t;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return le(t);case 8:return t===me?"StrictMode":"Mode";case 22:return"Offscreen";case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if(typeof t=="function")return t.displayName||t.name||null;if(typeof t=="string")return t}return null}function he(e){switch(typeof e){case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function we(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function _e(e){var t=we(e)?"checked":"value",i=Object.getOwnPropertyDescriptor(e.constructor.prototype,t),o=""+e[t];if(!e.hasOwnProperty(t)&&typeof i<"u"&&typeof i.get=="function"&&typeof i.set=="function"){var l=i.get,u=i.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return l.call(this)},set:function(h){o=""+h,u.call(this,h)}}),Object.defineProperty(e,t,{enumerable:i.enumerable}),{getValue:function(){return o},setValue:function(h){o=""+h},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function Ne(e){e._valueTracker||(e._valueTracker=_e(e))}function Ge(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var i=t.getValue(),o="";return e&&(o=we(e)?e.checked?"true":"false":e.value),e=o,e!==i?(t.setValue(e),!0):!1}function Dt(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}function mr(e,t){var i=t.checked;return z({},t,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:i??e._wrapperState.initialChecked})}function Dr(e,t){var i=t.defaultValue==null?"":t.defaultValue,o=t.checked!=null?t.checked:t.defaultChecked;i=he(t.value!=null?t.value:i),e._wrapperState={initialChecked:o,initialValue:i,controlled:t.type==="checkbox"||t.type==="radio"?t.checked!=null:t.value!=null}}function Sn(e,t){t=t.checked,t!=null&&A(e,"checked",t,!1)}function zr(e,t){Sn(e,t);var i=he(t.value),o=t.type;if(i!=null)o==="number"?(i===0&&e.value===""||e.value!=i)&&(e.value=""+i):e.value!==""+i&&(e.value=""+i);else if(o==="submit"||o==="reset"){e.removeAttribute("value");return}t.hasOwnProperty("value")?Ri(e,t.type,i):t.hasOwnProperty("defaultValue")&&Ri(e,t.type,he(t.defaultValue)),t.checked==null&&t.defaultChecked!=null&&(e.defaultChecked=!!t.defaultChecked)}function Ui(e,t,i){if(t.hasOwnProperty("value")||t.hasOwnProperty("defaultValue")){var o=t.type;if(!(o!=="submit"&&o!=="reset"||t.value!==void 0&&t.value!==null))return;t=""+e._wrapperState.initialValue,i||t===e.value||(e.value=t),e.defaultValue=t}i=e.name,i!==""&&(e.name=""),e.defaultChecked=!!e._wrapperState.initialChecked,i!==""&&(e.name=i)}function Ri(e,t,i){(t!=="number"||Dt(e.ownerDocument)!==e)&&(i==null?e.defaultValue=""+e._wrapperState.initialValue:e.defaultValue!==""+i&&(e.defaultValue=""+i))}var Fr=Array.isArray;function yr(e,t,i,o){if(e=e.options,t){t={};for(var l=0;l"+t.valueOf().toString()+"",t=xt.firstChild;e.firstChild;)e.removeChild(e.firstChild);for(;t.firstChild;)e.appendChild(t.firstChild)}});function $r(e,t){if(t){var i=e.firstChild;if(i&&i===e.lastChild&&i.nodeType===3){i.nodeValue=t;return}}e.textContent=t}var Lr={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},ya=["Webkit","ms","Moz","O"];Object.keys(Lr).forEach(function(e){ya.forEach(function(t){t=t+e.charAt(0).toUpperCase()+e.substring(1),Lr[t]=Lr[e]})});function Os(e,t,i){return t==null||typeof t=="boolean"||t===""?"":i||typeof t!="number"||t===0||Lr.hasOwnProperty(e)&&Lr[e]?(""+t).trim():t+"px"}function Ds(e,t){e=e.style;for(var i in t)if(t.hasOwnProperty(i)){var o=i.indexOf("--")===0,l=Os(i,t[i],o);i==="float"&&(i="cssFloat"),o?e.setProperty(i,l):e[i]=l}}var wa=z({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});function Bi(e,t){if(t){if(wa[e]&&(t.children!=null||t.dangerouslySetInnerHTML!=null))throw Error(s(137,e));if(t.dangerouslySetInnerHTML!=null){if(t.children!=null)throw Error(s(60));if(typeof t.dangerouslySetInnerHTML!="object"||!("__html"in t.dangerouslySetInnerHTML))throw Error(s(61))}if(t.style!=null&&typeof t.style!="object")throw Error(s(62))}}function Ai(e,t){if(e.indexOf("-")===-1)return typeof t.is=="string";switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var zs=null;function Et(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var Mi=null,B=null,ye=null;function bn(e){if(e=ns(e)){if(typeof Mi!="function")throw Error(s(280));var t=e.stateNode;t&&(t=lo(t),Mi(e.stateNode,e.type,t))}}function Qu(e){B?ye?ye.push(e):ye=[e]:B=e}function Ju(){if(B){var e=B,t=ye;if(ye=B=null,bn(e),t)for(e=0;e>>=0,e===0?32:31-(Dp(e)/zp|0)|0}var qs=64,Hs=4194304;function zi(e){switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return e&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return e&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;default:return e}}function Ks(e,t){var i=e.pendingLanes;if(i===0)return 0;var o=0,l=e.suspendedLanes,u=e.pingedLanes,h=i&268435455;if(h!==0){var m=h&~l;m!==0?o=zi(m):(u&=h,u!==0&&(o=zi(u)))}else h=i&~l,h!==0?o=zi(h):u!==0&&(o=zi(u));if(o===0)return 0;if(t!==0&&t!==o&&(t&l)===0&&(l=o&-o,u=t&-t,l>=u||l===16&&(u&4194240)!==0))return t;if((o&4)!==0&&(o|=i&16),t=e.entangledLanes,t!==0)for(e=e.entanglements,t&=o;0i;i++)t.push(e);return t}function Fi(e,t,i){e.pendingLanes|=t,t!==536870912&&(e.suspendedLanes=0,e.pingedLanes=0),e=e.eventTimes,t=31-zt(t),e[t]=i}function Vp(e,t){var i=e.pendingLanes&~t;e.pendingLanes=t,e.suspendedLanes=0,e.pingedLanes=0,e.expiredLanes&=t,e.mutableReadLanes&=t,e.entangledLanes&=t,t=e.entanglements;var o=e.eventTimes;for(e=e.expirationTimes;0=Qi),Ic=" ",kc=!1;function bc(e,t){switch(e){case"keyup":return yg.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function Cc(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var En=!1;function vg(e,t){switch(e){case"compositionend":return Cc(t);case"keypress":return t.which!==32?null:(kc=!0,Ic);case"textInput":return e=t.data,e===Ic&&kc?null:e;default:return null}}function _g(e,t){if(En)return e==="compositionend"||!ja&&bc(e,t)?(e=yc(),Xs=Ra=xr=null,En=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1=t)return{node:i,offset:t-e};e=o}e:{for(;i;){if(i.nextSibling){i=i.nextSibling;break e}i=i.parentNode}i=void 0}i=Bc(i)}}function Mc(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?Mc(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function jc(){for(var e=window,t=Dt();t instanceof e.HTMLIFrameElement;){try{var i=typeof t.contentWindow.location.href=="string"}catch{i=!1}if(i)e=t.contentWindow;else break;t=Dt(e.document)}return t}function za(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}function Ug(e){var t=jc(),i=e.focusedElem,o=e.selectionRange;if(t!==i&&i&&i.ownerDocument&&Mc(i.ownerDocument.documentElement,i)){if(o!==null&&za(i)){if(t=o.start,e=o.end,e===void 0&&(e=t),"selectionStart"in i)i.selectionStart=t,i.selectionEnd=Math.min(e,i.value.length);else if(e=(t=i.ownerDocument||document)&&t.defaultView||window,e.getSelection){e=e.getSelection();var l=i.textContent.length,u=Math.min(o.start,l);o=o.end===void 0?u:Math.min(o.end,l),!e.extend&&u>o&&(l=o,o=u,u=l),l=Ac(i,u);var h=Ac(i,o);l&&h&&(e.rangeCount!==1||e.anchorNode!==l.node||e.anchorOffset!==l.offset||e.focusNode!==h.node||e.focusOffset!==h.offset)&&(t=t.createRange(),t.setStart(l.node,l.offset),e.removeAllRanges(),u>o?(e.addRange(t),e.extend(h.node,h.offset)):(t.setEnd(h.node,h.offset),e.addRange(t)))}}for(t=[],e=i;e=e.parentNode;)e.nodeType===1&&t.push({element:e,left:e.scrollLeft,top:e.scrollTop});for(typeof i.focus=="function"&&i.focus(),i=0;i=document.documentMode,Un=null,Fa=null,Yi=null,$a=!1;function Oc(e,t,i){var o=i.window===i?i.document:i.nodeType===9?i:i.ownerDocument;$a||Un==null||Un!==Dt(o)||(o=Un,"selectionStart"in o&&za(o)?o={start:o.selectionStart,end:o.selectionEnd}:(o=(o.ownerDocument&&o.ownerDocument.defaultView||window).getSelection(),o={anchorNode:o.anchorNode,anchorOffset:o.anchorOffset,focusNode:o.focusNode,focusOffset:o.focusOffset}),Yi&&Xi(Yi,o)||(Yi=o,o=so(Fa,"onSelect"),0An||(e.current=Za[An],Za[An]=null,An--)}function Ae(e,t){An++,Za[An]=e.current,e.current=t}var Cr={},at=br(Cr),ht=br(!1),Hr=Cr;function Mn(e,t){var i=e.type.contextTypes;if(!i)return Cr;var o=e.stateNode;if(o&&o.__reactInternalMemoizedUnmaskedChildContext===t)return o.__reactInternalMemoizedMaskedChildContext;var l={},u;for(u in i)l[u]=t[u];return o&&(e=e.stateNode,e.__reactInternalMemoizedUnmaskedChildContext=t,e.__reactInternalMemoizedMaskedChildContext=l),l}function pt(e){return e=e.childContextTypes,e!=null}function uo(){Oe(ht),Oe(at)}function Yc(e,t,i){if(at.current!==Cr)throw Error(s(168));Ae(at,t),Ae(ht,i)}function Zc(e,t,i){var o=e.stateNode;if(t=t.childContextTypes,typeof o.getChildContext!="function")return i;o=o.getChildContext();for(var l in o)if(!(l in t))throw Error(s(108,ie(e)||"Unknown",l));return z({},i,o)}function co(e){return e=(e=e.stateNode)&&e.__reactInternalMemoizedMergedChildContext||Cr,Hr=at.current,Ae(at,e),Ae(ht,ht.current),!0}function ed(e,t,i){var o=e.stateNode;if(!o)throw Error(s(169));i?(e=Zc(e,t,Hr),o.__reactInternalMemoizedMergedChildContext=e,Oe(ht),Oe(at),Ae(at,e)):Oe(ht),Ae(ht,i)}var ir=null,fo=!1,el=!1;function td(e){ir===null?ir=[e]:ir.push(e)}function $g(e){fo=!0,td(e)}function Tr(){if(!el&&ir!==null){el=!0;var e=0,t=Ue;try{var i=ir;for(Ue=1;e>=h,l-=h,sr=1<<32-zt(t)+l|i<pe?(nt=de,de=null):nt=de.sibling;var Ce=D(I,de,k[pe],K);if(Ce===null){de===null&&(de=nt);break}e&&de&&Ce.alternate===null&&t(I,de),S=u(Ce,S,pe),ce===null?se=Ce:ce.sibling=Ce,ce=Ce,de=nt}if(pe===k.length)return i(I,de),De&&Wr(I,pe),se;if(de===null){for(;pepe?(nt=de,de=null):nt=de.sibling;var jr=D(I,de,Ce.value,K);if(jr===null){de===null&&(de=nt);break}e&&de&&jr.alternate===null&&t(I,de),S=u(jr,S,pe),ce===null?se=jr:ce.sibling=jr,ce=jr,de=nt}if(Ce.done)return i(I,de),De&&Wr(I,pe),se;if(de===null){for(;!Ce.done;pe++,Ce=k.next())Ce=V(I,Ce.value,K),Ce!==null&&(S=u(Ce,S,pe),ce===null?se=Ce:ce.sibling=Ce,ce=Ce);return De&&Wr(I,pe),se}for(de=o(I,de);!Ce.done;pe++,Ce=k.next())Ce=G(de,I,pe,Ce.value,K),Ce!==null&&(e&&Ce.alternate!==null&&de.delete(Ce.key===null?pe:Ce.key),S=u(Ce,S,pe),ce===null?se=Ce:ce.sibling=Ce,ce=Ce);return e&&de.forEach(function(Sm){return t(I,Sm)}),De&&Wr(I,pe),se}function He(I,S,k,K){if(typeof k=="object"&&k!==null&&k.type===ge&&k.key===null&&(k=k.props.children),typeof k=="object"&&k!==null){switch(k.$$typeof){case J:e:{for(var se=k.key,ce=S;ce!==null;){if(ce.key===se){if(se=k.type,se===ge){if(ce.tag===7){i(I,ce.sibling),S=l(ce,k.props.children),S.return=I,I=S;break e}}else if(ce.elementType===se||typeof se=="object"&&se!==null&&se.$$typeof===P&&ad(se)===ce.type){i(I,ce.sibling),S=l(ce,k.props),S.ref=is(I,ce,k),S.return=I,I=S;break e}i(I,ce);break}else t(I,ce);ce=ce.sibling}k.type===ge?(S=tn(k.props.children,I.mode,K,k.key),S.return=I,I=S):(K=Fo(k.type,k.key,k.props,null,I.mode,K),K.ref=is(I,S,k),K.return=I,I=K)}return h(I);case Y:e:{for(ce=k.key;S!==null;){if(S.key===ce)if(S.tag===4&&S.stateNode.containerInfo===k.containerInfo&&S.stateNode.implementation===k.implementation){i(I,S.sibling),S=l(S,k.children||[]),S.return=I,I=S;break e}else{i(I,S);break}else t(I,S);S=S.sibling}S=Xl(k,I.mode,K),S.return=I,I=S}return h(I);case P:return ce=k._init,He(I,S,ce(k._payload),K)}if(Fr(k))return Z(I,S,k,K);if(H(k))return re(I,S,k,K);mo(I,k)}return typeof k=="string"&&k!==""||typeof k=="number"?(k=""+k,S!==null&&S.tag===6?(i(I,S.sibling),S=l(S,k),S.return=I,I=S):(i(I,S),S=Gl(k,I.mode,K),S.return=I,I=S),h(I)):i(I,S)}return He}var zn=ld(!0),ud=ld(!1),yo=br(null),wo=null,Fn=null,ol=null;function al(){ol=Fn=wo=null}function ll(e){var t=yo.current;Oe(yo),e._currentValue=t}function ul(e,t,i){for(;e!==null;){var o=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,o!==null&&(o.childLanes|=t)):o!==null&&(o.childLanes&t)!==t&&(o.childLanes|=t),e===i)break;e=e.return}}function $n(e,t){wo=e,ol=Fn=null,e=e.dependencies,e!==null&&e.firstContext!==null&&((e.lanes&t)!==0&&(gt=!0),e.firstContext=null)}function Nt(e){var t=e._currentValue;if(ol!==e)if(e={context:e,memoizedValue:t,next:null},Fn===null){if(wo===null)throw Error(s(308));Fn=e,wo.dependencies={lanes:0,firstContext:e}}else Fn=Fn.next=e;return t}var Qr=null;function cl(e){Qr===null?Qr=[e]:Qr.push(e)}function cd(e,t,i,o){var l=t.interleaved;return l===null?(i.next=i,cl(t)):(i.next=l.next,l.next=i),t.interleaved=i,ar(e,o)}function ar(e,t){e.lanes|=t;var i=e.alternate;for(i!==null&&(i.lanes|=t),i=e,e=e.return;e!==null;)e.childLanes|=t,i=e.alternate,i!==null&&(i.childLanes|=t),i=e,e=e.return;return i.tag===3?i.stateNode:null}var Er=!1;function dl(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}function dd(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,effects:e.effects})}function lr(e,t){return{eventTime:e,lane:t,tag:0,payload:null,callback:null,next:null}}function Ur(e,t,i){var o=e.updateQueue;if(o===null)return null;if(o=o.shared,(be&2)!==0){var l=o.pending;return l===null?t.next=t:(t.next=l.next,l.next=t),o.pending=t,ar(e,i)}return l=o.interleaved,l===null?(t.next=t,cl(o)):(t.next=l.next,l.next=t),o.interleaved=t,ar(e,i)}function vo(e,t,i){if(t=t.updateQueue,t!==null&&(t=t.shared,(i&4194240)!==0)){var o=t.lanes;o&=e.pendingLanes,i|=o,t.lanes=i,ba(e,i)}}function fd(e,t){var i=e.updateQueue,o=e.alternate;if(o!==null&&(o=o.updateQueue,i===o)){var l=null,u=null;if(i=i.firstBaseUpdate,i!==null){do{var h={eventTime:i.eventTime,lane:i.lane,tag:i.tag,payload:i.payload,callback:i.callback,next:null};u===null?l=u=h:u=u.next=h,i=i.next}while(i!==null);u===null?l=u=t:u=u.next=t}else l=u=t;i={baseState:o.baseState,firstBaseUpdate:l,lastBaseUpdate:u,shared:o.shared,effects:o.effects},e.updateQueue=i;return}e=i.lastBaseUpdate,e===null?i.firstBaseUpdate=t:e.next=t,i.lastBaseUpdate=t}function _o(e,t,i,o){var l=e.updateQueue;Er=!1;var u=l.firstBaseUpdate,h=l.lastBaseUpdate,m=l.shared.pending;if(m!==null){l.shared.pending=null;var _=m,C=_.next;_.next=null,h===null?u=C:h.next=C,h=_;var F=e.alternate;F!==null&&(F=F.updateQueue,m=F.lastBaseUpdate,m!==h&&(m===null?F.firstBaseUpdate=C:m.next=C,F.lastBaseUpdate=_))}if(u!==null){var V=l.baseState;h=0,F=C=_=null,m=u;do{var D=m.lane,G=m.eventTime;if((o&D)===D){F!==null&&(F=F.next={eventTime:G,lane:0,tag:m.tag,payload:m.payload,callback:m.callback,next:null});e:{var Z=e,re=m;switch(D=t,G=i,re.tag){case 1:if(Z=re.payload,typeof Z=="function"){V=Z.call(G,V,D);break e}V=Z;break e;case 3:Z.flags=Z.flags&-65537|128;case 0:if(Z=re.payload,D=typeof Z=="function"?Z.call(G,V,D):Z,D==null)break e;V=z({},V,D);break e;case 2:Er=!0}}m.callback!==null&&m.lane!==0&&(e.flags|=64,D=l.effects,D===null?l.effects=[m]:D.push(m))}else G={eventTime:G,lane:D,tag:m.tag,payload:m.payload,callback:m.callback,next:null},F===null?(C=F=G,_=V):F=F.next=G,h|=D;if(m=m.next,m===null){if(m=l.shared.pending,m===null)break;D=m,m=D.next,D.next=null,l.lastBaseUpdate=D,l.shared.pending=null}}while(!0);if(F===null&&(_=V),l.baseState=_,l.firstBaseUpdate=C,l.lastBaseUpdate=F,t=l.shared.interleaved,t!==null){l=t;do h|=l.lane,l=l.next;while(l!==t)}else u===null&&(l.shared.lanes=0);Xr|=h,e.lanes=h,e.memoizedState=V}}function hd(e,t,i){if(e=t.effects,t.effects=null,e!==null)for(t=0;ti?i:4,e(!0);var o=ml.transition;ml.transition={};try{e(!1),t()}finally{Ue=i,ml.transition=o}}function Pd(){return Pt().memoizedState}function Hg(e,t,i){var o=Br(e);if(i={lane:o,action:i,hasEagerState:!1,eagerState:null,next:null},Bd(e))Ad(t,i);else if(i=cd(e,t,i,o),i!==null){var l=ft();Ht(i,e,o,l),Md(i,t,o)}}function Kg(e,t,i){var o=Br(e),l={lane:o,action:i,hasEagerState:!1,eagerState:null,next:null};if(Bd(e))Ad(t,l);else{var u=e.alternate;if(e.lanes===0&&(u===null||u.lanes===0)&&(u=t.lastRenderedReducer,u!==null))try{var h=t.lastRenderedState,m=u(h,i);if(l.hasEagerState=!0,l.eagerState=m,Ft(m,h)){var _=t.interleaved;_===null?(l.next=l,cl(t)):(l.next=_.next,_.next=l),t.interleaved=l;return}}catch{}i=cd(e,t,l,o),i!==null&&(l=ft(),Ht(i,e,o,l),Md(i,t,o))}}function Bd(e){var t=e.alternate;return e===$e||t!==null&&t===$e}function Ad(e,t){ls=Io=!0;var i=e.pending;i===null?t.next=t:(t.next=i.next,i.next=t),e.pending=t}function Md(e,t,i){if((i&4194240)!==0){var o=t.lanes;o&=e.pendingLanes,i|=o,t.lanes=i,ba(e,i)}}var Co={readContext:Nt,useCallback:lt,useContext:lt,useEffect:lt,useImperativeHandle:lt,useInsertionEffect:lt,useLayoutEffect:lt,useMemo:lt,useReducer:lt,useRef:lt,useState:lt,useDebugValue:lt,useDeferredValue:lt,useTransition:lt,useMutableSource:lt,useSyncExternalStore:lt,useId:lt,unstable_isNewReconciler:!1},Wg={readContext:Nt,useCallback:function(e,t){return Xt().memoizedState=[e,t===void 0?null:t],e},useContext:Nt,useEffect:kd,useImperativeHandle:function(e,t,i){return i=i!=null?i.concat([e]):null,ko(4194308,4,Td.bind(null,t,e),i)},useLayoutEffect:function(e,t){return ko(4194308,4,e,t)},useInsertionEffect:function(e,t){return ko(4,2,e,t)},useMemo:function(e,t){var i=Xt();return t=t===void 0?null:t,e=e(),i.memoizedState=[e,t],e},useReducer:function(e,t,i){var o=Xt();return t=i!==void 0?i(t):t,o.memoizedState=o.baseState=t,e={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:t},o.queue=e,e=e.dispatch=Hg.bind(null,$e,e),[o.memoizedState,e]},useRef:function(e){var t=Xt();return e={current:e},t.memoizedState=e},useState:xd,useDebugValue:Il,useDeferredValue:function(e){return Xt().memoizedState=e},useTransition:function(){var e=xd(!1),t=e[0];return e=qg.bind(null,e[1]),Xt().memoizedState=e,[t,e]},useMutableSource:function(){},useSyncExternalStore:function(e,t,i){var o=$e,l=Xt();if(De){if(i===void 0)throw Error(s(407));i=i()}else{if(i=t(),rt===null)throw Error(s(349));(Gr&30)!==0||yd(o,t,i)}l.memoizedState=i;var u={value:i,getSnapshot:t};return l.queue=u,kd(vd.bind(null,o,u,e),[e]),o.flags|=2048,ds(9,wd.bind(null,o,u,i,t),void 0,null),i},useId:function(){var e=Xt(),t=rt.identifierPrefix;if(De){var i=or,o=sr;i=(o&~(1<<32-zt(o)-1)).toString(32)+i,t=":"+t+"R"+i,i=us++,0<\/script>",e=e.removeChild(e.firstChild)):typeof o.is=="string"?e=h.createElement(i,{is:o.is}):(e=h.createElement(i),i==="select"&&(h=e,o.multiple?h.multiple=!0:o.size&&(h.size=o.size))):e=h.createElementNS(e,i),e[Jt]=t,e[rs]=o,tf(e,t,!1,!1),t.stateNode=e;e:{switch(h=Ai(i,o),i){case"dialog":je("cancel",e),je("close",e),l=o;break;case"iframe":case"object":case"embed":je("load",e),l=o;break;case"video":case"audio":for(l=0;lKn&&(t.flags|=128,o=!0,fs(u,!1),t.lanes=4194304)}else{if(!o)if(e=So(h),e!==null){if(t.flags|=128,o=!0,i=e.updateQueue,i!==null&&(t.updateQueue=i,t.flags|=4),fs(u,!0),u.tail===null&&u.tailMode==="hidden"&&!h.alternate&&!De)return ut(t),null}else 2*qe()-u.renderingStartTime>Kn&&i!==1073741824&&(t.flags|=128,o=!0,fs(u,!1),t.lanes=4194304);u.isBackwards?(h.sibling=t.child,t.child=h):(i=u.last,i!==null?i.sibling=h:t.child=h,u.last=h)}return u.tail!==null?(t=u.tail,u.rendering=t,u.tail=t.sibling,u.renderingStartTime=qe(),t.sibling=null,i=Fe.current,Ae(Fe,o?i&1|2:i&1),t):(ut(t),null);case 22:case 23:return Wl(),o=t.memoizedState!==null,e!==null&&e.memoizedState!==null!==o&&(t.flags|=8192),o&&(t.mode&1)!==0?(Ct&1073741824)!==0&&(ut(t),t.subtreeFlags&6&&(t.flags|=8192)):ut(t),null;case 24:return null;case 25:return null}throw Error(s(156,t.tag))}function tm(e,t){switch(rl(t),t.tag){case 1:return pt(t.type)&&uo(),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return Ln(),Oe(ht),Oe(at),gl(),e=t.flags,(e&65536)!==0&&(e&128)===0?(t.flags=e&-65537|128,t):null;case 5:return hl(t),null;case 13:if(Oe(Fe),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(s(340));Dn()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return Oe(Fe),null;case 4:return Ln(),null;case 10:return ll(t.type._context),null;case 22:case 23:return Wl(),null;case 24:return null;default:return null}}var Ro=!1,ct=!1,rm=typeof WeakSet=="function"?WeakSet:Set,X=null;function qn(e,t){var i=e.ref;if(i!==null)if(typeof i=="function")try{i(null)}catch(o){Ve(e,t,o)}else i.current=null}function Ml(e,t,i){try{i()}catch(o){Ve(e,t,o)}}var sf=!1;function nm(e,t){if(Wa=Js,e=jc(),za(e)){if("selectionStart"in e)var i={start:e.selectionStart,end:e.selectionEnd};else e:{i=(i=e.ownerDocument)&&i.defaultView||window;var o=i.getSelection&&i.getSelection();if(o&&o.rangeCount!==0){i=o.anchorNode;var l=o.anchorOffset,u=o.focusNode;o=o.focusOffset;try{i.nodeType,u.nodeType}catch{i=null;break e}var h=0,m=-1,_=-1,C=0,F=0,V=e,D=null;t:for(;;){for(var G;V!==i||l!==0&&V.nodeType!==3||(m=h+l),V!==u||o!==0&&V.nodeType!==3||(_=h+o),V.nodeType===3&&(h+=V.nodeValue.length),(G=V.firstChild)!==null;)D=V,V=G;for(;;){if(V===e)break t;if(D===i&&++C===l&&(m=h),D===u&&++F===o&&(_=h),(G=V.nextSibling)!==null)break;V=D,D=V.parentNode}V=G}i=m===-1||_===-1?null:{start:m,end:_}}else i=null}i=i||{start:0,end:0}}else i=null;for(Qa={focusedElem:e,selectionRange:i},Js=!1,X=t;X!==null;)if(t=X,e=t.child,(t.subtreeFlags&1028)!==0&&e!==null)e.return=t,X=e;else for(;X!==null;){t=X;try{var Z=t.alternate;if((t.flags&1024)!==0)switch(t.tag){case 0:case 11:case 15:break;case 1:if(Z!==null){var re=Z.memoizedProps,He=Z.memoizedState,I=t.stateNode,S=I.getSnapshotBeforeUpdate(t.elementType===t.type?re:Lt(t.type,re),He);I.__reactInternalSnapshotBeforeUpdate=S}break;case 3:var k=t.stateNode.containerInfo;k.nodeType===1?k.textContent="":k.nodeType===9&&k.documentElement&&k.removeChild(k.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(s(163))}}catch(K){Ve(t,t.return,K)}if(e=t.sibling,e!==null){e.return=t.return,X=e;break}X=t.return}return Z=sf,sf=!1,Z}function hs(e,t,i){var o=t.updateQueue;if(o=o!==null?o.lastEffect:null,o!==null){var l=o=o.next;do{if((l.tag&e)===e){var u=l.destroy;l.destroy=void 0,u!==void 0&&Ml(t,i,u)}l=l.next}while(l!==o)}}function No(e,t){if(t=t.updateQueue,t=t!==null?t.lastEffect:null,t!==null){var i=t=t.next;do{if((i.tag&e)===e){var o=i.create;i.destroy=o()}i=i.next}while(i!==t)}}function jl(e){var t=e.ref;if(t!==null){var i=e.stateNode;e.tag,e=i,typeof t=="function"?t(e):t.current=e}}function of(e){var t=e.alternate;t!==null&&(e.alternate=null,of(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&(delete t[Jt],delete t[rs],delete t[Ya],delete t[zg],delete t[Fg])),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}function af(e){return e.tag===5||e.tag===3||e.tag===4}function lf(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||af(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function Ol(e,t,i){var o=e.tag;if(o===5||o===6)e=e.stateNode,t?i.nodeType===8?i.parentNode.insertBefore(e,t):i.insertBefore(e,t):(i.nodeType===8?(t=i.parentNode,t.insertBefore(e,i)):(t=i,t.appendChild(e)),i=i._reactRootContainer,i!=null||t.onclick!==null||(t.onclick=ao));else if(o!==4&&(e=e.child,e!==null))for(Ol(e,t,i),e=e.sibling;e!==null;)Ol(e,t,i),e=e.sibling}function Dl(e,t,i){var o=e.tag;if(o===5||o===6)e=e.stateNode,t?i.insertBefore(e,t):i.appendChild(e);else if(o!==4&&(e=e.child,e!==null))for(Dl(e,t,i),e=e.sibling;e!==null;)Dl(e,t,i),e=e.sibling}var st=null,Vt=!1;function Rr(e,t,i){for(i=i.child;i!==null;)uf(e,t,i),i=i.sibling}function uf(e,t,i){if(Qt&&typeof Qt.onCommitFiberUnmount=="function")try{Qt.onCommitFiberUnmount(Vs,i)}catch{}switch(i.tag){case 5:ct||qn(i,t);case 6:var o=st,l=Vt;st=null,Rr(e,t,i),st=o,Vt=l,st!==null&&(Vt?(e=st,i=i.stateNode,e.nodeType===8?e.parentNode.removeChild(i):e.removeChild(i)):st.removeChild(i.stateNode));break;case 18:st!==null&&(Vt?(e=st,i=i.stateNode,e.nodeType===8?Xa(e.parentNode,i):e.nodeType===1&&Xa(e,i),Hi(e)):Xa(st,i.stateNode));break;case 4:o=st,l=Vt,st=i.stateNode.containerInfo,Vt=!0,Rr(e,t,i),st=o,Vt=l;break;case 0:case 11:case 14:case 15:if(!ct&&(o=i.updateQueue,o!==null&&(o=o.lastEffect,o!==null))){l=o=o.next;do{var u=l,h=u.destroy;u=u.tag,h!==void 0&&((u&2)!==0||(u&4)!==0)&&Ml(i,t,h),l=l.next}while(l!==o)}Rr(e,t,i);break;case 1:if(!ct&&(qn(i,t),o=i.stateNode,typeof o.componentWillUnmount=="function"))try{o.props=i.memoizedProps,o.state=i.memoizedState,o.componentWillUnmount()}catch(m){Ve(i,t,m)}Rr(e,t,i);break;case 21:Rr(e,t,i);break;case 22:i.mode&1?(ct=(o=ct)||i.memoizedState!==null,Rr(e,t,i),ct=o):Rr(e,t,i);break;default:Rr(e,t,i)}}function cf(e){var t=e.updateQueue;if(t!==null){e.updateQueue=null;var i=e.stateNode;i===null&&(i=e.stateNode=new rm),t.forEach(function(o){var l=fm.bind(null,e,o);i.has(o)||(i.add(o),o.then(l,l))})}}function qt(e,t){var i=t.deletions;if(i!==null)for(var o=0;ol&&(l=h),o&=~u}if(o=l,o=qe()-o,o=(120>o?120:480>o?480:1080>o?1080:1920>o?1920:3e3>o?3e3:4320>o?4320:1960*sm(o/1960))-o,10e?16:e,Pr===null)var o=!1;else{if(e=Pr,Pr=null,jo=0,(be&6)!==0)throw Error(s(331));var l=be;for(be|=4,X=e.current;X!==null;){var u=X,h=u.child;if((X.flags&16)!==0){var m=u.deletions;if(m!==null){for(var _=0;_qe()-$l?Zr(e,0):Fl|=i),yt(e,t)}function If(e,t){t===0&&((e.mode&1)===0?t=1:(t=Hs,Hs<<=1,(Hs&130023424)===0&&(Hs=4194304)));var i=ft();e=ar(e,t),e!==null&&(Fi(e,t,i),yt(e,i))}function dm(e){var t=e.memoizedState,i=0;t!==null&&(i=t.retryLane),If(e,i)}function fm(e,t){var i=0;switch(e.tag){case 13:var o=e.stateNode,l=e.memoizedState;l!==null&&(i=l.retryLane);break;case 19:o=e.stateNode;break;default:throw Error(s(314))}o!==null&&o.delete(t),If(e,i)}var kf;kf=function(e,t,i){if(e!==null)if(e.memoizedProps!==t.pendingProps||ht.current)gt=!0;else{if((e.lanes&i)===0&&(t.flags&128)===0)return gt=!1,Zg(e,t,i);gt=(e.flags&131072)!==0}else gt=!1,De&&(t.flags&1048576)!==0&&rd(t,po,t.index);switch(t.lanes=0,t.tag){case 2:var o=t.type;Uo(e,t),e=t.pendingProps;var l=Mn(t,at.current);$n(t,i),l=wl(null,t,o,e,l,i);var u=vl();return t.flags|=1,typeof l=="object"&&l!==null&&typeof l.render=="function"&&l.$$typeof===void 0?(t.tag=1,t.memoizedState=null,t.updateQueue=null,pt(o)?(u=!0,co(t)):u=!1,t.memoizedState=l.state!==null&&l.state!==void 0?l.state:null,dl(t),l.updater=To,t.stateNode=l,l._reactInternals=t,bl(t,o,e,i),t=Ul(null,t,o,!0,u,i)):(t.tag=0,De&&u&&tl(t),dt(null,t,l,i),t=t.child),t;case 16:o=t.elementType;e:{switch(Uo(e,t),e=t.pendingProps,l=o._init,o=l(o._payload),t.type=o,l=t.tag=pm(o),e=Lt(o,e),l){case 0:t=El(null,t,o,e,i);break e;case 1:t=Jd(null,t,o,e,i);break e;case 11:t=qd(null,t,o,e,i);break e;case 14:t=Hd(null,t,o,Lt(o.type,e),i);break e}throw Error(s(306,o,""))}return t;case 0:return o=t.type,l=t.pendingProps,l=t.elementType===o?l:Lt(o,l),El(e,t,o,l,i);case 1:return o=t.type,l=t.pendingProps,l=t.elementType===o?l:Lt(o,l),Jd(e,t,o,l,i);case 3:e:{if(Gd(t),e===null)throw Error(s(387));o=t.pendingProps,u=t.memoizedState,l=u.element,dd(e,t),_o(t,o,null,i);var h=t.memoizedState;if(o=h.element,u.isDehydrated)if(u={element:o,isDehydrated:!1,cache:h.cache,pendingSuspenseBoundaries:h.pendingSuspenseBoundaries,transitions:h.transitions},t.updateQueue.baseState=u,t.memoizedState=u,t.flags&256){l=Vn(Error(s(423)),t),t=Xd(e,t,o,i,l);break e}else if(o!==l){l=Vn(Error(s(424)),t),t=Xd(e,t,o,i,l);break e}else for(bt=kr(t.stateNode.containerInfo.firstChild),kt=t,De=!0,$t=null,i=ud(t,null,o,i),t.child=i;i;)i.flags=i.flags&-3|4096,i=i.sibling;else{if(Dn(),o===l){t=ur(e,t,i);break e}dt(e,t,o,i)}t=t.child}return t;case 5:return pd(t),e===null&&il(t),o=t.type,l=t.pendingProps,u=e!==null?e.memoizedProps:null,h=l.children,Ja(o,l)?h=null:u!==null&&Ja(o,u)&&(t.flags|=32),Qd(e,t),dt(e,t,h,i),t.child;case 6:return e===null&&il(t),null;case 13:return Yd(e,t,i);case 4:return fl(t,t.stateNode.containerInfo),o=t.pendingProps,e===null?t.child=zn(t,null,o,i):dt(e,t,o,i),t.child;case 11:return o=t.type,l=t.pendingProps,l=t.elementType===o?l:Lt(o,l),qd(e,t,o,l,i);case 7:return dt(e,t,t.pendingProps,i),t.child;case 8:return dt(e,t,t.pendingProps.children,i),t.child;case 12:return dt(e,t,t.pendingProps.children,i),t.child;case 10:e:{if(o=t.type._context,l=t.pendingProps,u=t.memoizedProps,h=l.value,Ae(yo,o._currentValue),o._currentValue=h,u!==null)if(Ft(u.value,h)){if(u.children===l.children&&!ht.current){t=ur(e,t,i);break e}}else for(u=t.child,u!==null&&(u.return=t);u!==null;){var m=u.dependencies;if(m!==null){h=u.child;for(var _=m.firstContext;_!==null;){if(_.context===o){if(u.tag===1){_=lr(-1,i&-i),_.tag=2;var C=u.updateQueue;if(C!==null){C=C.shared;var F=C.pending;F===null?_.next=_:(_.next=F.next,F.next=_),C.pending=_}}u.lanes|=i,_=u.alternate,_!==null&&(_.lanes|=i),ul(u.return,i,t),m.lanes|=i;break}_=_.next}}else if(u.tag===10)h=u.type===t.type?null:u.child;else if(u.tag===18){if(h=u.return,h===null)throw Error(s(341));h.lanes|=i,m=h.alternate,m!==null&&(m.lanes|=i),ul(h,i,t),h=u.sibling}else h=u.child;if(h!==null)h.return=u;else for(h=u;h!==null;){if(h===t){h=null;break}if(u=h.sibling,u!==null){u.return=h.return,h=u;break}h=h.return}u=h}dt(e,t,l.children,i),t=t.child}return t;case 9:return l=t.type,o=t.pendingProps.children,$n(t,i),l=Nt(l),o=o(l),t.flags|=1,dt(e,t,o,i),t.child;case 14:return o=t.type,l=Lt(o,t.pendingProps),l=Lt(o.type,l),Hd(e,t,o,l,i);case 15:return Kd(e,t,t.type,t.pendingProps,i);case 17:return o=t.type,l=t.pendingProps,l=t.elementType===o?l:Lt(o,l),Uo(e,t),t.tag=1,pt(o)?(e=!0,co(t)):e=!1,$n(t,i),Od(t,o,l),bl(t,o,l,i),Ul(null,t,o,!0,e,i);case 19:return ef(e,t,i);case 22:return Wd(e,t,i)}throw Error(s(156,t.tag))};function bf(e,t){return nc(e,t)}function hm(e,t,i,o){this.tag=e,this.key=i,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=o,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function At(e,t,i,o){return new hm(e,t,i,o)}function Jl(e){return e=e.prototype,!(!e||!e.isReactComponent)}function pm(e){if(typeof e=="function")return Jl(e)?1:0;if(e!=null){if(e=e.$$typeof,e===Le)return 11;if(e===ke)return 14}return 2}function Mr(e,t){var i=e.alternate;return i===null?(i=At(e.tag,t,e.key,e.mode),i.elementType=e.elementType,i.type=e.type,i.stateNode=e.stateNode,i.alternate=e,e.alternate=i):(i.pendingProps=t,i.type=e.type,i.flags=0,i.subtreeFlags=0,i.deletions=null),i.flags=e.flags&14680064,i.childLanes=e.childLanes,i.lanes=e.lanes,i.child=e.child,i.memoizedProps=e.memoizedProps,i.memoizedState=e.memoizedState,i.updateQueue=e.updateQueue,t=e.dependencies,i.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},i.sibling=e.sibling,i.index=e.index,i.ref=e.ref,i}function Fo(e,t,i,o,l,u){var h=2;if(o=e,typeof e=="function")Jl(e)&&(h=1);else if(typeof e=="string")h=5;else e:switch(e){case ge:return tn(i.children,l,u,t);case me:h=8,l|=8;break;case ue:return e=At(12,i,t,l|2),e.elementType=ue,e.lanes=u,e;case Me:return e=At(13,i,t,l),e.elementType=Me,e.lanes=u,e;case it:return e=At(19,i,t,l),e.elementType=it,e.lanes=u,e;case W:return $o(i,l,u,t);default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case Re:h=10;break e;case We:h=9;break e;case Le:h=11;break e;case ke:h=14;break e;case P:h=16,o=null;break e}throw Error(s(130,e==null?e:typeof e,""))}return t=At(h,i,t,l),t.elementType=e,t.type=o,t.lanes=u,t}function tn(e,t,i,o){return e=At(7,e,o,t),e.lanes=i,e}function $o(e,t,i,o){return e=At(22,e,o,t),e.elementType=W,e.lanes=i,e.stateNode={isHidden:!1},e}function Gl(e,t,i){return e=At(6,e,null,t),e.lanes=i,e}function Xl(e,t,i){return t=At(4,e.children!==null?e.children:[],e.key,t),t.lanes=i,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}function gm(e,t,i,o,l){this.tag=t,this.containerInfo=e,this.finishedWork=this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.pendingContext=this.context=null,this.callbackPriority=0,this.eventTimes=ka(0),this.expirationTimes=ka(-1),this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=ka(0),this.identifierPrefix=o,this.onRecoverableError=l,this.mutableSourceEagerHydrationData=null}function Yl(e,t,i,o,l,u,h,m,_){return e=new gm(e,t,i,m,_),t===1?(t=1,u===!0&&(t|=8)):t=0,u=At(3,null,null,t),e.current=u,u.stateNode=e,u.memoizedState={element:o,isDehydrated:i,cache:null,transitions:null,pendingSuspenseBoundaries:null},dl(u),e}function mm(e,t,i){var o=3"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(r)}catch(n){console.error(n)}}return r(),iu.exports=Tm(),iu.exports}var zf;function Um(){if(zf)return Qo;zf=1;var r=Em();return Qo.createRoot=r.createRoot,Qo.hydrateRoot=r.hydrateRoot,Qo}var Rm=Um(),vs={},Ff;function Nm(){if(Ff)return vs;Ff=1,vs.byteLength=v,vs.toByteArray=x,vs.fromByteArray=j;for(var r=[],n=[],s=typeof Uint8Array<"u"?Uint8Array:Array,a="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",c=0,f=a.length;c0)throw new Error("Invalid string. Length must be a multiple of 4");var Q=O.indexOf("=");Q===-1&&(Q=q);var $=Q===q?0:4-Q%4;return[Q,$]}function v(O){var q=p(O),Q=q[0],$=q[1];return(Q+$)*3/4-$}function y(O,q,Q){return(q+Q)*3/4-Q}function x(O){var q,Q=p(O),$=Q[0],fe=Q[1],T=new s(y(O,$,fe)),A=0,L=fe>0?$-4:$,J;for(J=0;J>16&255,T[A++]=q>>8&255,T[A++]=q&255;return fe===2&&(q=n[O.charCodeAt(J)]<<2|n[O.charCodeAt(J+1)]>>4,T[A++]=q&255),fe===1&&(q=n[O.charCodeAt(J)]<<10|n[O.charCodeAt(J+1)]<<4|n[O.charCodeAt(J+2)]>>2,T[A++]=q>>8&255,T[A++]=q&255),T}function R(O){return r[O>>18&63]+r[O>>12&63]+r[O>>6&63]+r[O&63]}function N(O,q,Q){for(var $,fe=[],T=q;TL?L:A+T));return $===1?(q=O[Q-1],fe.push(r[q>>2]+r[q<<4&63]+"==")):$===2&&(q=(O[Q-2]<<8)+O[Q-1],fe.push(r[q>>10]+r[q>>4&63]+r[q<<2&63]+"=")),fe.join("")}return vs}var Mu=Nm(),Jo={exports:{}},$f;function Pm(){return $f||($f=1,(function(r,n){const{hasOwnProperty:s}=Object.prototype,a=fe();a.configure=fe,a.stringify=a,a.default=a,n.stringify=a,n.configure=fe,r.exports=a;const c=/[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;function f(T){return T.length<5e3&&!c.test(T)?`"${T}"`:JSON.stringify(T)}function p(T,A){if(T.length>200||A)return T.sort(A);for(let L=1;LJ;)T[Y]=T[Y-1],Y--;T[Y]=J}return T}const v=Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Object.getPrototypeOf(new Int8Array)),Symbol.toStringTag).get;function y(T){return v.call(T)!==void 0&&T.length!==0}function x(T,A,L){T.length= 1`)}return L===void 0?1/0:L}function q(T){return T===1?"1 item":`${T} items`}function Q(T){const A=new Set;for(const L of T)(typeof L=="string"||typeof L=="number")&&A.add(String(L));return A}function $(T){if(s.call(T,"strict")){const A=T.strict;if(typeof A!="boolean")throw new TypeError('The "strict" argument must be of type boolean');if(A)return L=>{let J=`Object can not safely be stringified. Received type ${typeof L}`;throw typeof L!="function"&&(J+=` (${L.toString()})`),new Error(J)}}}function fe(T){T={...T};const A=$(T);A&&(T.bigint===void 0&&(T.bigint=!1),"circularValue"in T||(T.circularValue=Error));const L=R(T),J=j(T,"bigint"),Y=N(T),ge=typeof Y=="function"?Y:void 0,me=O(T,"maximumDepth"),ue=O(T,"maximumBreadth");function Re(ke,P,W,M,H,z){let w=P[ke];switch(typeof w=="object"&&w!==null&&typeof w.toJSON=="function"&&(w=w.toJSON(ke)),w=M.call(P,ke,w),typeof w){case"string":return f(w);case"object":{if(w===null)return"null";if(W.indexOf(w)!==-1)return L;let E="",ee=",";const ne=z;if(Array.isArray(w)){if(w.length===0)return"[]";if(meue){const Dt=w.length-ue-1;E+=`${ee}"... ${q(Dt)} not stringified"`}return H!==""&&(E+=` +${ne}`),W.pop(),`[${E}]`}let te=Object.keys(w);const le=te.length;if(le===0)return"{}";if(meue){const _e=le-ue;E+=`${he}"...":${ie}"${q(_e)} not stringified"`,he=ee}return H!==""&&he.length>1&&(E=` +${z}${E} +${ne}`),W.pop(),`{${E}}`}case"number":return isFinite(w)?String(w):A?A(w):"null";case"boolean":return w===!0?"true":"false";case"undefined":return;case"bigint":if(J)return String(w);default:return A?A(w):void 0}}function We(ke,P,W,M,H,z){switch(typeof P=="object"&&P!==null&&typeof P.toJSON=="function"&&(P=P.toJSON(ke)),typeof P){case"string":return f(P);case"object":{if(P===null)return"null";if(W.indexOf(P)!==-1)return L;const w=z;let E="",ee=",";if(Array.isArray(P)){if(P.length===0)return"[]";if(meue){const we=P.length-ue-1;E+=`${ee}"... ${q(we)} not stringified"`}return H!==""&&(E+=` +${w}`),W.pop(),`[${E}]`}W.push(P);let ne="";H!==""&&(z+=H,ee=`, +${z}`,ne=" ");let te="";for(const le of M){const ie=We(le,P[le],W,M,H,z);ie!==void 0&&(E+=`${te}${f(le)}:${ne}${ie}`,te=ee)}return H!==""&&te.length>1&&(E=` +${z}${E} +${w}`),W.pop(),`{${E}}`}case"number":return isFinite(P)?String(P):A?A(P):"null";case"boolean":return P===!0?"true":"false";case"undefined":return;case"bigint":if(J)return String(P);default:return A?A(P):void 0}}function Le(ke,P,W,M,H){switch(typeof P){case"string":return f(P);case"object":{if(P===null)return"null";if(typeof P.toJSON=="function"){if(P=P.toJSON(ke),typeof P!="object")return Le(ke,P,W,M,H);if(P===null)return"null"}if(W.indexOf(P)!==-1)return L;const z=H;if(Array.isArray(P)){if(P.length===0)return"[]";if(meue){const Ge=P.length-ue-1;ie+=`${he}"... ${q(Ge)} not stringified"`}return ie+=` +${z}`,W.pop(),`[${ie}]`}let w=Object.keys(P);const E=w.length;if(E===0)return"{}";if(meue){const ie=E-ue;ne+=`${te}"...": "${q(ie)} not stringified"`,te=ee}return te!==""&&(ne=` +${H}${ne} +${z}`),W.pop(),`{${ne}}`}case"number":return isFinite(P)?String(P):A?A(P):"null";case"boolean":return P===!0?"true":"false";case"undefined":return;case"bigint":if(J)return String(P);default:return A?A(P):void 0}}function Me(ke,P,W){switch(typeof P){case"string":return f(P);case"object":{if(P===null)return"null";if(typeof P.toJSON=="function"){if(P=P.toJSON(ke),typeof P!="object")return Me(ke,P,W);if(P===null)return"null"}if(W.indexOf(P)!==-1)return L;let M="";const H=P.length!==void 0;if(H&&Array.isArray(P)){if(P.length===0)return"[]";if(meue){const ie=P.length-ue-1;M+=`,"... ${q(ie)} not stringified"`}return W.pop(),`[${M}]`}let z=Object.keys(P);const w=z.length;if(w===0)return"{}";if(meue){const ne=w-ue;M+=`${E}"...":"${q(ne)} not stringified"`}return W.pop(),`{${M}}`}case"number":return isFinite(P)?String(P):A?A(P):"null";case"boolean":return P===!0?"true":"false";case"undefined":return;case"bigint":if(J)return String(P);default:return A?A(P):void 0}}function it(ke,P,W){if(arguments.length>1){let M="";if(typeof W=="number"?M=" ".repeat(Math.min(W,10)):typeof W=="string"&&(M=W.slice(0,10)),P!=null){if(typeof P=="function")return Re("",{"":ke},[],P,M,"");if(Array.isArray(P))return We("",ke,[],Q(P),M,"")}if(M.length!==0)return Le("",ke,[],M,"")}return Me("",ke,[])}return it}})(Jo,Jo.exports)),Jo.exports}var Bm=Pm();const wh=yh(Bm);wh.configure;const Lf=wh;var bi=class Yo{__time_duration_micros__;static MICROS_PER_MILLIS=1000n;static getAlgebraicType(){return oe.Product({elements:[{name:"__time_duration_micros__",algebraicType:oe.I64}]})}static isTimeDuration(n){if(n.tag!=="Product")return!1;const s=n.value.elements;if(s.length!==1)return!1;const a=s[0];return a.name==="__time_duration_micros__"&&a.algebraicType.tag==="I64"}get micros(){return this.__time_duration_micros__}get millis(){return Number(this.micros/Yo.MICROS_PER_MILLIS)}constructor(n){this.__time_duration_micros__=n}static fromMillis(n){return new Yo(BigInt(n)*Yo.MICROS_PER_MILLIS)}toString(){const n=this.micros,s=n<0?"-":"+",a=n<0?-n:n,c=a/1000000n,f=a%1000000n;return`${s}${c}.${String(f).padStart(6,"0")}`}},Ci=class rn{__timestamp_micros_since_unix_epoch__;static MICROS_PER_MILLIS=1000n;get microsSinceUnixEpoch(){return this.__timestamp_micros_since_unix_epoch__}constructor(n){this.__timestamp_micros_since_unix_epoch__=n}static getAlgebraicType(){return oe.Product({elements:[{name:"__timestamp_micros_since_unix_epoch__",algebraicType:oe.I64}]})}static isTimestamp(n){if(n.tag!=="Product")return!1;const s=n.value.elements;if(s.length!==1)return!1;const a=s[0];return a.name==="__timestamp_micros_since_unix_epoch__"&&a.algebraicType.tag==="I64"}static UNIX_EPOCH=new rn(0n);static now(){return rn.fromDate(new Date)}toMillis(){return this.microsSinceUnixEpoch/1000n}static fromDate(n){const s=n.getTime(),a=BigInt(s)*rn.MICROS_PER_MILLIS;return new rn(a)}toDate(){const s=this.__timestamp_micros_since_unix_epoch__/rn.MICROS_PER_MILLIS;if(s>BigInt(Number.MAX_SAFE_INTEGER)||sBigInt(Number.MAX_SAFE_INTEGER)||svt.MAX_UUID_BIGINT)throw new Error("Invalid UUID: must be between 0 and `MAX_UUID_BIGINT`");this.__uuid__=n}static fromRandomBytesV4(n){if(n.length!==16)throw new Error("UUID v4 requires 16 bytes");const s=new Uint8Array(n);return s[6]=s[6]&15|64,s[8]=s[8]&63|128,new vt(vt.bytesToBigInt(s))}static fromCounterV7(n,s,a){if(a.length!==4)throw new Error("`fromCounterV7` requires `randomBytes.length == 4`");if(n.value<0)throw new Error("`fromCounterV7` uuid `counter` must be non-negative");if(s.__timestamp_micros_since_unix_epoch__<0)throw new Error("`fromCounterV7` `timestamp` before unix epoch");const c=n.value;n.value=c+1&2147483647;const f=s.toMillis()&0xffffffffffffn,p=new Uint8Array(16);return p[0]=Number(f>>40n&0xffn),p[1]=Number(f>>32n&0xffn),p[2]=Number(f>>24n&0xffn),p[3]=Number(f>>16n&0xffn),p[4]=Number(f>>8n&0xffn),p[5]=Number(f&0xffn),p[7]=c>>>23&255,p[9]=c>>>15&255,p[10]=c>>>7&255,p[11]=(c&127)<<1&255,p[12]|=a[0]&127,p[13]=a[1],p[14]=a[2],p[15]=a[3],p[6]=p[6]&15|112,p[8]=p[8]&63|128,new vt(vt.bytesToBigInt(p))}static parse(n){const s=n.replace(/-/g,"");if(s.length!==32)throw new Error("Invalid hex UUID");let a=0n;for(let c=0;c<32;c+=2)a=a<<8n|BigInt(parseInt(s.slice(c,c+2),16));return new vt(a)}toString(){const s=[...vt.bigIntToBytes(this.__uuid__)].map(a=>a.toString(16).padStart(2,"0")).join("");return s.slice(0,8)+"-"+s.slice(8,12)+"-"+s.slice(12,16)+"-"+s.slice(16,20)+"-"+s.slice(20)}asBigInt(){return this.__uuid__}toBytes(){return vt.bigIntToBytes(this.__uuid__)}static bytesToBigInt(n){let s=0n;for(const a of n)s=s<<8n|BigInt(a);return s}static bigIntToBytes(n){const s=new Uint8Array(16);for(let a=15;a>=0;a--)s[a]=Number(n&0xffn),n>>=8n;return s}getVersion(){const n=this.toBytes()[6]>>4&15;switch(n){case 4:return"V4";case 7:return"V7";default:if(this==vt.NIL)return"Nil";if(this==vt.MAX)return"Max";throw new Error(`Unsupported UUID version: ${n}`)}}getCounter(){const n=this.toBytes(),s=n[7],a=n[9],c=n[10],f=n[11]>>>1;return s<<23|a<<15|c<<7|f|0}compareTo(n){return this.__uuid__n.__uuid__?1:0}static getAlgebraicType(){return oe.Product({elements:[{name:"__uuid__",algebraicType:oe.U128}]})}},ze=class{view;offset=0;constructor(n){this.view=n instanceof DataView?n:new DataView(n.buffer,n.byteOffset,n.byteLength),this.offset=0}reset(n){this.view=n,this.offset=0}get remaining(){return this.view.byteLength-this.offset}#e(n){if(this.offset+n>this.view.byteLength)throw new RangeError(`Tried to read ${n} byte(s) at relative offset ${this.offset}, but only ${this.remaining} byte(s) remain`)}readUInt8Array(){const n=this.readU32();return this.#e(n),this.readBytes(n)}readBool(){const n=this.view.getUint8(this.offset);return this.offset+=1,n!==0}readByte(){const n=this.view.getUint8(this.offset);return this.offset+=1,n}readBytes(n){const s=new Uint8Array(this.view.buffer,this.view.byteOffset+this.offset,n);return this.offset+=n,s}readI8(){const n=this.view.getInt8(this.offset);return this.offset+=1,n}readU8(){return this.readByte()}readI16(){const n=this.view.getInt16(this.offset,!0);return this.offset+=2,n}readU16(){const n=this.view.getUint16(this.offset,!0);return this.offset+=2,n}readI32(){const n=this.view.getInt32(this.offset,!0);return this.offset+=4,n}readU32(){const n=this.view.getUint32(this.offset,!0);return this.offset+=4,n}readI64(){const n=this.view.getBigInt64(this.offset,!0);return this.offset+=8,n}readU64(){const n=this.view.getBigUint64(this.offset,!0);return this.offset+=8,n}readU128(){const n=this.view.getBigUint64(this.offset,!0),s=this.view.getBigUint64(this.offset+8,!0);return this.offset+=16,(s<>BigInt(64);this.view.setBigUint64(this.offset,s,!0),this.view.setBigUint64(this.offset+8,a,!0),this.offset+=16}writeI128(n){this.expandBuffer(16);const s=n&BigInt("0xFFFFFFFFFFFFFFFF"),a=n>>BigInt(64);this.view.setBigInt64(this.offset,s,!0),this.view.setBigInt64(this.offset+8,a,!0),this.offset+=16}writeU256(n){this.expandBuffer(32);const s=BigInt("0xFFFFFFFFFFFFFFFF"),a=n&s,c=n>>BigInt(64)&s,f=n>>BigInt(128)&s,p=n>>BigInt(192);this.view.setBigUint64(this.offset+0,a,!0),this.view.setBigUint64(this.offset+8,c,!0),this.view.setBigUint64(this.offset+16,f,!0),this.view.setBigUint64(this.offset+24,p,!0),this.offset+=32}writeI256(n){this.expandBuffer(32);const s=BigInt("0xFFFFFFFFFFFFFFFF"),a=n&s,c=n>>BigInt(64)&s,f=n>>BigInt(128)&s,p=n>>BigInt(192);this.view.setBigUint64(this.offset+0,a,!0),this.view.setBigUint64(this.offset+8,c,!0),this.view.setBigUint64(this.offset+16,f,!0),this.view.setBigInt64(this.offset+24,p,!0),this.offset+=32}writeF32(n){this.expandBuffer(4),this.view.setFloat32(this.offset,n,!0),this.offset+=4}writeF64(n){this.expandBuffer(8),this.view.setFloat64(this.offset,n,!0),this.offset+=8}writeString(n){const a=new TextEncoder().encode(n);this.writeUInt8Array(a)}};function Is(r,n){if(r===n)return!0;if(typeof r!="object"||r===null||typeof n!="object"||n===null)return!1;const s=Object.keys(r),a=Object.keys(n);if(s.length!==a.length)return!1;for(const c of s)if(!a.includes(c)||!Is(r[c],n[c]))return!1;return!0}function _h(r){return Array.prototype.map.call(r.reverse(),n=>("00"+n.toString(16)).slice(-2)).join("")}function jm(r){if(r.length!=16)throw new Error(`Uint8Array is not 16 bytes long: ${r}`);return new ze(r).readU128()}function Om(r){if(r.length!=32)throw new Error(`Uint8Array is not 32 bytes long: [${r}]`);return new ze(r).readU256()}function Sh(r){r.startsWith("0x")&&(r=r.slice(2));const n=r.match(/.{1,2}/g)||[];return Uint8Array.from(n.map(a=>parseInt(a,16))).reverse()}function Dm(r){return jm(Sh(r))}function zm(r){return Om(Sh(r))}function xh(r){const n=new Pe(16);return n.writeU128(r),n.getBuffer()}function Ih(r){return _h(xh(r))}function kh(r){const n=new Pe(32);return n.writeU256(r),n.getBuffer()}function bh(r){return _h(kh(r))}function Fm(r){const n=Ch(r);return n.charAt(0).toUpperCase()+n.slice(1)}function Ch(r){const n=r.replace(/[-_]+/g,"_").replace(/_([a-zA-Z0-9])/g,(s,a)=>a.toUpperCase());return n.charAt(0).toLowerCase()+n.slice(1)}var Vf=Object.hasOwn,Bs=class fu{__identity__;constructor(n){this.__identity__=typeof n=="string"?zm(n):n}static getAlgebraicType(){return oe.Product({elements:[{name:"__identity__",algebraicType:oe.U256}]})}isEqual(n){return this.toHexString()===n.toHexString()}equals(n){return this.isEqual(n)}toHexString(){return bh(this.__identity__)}toUint8Array(){return kh(this.__identity__)}static fromString(n){return new fu(n)}static zero(){return new fu(0n)}toString(){return this.toHexString()}},bs=new Map,Cs=new Map,oe={Ref:r=>({tag:"Ref",value:r}),Sum:r=>({tag:"Sum",value:r}),Product:r=>({tag:"Product",value:r}),Array:r=>({tag:"Array",value:r}),String:{tag:"String"},Bool:{tag:"Bool"},I8:{tag:"I8"},U8:{tag:"U8"},I16:{tag:"I16"},U16:{tag:"U16"},I32:{tag:"I32"},U32:{tag:"U32"},I64:{tag:"I64"},U64:{tag:"U64"},I128:{tag:"I128"},U128:{tag:"U128"},I256:{tag:"I256"},U256:{tag:"U256"},F32:{tag:"F32"},F64:{tag:"F64"},makeSerializer(r,n){if(r.tag==="Ref"){if(!n)throw new Error("cannot serialize refs without a typespace");for(;r.tag==="Ref";)r=n.types[r.value]}switch(r.tag){case"Product":return pr.makeSerializer(r.value,n);case"Sum":return ua.makeSerializer(r.value,n);case"Array":if(r.value.tag==="U8")return $m;{const s=oe.makeSerializer(r.value,n);return(a,c)=>{a.writeU32(c.length);for(const f of c)s(a,f)}}default:return Th[r.tag]}},serializeValue(r,n,s,a){oe.makeSerializer(n,a)(r,s)},makeDeserializer(r,n){if(r.tag==="Ref"){if(!n)throw new Error("cannot deserialize refs without a typespace");for(;r.tag==="Ref";)r=n.types[r.value]}switch(r.tag){case"Product":return pr.makeDeserializer(r.value,n);case"Sum":return ua.makeDeserializer(r.value,n);case"Array":if(r.value.tag==="U8")return Lm;{const s=oe.makeDeserializer(r.value,n);return a=>{const c=a.readU32(),f=Array(c);for(let p=0;pr.elements.every(({algebraicType:n})=>Vm.has(n.tag)),qm=r=>r.elements.reduce((n,{algebraicType:s})=>n+xi[s.tag],0),Go={Bool:"Uint8",I8:"Int8",U8:"Uint8",I16:"Int16",U16:"Uint16",I32:"Int32",U32:"Uint32",I64:"BigInt64",U64:"BigUint64",F32:"Float32",F64:"Float64"},Zo={__time_duration_micros__:r=>new bi(r.readI64()),__timestamp_micros_since_unix_epoch__:r=>new Ci(r.readI64()),__identity__:r=>new Bs(r.readU256()),__connection_id__:r=>new ga(r.readU128()),__uuid__:r=>new vh(r.readU128())};Object.freeze(Zo);var Hm=()=>({}),Hf=r=>{let n;switch(r.algebraicType.tag){case"String":n="''";break;case"Bool":n="false";break;case"I8":case"U8":case"I16":case"U16":case"I32":case"U32":n="0";break;case"I64":case"U64":case"I128":case"U128":case"I256":case"U256":n="0n";break;case"F32":case"F64":n="0.0";break;default:n="undefined"}return`${r.name}: ${n}`},pr={makeSerializer(r,n){let s=bs.get(r);if(s!=null)return s;if(qf(r)){const p=`"use strict"; +writer.expandBuffer(${qm(r)}); +const view = writer.view; +${r.elements.map(({name:v,algebraicType:{tag:y}})=>y in Go?`view.set${Go[y]}(writer.offset, value.${v}, ${xi[y]>1?"true":""}); +writer.offset += ${xi[y]};`:`writer.write${y}(value.${v});`).join(` +`)}`;return s=Function("writer","value",p),bs.set(r,s),s}const a={},c=`"use strict"; +`+r.elements.map(f=>`this.${f.name}(writer, value.${f.name});`).join(` +`);s=Function("writer","value",c).bind(a),bs.set(r,s);for(const{name:f,algebraicType:p}of r.elements)a[f]=oe.makeSerializer(p,n);return Object.freeze(a),s},serializeValue(r,n,s,a){pr.makeSerializer(n,a)(r,s)},makeDeserializer(r,n){switch(r.elements.length){case 0:return Hm;case 1:{const c=r.elements[0].name;if(Vf(Zo,c))return Zo[c]}}let s=Cs.get(r);if(s!=null)return s;if(qf(r)){const c=`"use strict"; +const result = { ${r.elements.map(Hf).join(", ")} }; +const view = reader.view; +${r.elements.map(({name:f,algebraicType:{tag:p}})=>p in Go?p==="Bool"?`result.${f} = view.getUint8(reader.offset) !== 0; +reader.offset += 1;`:`result.${f} = view.get${Go[p]}(reader.offset, ${xi[p]>1?"true":""}); +reader.offset += ${xi[p]};`:`result.${f} = reader.read${p}();`).join(` +`)} +return result;`;return s=Function("reader",c),Cs.set(r,s),s}const a={};s=Function("reader",`"use strict"; +const result = { ${r.elements.map(Hf).join(", ")} }; +${r.elements.map(({name:c})=>`result.${c} = this.${c}(reader);`).join(` +`)} +return result;`).bind(a),Cs.set(r,s);for(const{name:c,algebraicType:f}of r.elements)a[c]=oe.makeDeserializer(f,n);return Object.freeze(a),s},deserializeValue(r,n,s){return pr.makeDeserializer(n,s)(r)},intoMapKey(r,n){if(r.elements.length===1){const a=r.elements[0].name;if(Vf(Zo,a))return n[a]}const s=new Pe(10);return oe.serializeValue(s,oe.Product(r),n),s.toBase64()}},ua={makeSerializer(r,n){if(r.variants.length==2&&r.variants[0].name==="some"&&r.variants[1].name==="none"){const s=oe.makeSerializer(r.variants[0].algebraicType,n);return(a,c)=>{c!=null?(a.writeByte(0),s(a,c)):a.writeByte(1)}}else if(r.variants.length==2&&r.variants[0].name==="ok"&&r.variants[1].name==="err"){const s=oe.makeSerializer(r.variants[0].algebraicType,n),a=oe.makeSerializer(r.variants[0].algebraicType,n);return(c,f)=>{if("ok"in f)c.writeU8(0),s(c,f.ok);else if("err"in f)c.writeU8(1),a(c,f.err);else throw new TypeError("could not serialize result: object had neither a `ok` nor an `err` field")}}else{let s=bs.get(r);if(s!=null)return s;const a={},c=`switch (value.tag) { +${r.variants.map(({name:f},p)=>` case ${JSON.stringify(f)}: + writer.writeByte(${p}); + return this.${f}(writer, value.value);`).join(` +`)} + default: + throw new TypeError( + \`Could not serialize sum type; unknown tag \${value.tag}\` + ) +} +`;s=Function("writer","value",c).bind(a),bs.set(r,s);for(const{name:f,algebraicType:p}of r.variants)a[f]=oe.makeSerializer(p,n);return Object.freeze(a),s}},serializeValue(r,n,s,a){ua.makeSerializer(n,a)(r,s)},makeDeserializer(r,n){if(r.variants.length==2&&r.variants[0].name==="some"&&r.variants[1].name==="none"){const s=oe.makeDeserializer(r.variants[0].algebraicType,n);return a=>{const c=a.readU8();if(c===0)return s(a);if(c===1)return;throw`Can't deserialize an option type, couldn't find ${c} tag`}}else if(r.variants.length==2&&r.variants[0].name==="ok"&&r.variants[1].name==="err"){const s=oe.makeDeserializer(r.variants[0].algebraicType,n),a=oe.makeDeserializer(r.variants[1].algebraicType,n);return c=>{const f=c.readByte();if(f===0)return{ok:s(c)};if(f===1)return{err:a(c)};throw`Can't deserialize a result type, couldn't find ${f} tag`}}else{let s=Cs.get(r);if(s!=null)return s;const a={};s=Function("reader",`switch (reader.readU8()) { +${r.variants.map(({name:c},f)=>`case ${f}: return { tag: ${JSON.stringify(c)}, value: this.${c}(reader) };`).join(` +`)} }`).bind(a),Cs.set(r,s);for(const{name:c,algebraicType:f}of r.variants)a[c]=oe.makeDeserializer(f,n);return Object.freeze(a),s}},deserializeValue(r,n,s){return ua.makeDeserializer(n,s)(r)}},ga=class ea{__connection_id__;constructor(n){this.__connection_id__=n}static getAlgebraicType(){return oe.Product({elements:[{name:"__connection_id__",algebraicType:oe.U128}]})}isZero(){return this.__connection_id__===BigInt(0)}static nullIfZero(n){return n.isZero()?null:n}static random(){function n(){return Math.floor(Math.random()*255)}let s=BigInt(0);for(let a=0;a<16;a++)s=s<c.name==="Interval"),a=n.find(c=>c.name==="Time");return!s||!a?!1:bi.isTimeDuration(s.algebraicType)&&Ci.isTimestamp(a.algebraicType)}},Jm=r=>({tag:"Interval",value:new bi(r)}),Gm=r=>({tag:"Time",value:new Ci(r)}),Uh=Qm,Xm={getAlgebraicType(r){return oe.Sum({variants:[{name:"some",algebraicType:r},{name:"none",algebraicType:oe.Product({elements:[]})}]})}},Ym={getAlgebraicType(r,n){return oe.Sum({variants:[{name:"ok",algebraicType:r},{name:"err",algebraicType:n}]})}},ma=Symbol("QueryBrand"),Zm=r=>!!r&&typeof r=="object"&&ma in r;function ey(r){return r.toSql()}var Kf=class Rh{constructor(n,s,a){if(this.sourceQuery=n,this.filterQuery=s,this.joinCondition=a,n.table.sourceName===s.table.sourceName)throw new Error("Cannot semijoin a table to itself")}[ma]=!0;type="semijoin";build(){return this}where(n){const s=this.sourceQuery.where(n);return new Rh(s,this.filterQuery,this.joinCondition)}toSql(){const n=this.filterQuery,s=this.sourceQuery,a=As(n.table.sourceName),c=As(s.table.sourceName);let f=`SELECT ${c}.* FROM ${a} JOIN ${c} ON ${yn(this.joinCondition)}`;const p=[];if(n.whereClause&&p.push(yn(n.whereClause)),s.whereClause&&p.push(yn(s.whereClause)),p.length>0){const v=p.length===1?p[0]:p.map(Ts).join(" AND ");f+=` WHERE ${v}`}return f}},ty=class ta{constructor(n,s){this.table=n,this.whereClause=s}[ma]=!0;where(n){const s=ay(n(this.table.cols)),a=this.whereClause?this.whereClause.and(s):s;return new ta(this.table,a)}rightSemijoin(n,s){const a=new ta(n),c=s(this.table.indexedCols,n.indexedCols);return new Kf(a,this,c)}leftSemijoin(n,s){const a=new ta(n),c=s(this.table.indexedCols,n.indexedCols);return new Kf(this,a,c)}toSql(){return sy(this.table,this.whereClause)}build(){return this}},ry=class{[ma]=!0;type="table";sourceName;accessorName;cols;indexedCols;tableDef;get columns(){return this.tableDef.columns}get indexes(){return this.tableDef.indexes}get rowType(){return this.tableDef.rowType}get constraints(){return this.tableDef.constraints}constructor(r){this.sourceName=r.sourceName,this.accessorName=r.accessorName,this.cols=iy(r),this.indexedCols=this.cols,this.tableDef=r,Object.freeze(this)}asFrom(){return new ty(this)}rightSemijoin(r,n){return this.asFrom().rightSemijoin(r,n)}leftSemijoin(r,n){return this.asFrom().leftSemijoin(r,n)}build(){return this.asFrom().build()}toSql(){return this.asFrom().toSql()}where(r){return this.asFrom().where(r)}};function ny(r){return new ry(r)}function Nh(r){const n=Object.create(null);for(const s of Object.values(r.tables)){const a=ny(s);n[s.accessorName]=a}return Object.freeze(n)}function iy(r){const n={};for(const s of Object.keys(r.columns)){const a=r.columns[s],c=new oy(r.sourceName,s,a.typeBuilder.algebraicType,a.columnMetadata.name);n[s]=Object.freeze(c)}return Object.freeze(n)}function sy(r,n,s=[]){const c=`SELECT * FROM ${As(r.sourceName)}`,f=[];if(n&&f.push(yn(n)),f.push(...s),f.length===0)return c;const p=f.length===1?f[0]:f.map(Ts).join(" AND ");return`${c} WHERE ${p}`}var oy=class{type="column";column;columnName;table;tsValueType;spacetimeType;constructor(r,n,s,a){this.table=r,this.column=n,this.columnName=a||n,this.spacetimeType=s}eq(r){return new rr({type:"eq",left:this,right:Qn(r)})}ne(r){return new rr({type:"ne",left:this,right:Qn(r)})}lt(r){return new rr({type:"lt",left:this,right:Qn(r)})}lte(r){return new rr({type:"lte",left:this,right:Qn(r)})}gt(r){return new rr({type:"gt",left:this,right:Qn(r)})}gte(r){return new rr({type:"gte",left:this,right:Qn(r)})}};function ra(r){return{type:"literal",value:r}}function Qn(r){return r.type==="literal"||typeof r=="object"&&r!=null&&"type"in r&&r.type==="column"?r:ra(r)}function ay(r){return r instanceof rr?r:typeof r=="boolean"?new rr({type:"eq",left:ra(r),right:ra(!0)}):new rr({type:"eq",left:r,right:ra(!0)})}var rr=class na{constructor(n){this.data=n}and(n){return new na({type:"and",clauses:[this.data,n.data]})}or(n){return new na({type:"or",clauses:[this.data,n.data]})}not(){return new na({type:"not",clause:this.data})}};function yn(r,n){const s=r instanceof rr?r.data:r;switch(s.type){case"eq":return`${Mt(s.left)} = ${Mt(s.right)}`;case"ne":return`${Mt(s.left)} <> ${Mt(s.right)}`;case"gt":return`${Mt(s.left)} > ${Mt(s.right)}`;case"gte":return`${Mt(s.left)} >= ${Mt(s.right)}`;case"lt":return`${Mt(s.left)} < ${Mt(s.right)}`;case"lte":return`${Mt(s.left)} <= ${Mt(s.right)}`;case"and":return s.clauses.map(a=>yn(a)).map(Ts).join(" AND ");case"or":return s.clauses.map(a=>yn(a)).map(Ts).join(" OR ");case"not":return`NOT ${Ts(yn(s.clause))}`}}function Ts(r){return`(${r})`}function Mt(r,n){if(uy(r))return ly(r.value);const s=r.table;return`${As(s)}.${As(r.columnName)}`}function ly(r){if(r==null)return"NULL";if(r instanceof Bs||r instanceof ga)return`0x${r.toHexString()}`;if(r instanceof Ci)return`'${r.toISOString()}'`;switch(typeof r){case"number":case"bigint":return String(r);case"boolean":return r?"TRUE":"FALSE";case"string":return`'${r.replace(/'/g,"''")}'`;default:return`'${JSON.stringify(r).replace(/'/g,"''")}'`}}function As(r){return`"${r.replace(/"/g,'""')}"`}function uy(r){return r.type==="literal"}function g(r,n){return{...r,...n}}var Te=class{type;algebraicType;constructor(r){this.algebraicType=r}optional(){return new ca(this)}serialize(r,n){(this.serialize=oe.makeSerializer(this.algebraicType))(r,n)}deserialize(r){return(this.deserialize=oe.makeDeserializer(this.algebraicType))(r)}},cy=class extends Te{constructor(){super(oe.U8)}index(r="btree"){return new Jn(this,g(U,{indexType:r}))}unique(){return new Jn(this,g(U,{isUnique:!0}))}primaryKey(){return new Jn(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new Jn(this,g(U,{isAutoIncrement:!0}))}default(r){return new Jn(this,g(U,{defaultValue:r}))}name(r){return new Jn(this,g(U,{name:r}))}},dy=class extends Te{constructor(){super(oe.U16)}index(r="btree"){return new Gn(this,g(U,{indexType:r}))}unique(){return new Gn(this,g(U,{isUnique:!0}))}primaryKey(){return new Gn(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new Gn(this,g(U,{isAutoIncrement:!0}))}default(r){return new Gn(this,g(U,{defaultValue:r}))}name(r){return new Gn(this,g(U,{name:r}))}},fy=class extends Te{constructor(){super(oe.U32)}index(r="btree"){return new Xn(this,g(U,{indexType:r}))}unique(){return new Xn(this,g(U,{isUnique:!0}))}primaryKey(){return new Xn(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new Xn(this,g(U,{isAutoIncrement:!0}))}default(r){return new Xn(this,g(U,{defaultValue:r}))}name(r){return new Xn(this,g(U,{name:r}))}},hy=class extends Te{constructor(){super(oe.U64)}index(r="btree"){return new Yn(this,g(U,{indexType:r}))}unique(){return new Yn(this,g(U,{isUnique:!0}))}primaryKey(){return new Yn(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new Yn(this,g(U,{isAutoIncrement:!0}))}default(r){return new Yn(this,g(U,{defaultValue:r}))}name(r){return new Yn(this,g(U,{name:r}))}},py=class extends Te{constructor(){super(oe.U128)}index(r="btree"){return new Zn(this,g(U,{indexType:r}))}unique(){return new Zn(this,g(U,{isUnique:!0}))}primaryKey(){return new Zn(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new Zn(this,g(U,{isAutoIncrement:!0}))}default(r){return new Zn(this,g(U,{defaultValue:r}))}name(r){return new Zn(this,g(U,{name:r}))}},gy=class extends Te{constructor(){super(oe.U256)}index(r="btree"){return new ei(this,g(U,{indexType:r}))}unique(){return new ei(this,g(U,{isUnique:!0}))}primaryKey(){return new ei(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new ei(this,g(U,{isAutoIncrement:!0}))}default(r){return new ei(this,g(U,{defaultValue:r}))}name(r){return new ei(this,g(U,{name:r}))}},my=class extends Te{constructor(){super(oe.I8)}index(r="btree"){return new ti(this,g(U,{indexType:r}))}unique(){return new ti(this,g(U,{isUnique:!0}))}primaryKey(){return new ti(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new ti(this,g(U,{isAutoIncrement:!0}))}default(r){return new ti(this,g(U,{defaultValue:r}))}name(r){return new ti(this,g(U,{name:r}))}},yy=class extends Te{constructor(){super(oe.I16)}index(r="btree"){return new ri(this,g(U,{indexType:r}))}unique(){return new ri(this,g(U,{isUnique:!0}))}primaryKey(){return new ri(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new ri(this,g(U,{isAutoIncrement:!0}))}default(r){return new ri(this,g(U,{defaultValue:r}))}name(r){return new ri(this,g(U,{name:r}))}},wy=class extends Te{constructor(){super(oe.I32)}index(r="btree"){return new ni(this,g(U,{indexType:r}))}unique(){return new ni(this,g(U,{isUnique:!0}))}primaryKey(){return new ni(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new ni(this,g(U,{isAutoIncrement:!0}))}default(r){return new ni(this,g(U,{defaultValue:r}))}name(r){return new ni(this,g(U,{name:r}))}},vy=class extends Te{constructor(){super(oe.I64)}index(r="btree"){return new ii(this,g(U,{indexType:r}))}unique(){return new ii(this,g(U,{isUnique:!0}))}primaryKey(){return new ii(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new ii(this,g(U,{isAutoIncrement:!0}))}default(r){return new ii(this,g(U,{defaultValue:r}))}name(r){return new ii(this,g(U,{name:r}))}},_y=class extends Te{constructor(){super(oe.I128)}index(r="btree"){return new si(this,g(U,{indexType:r}))}unique(){return new si(this,g(U,{isUnique:!0}))}primaryKey(){return new si(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new si(this,g(U,{isAutoIncrement:!0}))}default(r){return new si(this,g(U,{defaultValue:r}))}name(r){return new si(this,g(U,{name:r}))}},Sy=class extends Te{constructor(){super(oe.I256)}index(r="btree"){return new oi(this,g(U,{indexType:r}))}unique(){return new oi(this,g(U,{isUnique:!0}))}primaryKey(){return new oi(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new oi(this,g(U,{isAutoIncrement:!0}))}default(r){return new oi(this,g(U,{defaultValue:r}))}name(r){return new oi(this,g(U,{name:r}))}},xy=class extends Te{constructor(){super(oe.F32)}default(r){return new Qf(this,g(U,{defaultValue:r}))}name(r){return new Qf(this,g(U,{name:r}))}},Wf=class extends Te{constructor(){super(oe.F64)}default(r){return new Jf(this,g(U,{defaultValue:r}))}name(r){return new Jf(this,g(U,{name:r}))}},Iy=class extends Te{constructor(){super(oe.Bool)}index(r="btree"){return new _s(this,g(U,{indexType:r}))}unique(){return new _s(this,g(U,{isUnique:!0}))}primaryKey(){return new _s(this,g(U,{isPrimaryKey:!0}))}default(r){return new _s(this,g(U,{defaultValue:r}))}name(r){return new _s(this,g(U,{name:r}))}},ky=class extends Te{constructor(){super(oe.String)}index(r="btree"){return new Ss(this,g(U,{indexType:r}))}unique(){return new Ss(this,g(U,{isUnique:!0}))}primaryKey(){return new Ss(this,g(U,{isPrimaryKey:!0}))}default(r){return new Ss(this,g(U,{defaultValue:r}))}name(r){return new Ss(this,g(U,{name:r}))}},hu=class extends Te{element;constructor(r){super(oe.Array(r.algebraicType)),this.element=r}default(r){return new Gf(this,g(U,{defaultValue:r}))}name(r){return new Gf(this,g(U,{name:r}))}},by=class extends Te{constructor(){super(oe.Array(oe.U8))}default(r){return new Xf(g(U,{defaultValue:r}))}name(r){return new Xf(g(U,{name:r}))}},ca=class extends Te{value;constructor(r){super(Xm.getAlgebraicType(r.algebraicType)),this.value=r}default(r){return new Yf(this,g(U,{defaultValue:r}))}name(r){return new Yf(this,g(U,{name:r}))}},ki=class extends Te{typeName;elements;constructor(r,n){function s(a){return Object.keys(a).map(c=>({name:c,get algebraicType(){return a[c].algebraicType}}))}super(oe.Product({elements:s(r)})),this.typeName=n,this.elements=r}default(r){return new Zf(this,g(U,{defaultValue:r}))}name(r){return new Zf(this,g(U,{name:r}))}},pu=class extends Te{ok;err;constructor(r,n){super(Ym.getAlgebraicType(r.algebraicType,n.algebraicType)),this.ok=r,this.err=n}default(r){return new By(this,g(U,{defaultValue:r}))}},ju=class extends Te{constructor(){super({tag:"Product",value:{elements:[]}})}},wn=class extends Te{row;typeName;constructor(r,n){const s=Object.fromEntries(Object.entries(r).map(([c,f])=>[c,f instanceof Ee?f:new Ee(f,{})])),a=Object.keys(s).map(c=>({name:c,get algebraicType(){return s[c].typeBuilder.algebraicType}}));super(oe.Product({elements:a})),this.row=s,this.typeName=n}},Ph=class extends Te{variants;typeName;constructor(r,n){function s(a){return Object.keys(a).map(c=>({name:c,get algebraicType(){return a[c].algebraicType}}))}super(oe.Sum({variants:s(r)})),this.variants=r,this.typeName=n;for(const a of Object.keys(r)){const c=Object.getOwnPropertyDescriptor(r,a),f=!!c&&(typeof c.get=="function"||typeof c.set=="function");let p=!1;if(f||(p=r[a]instanceof ju),p){const v=this.create(a);Object.defineProperty(this,a,{value:v,writable:!1,enumerable:!0,configurable:!1})}else Object.defineProperty(this,a,{value:(y=>this.create(a,y)),writable:!1,enumerable:!0,configurable:!1})}}create(r,n){return n===void 0?{tag:r}:{tag:r,value:n}}default(r){return new xu(this,g(U,{defaultValue:r}))}name(r){return new xu(this,g(U,{name:r}))}},gu=Ph,Cy=class extends Ph{index(r="btree"){return new eh(this,g(U,{indexType:r}))}primaryKey(){return new eh(this,g(U,{isPrimaryKey:!0}))}},Ty=class extends Te{constructor(){super(Uh.getAlgebraicType())}default(r){return new th(this,g(U,{defaultValue:r}))}name(r){return new th(this,g(U,{name:r}))}},Ey=class extends Te{constructor(){super(Bs.getAlgebraicType())}index(r="btree"){return new ai(this,g(U,{indexType:r}))}unique(){return new ai(this,g(U,{isUnique:!0}))}primaryKey(){return new ai(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new ai(this,g(U,{isAutoIncrement:!0}))}default(r){return new ai(this,g(U,{defaultValue:r}))}name(r){return new ai(this,g(U,{name:r}))}},Uy=class extends Te{constructor(){super(ga.getAlgebraicType())}index(r="btree"){return new li(this,g(U,{indexType:r}))}unique(){return new li(this,g(U,{isUnique:!0}))}primaryKey(){return new li(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new li(this,g(U,{isAutoIncrement:!0}))}default(r){return new li(this,g(U,{defaultValue:r}))}name(r){return new li(this,g(U,{name:r}))}},Ry=class extends Te{constructor(){super(Ci.getAlgebraicType())}index(r="btree"){return new ui(this,g(U,{indexType:r}))}unique(){return new ui(this,g(U,{isUnique:!0}))}primaryKey(){return new ui(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new ui(this,g(U,{isAutoIncrement:!0}))}default(r){return new ui(this,g(U,{defaultValue:r}))}name(r){return new ui(this,g(U,{name:r}))}},Ny=class extends Te{constructor(){super(bi.getAlgebraicType())}index(r="btree"){return new ci(this,g(U,{indexType:r}))}unique(){return new ci(this,g(U,{isUnique:!0}))}primaryKey(){return new ci(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new ci(this,g(U,{isAutoIncrement:!0}))}default(r){return new ci(this,g(U,{defaultValue:r}))}name(r){return new ci(this,g(U,{name:r}))}},Py=class extends Te{constructor(){super(vh.getAlgebraicType())}index(r="btree"){return new di(this,g(U,{indexType:r}))}unique(){return new di(this,g(U,{isUnique:!0}))}primaryKey(){return new di(this,g(U,{isPrimaryKey:!0}))}autoInc(){return new di(this,g(U,{isAutoIncrement:!0}))}default(r){return new di(this,g(U,{defaultValue:r}))}name(r){return new di(this,g(U,{name:r}))}},U={},Ee=class{typeBuilder;columnMetadata;constructor(r,n){this.typeBuilder=r,this.columnMetadata=n}serialize(r,n){this.typeBuilder.serialize(r,n)}deserialize(r){return this.typeBuilder.deserialize(r)}},Jn=class nn extends Ee{index(n="btree"){return new nn(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new nn(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new nn(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new nn(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new nn(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new nn(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Gn=class sn extends Ee{index(n="btree"){return new sn(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new sn(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new sn(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new sn(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new sn(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new sn(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Xn=class on extends Ee{index(n="btree"){return new on(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new on(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new on(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new on(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new on(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new on(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Yn=class an extends Ee{index(n="btree"){return new an(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new an(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new an(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new an(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new an(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new an(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Zn=class ln extends Ee{index(n="btree"){return new ln(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new ln(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new ln(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new ln(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new ln(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new ln(this.typeBuilder,g(this.columnMetadata,{name:n}))}},ei=class un extends Ee{index(n="btree"){return new un(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new un(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new un(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new un(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new un(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new un(this.typeBuilder,g(this.columnMetadata,{name:n}))}},ti=class cn extends Ee{index(n="btree"){return new cn(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new cn(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new cn(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new cn(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new cn(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new cn(this.typeBuilder,g(this.columnMetadata,{name:n}))}},ri=class dn extends Ee{index(n="btree"){return new dn(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new dn(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new dn(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new dn(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new dn(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new dn(this.typeBuilder,g(this.columnMetadata,{name:n}))}},ni=class fn extends Ee{index(n="btree"){return new fn(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new fn(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new fn(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new fn(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new fn(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new fn(this.typeBuilder,g(this.columnMetadata,{name:n}))}},ii=class hn extends Ee{index(n="btree"){return new hn(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new hn(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new hn(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new hn(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new hn(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new hn(this.typeBuilder,g(this.columnMetadata,{name:n}))}},si=class pn extends Ee{index(n="btree"){return new pn(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new pn(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new pn(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new pn(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new pn(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new pn(this.typeBuilder,g(this.columnMetadata,{name:n}))}},oi=class gn extends Ee{index(n="btree"){return new gn(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new gn(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new gn(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}autoInc(){return new gn(this.typeBuilder,g(this.columnMetadata,{isAutoIncrement:!0}))}default(n){return new gn(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new gn(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Qf=class mu extends Ee{default(n){return new mu(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new mu(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Jf=class yu extends Ee{default(n){return new yu(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new yu(this.typeBuilder,g(this.columnMetadata,{name:n}))}},_s=class gi extends Ee{index(n="btree"){return new gi(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new gi(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new gi(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}default(n){return new gi(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new gi(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Ss=class mi extends Ee{index(n="btree"){return new mi(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new mi(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new mi(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}default(n){return new mi(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new mi(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Gf=class wu extends Ee{default(n){return new wu(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new wu(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Xf=class vu extends Ee{constructor(n){super(new Te(oe.Array(oe.U8)),n)}default(n){return new vu(g(this.columnMetadata,{defaultValue:n}))}name(n){return new vu(g(this.columnMetadata,{name:n}))}},Yf=class _u extends Ee{default(n){return new _u(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new _u(this.typeBuilder,g(this.columnMetadata,{name:n}))}},By=class Bh extends Ee{constructor(n,s){super(n,s)}default(n){return new Bh(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}},Zf=class Su extends Ee{default(n){return new Su(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new Su(this.typeBuilder,g(this.columnMetadata,{name:n}))}},xu=class Iu extends Ee{default(n){return new Iu(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new Iu(this.typeBuilder,g(this.columnMetadata,{name:n}))}},eh=class ku extends xu{index(n="btree"){return new ku(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}primaryKey(){return new ku(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}},th=class bu extends Ee{default(n){return new bu(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new bu(this.typeBuilder,g(this.columnMetadata,{name:n}))}},ai=class yi extends Ee{index(n="btree"){return new yi(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new yi(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new yi(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}default(n){return new yi(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new yi(this.typeBuilder,g(this.columnMetadata,{name:n}))}},li=class wi extends Ee{index(n="btree"){return new wi(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new wi(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new wi(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}default(n){return new wi(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new wi(this.typeBuilder,g(this.columnMetadata,{name:n}))}},ui=class vi extends Ee{index(n="btree"){return new vi(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new vi(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new vi(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}default(n){return new vi(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new vi(this.typeBuilder,g(this.columnMetadata,{name:n}))}},ci=class _i extends Ee{index(n="btree"){return new _i(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new _i(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new _i(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}default(n){return new _i(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new _i(this.typeBuilder,g(this.columnMetadata,{name:n}))}},di=class Si extends Ee{index(n="btree"){return new Si(this.typeBuilder,g(this.columnMetadata,{indexType:n}))}unique(){return new Si(this.typeBuilder,g(this.columnMetadata,{isUnique:!0}))}primaryKey(){return new Si(this.typeBuilder,g(this.columnMetadata,{isPrimaryKey:!0}))}default(n){return new Si(this.typeBuilder,g(this.columnMetadata,{defaultValue:n}))}name(n){return new Si(this.typeBuilder,g(this.columnMetadata,{name:n}))}},Ay=class extends Te{ref;__spacetimeType;constructor(r){super(oe.Ref(r)),this.ref=r}},My=((r,n)=>{let s=r,a;if(typeof r=="string"){if(!n)throw new TypeError("When providing a name, you must also provide the variants object or array.");s=n,a=r}if(Array.isArray(s)){const c={};for(const f of s)c[f]=new ju;return new Cy(c,a)}return new gu(s,a)}),d={bool:()=>new Iy,string:()=>new ky,number:()=>new Wf,i8:()=>new my,u8:()=>new cy,i16:()=>new yy,u16:()=>new dy,i32:()=>new wy,u32:()=>new fy,i64:()=>new vy,u64:()=>new hy,i128:()=>new _y,u128:()=>new py,i256:()=>new Sy,u256:()=>new gy,f32:()=>new xy,f64:()=>new Wf,object:((r,n)=>{if(typeof r=="string"){if(!n)throw new TypeError("When providing a name, you must also provide the object.");return new ki(n,r)}return new ki(r,void 0)}),row:((r,n)=>{const[s,a]=typeof r=="string"?[n,r]:[r,void 0];return new wn(s,a)}),array(r){return new hu(r)},enum:My,unit(){return new ju},lazy(r){let n=null;const s=()=>n??=r();return new Proxy({},{get(c,f,p){const v=s(),y=Reflect.get(v,f,p);return typeof y=="function"?y.bind(v):y},set(c,f,p,v){return Reflect.set(s(),f,p,v)},has(c,f){return f in s()},ownKeys(){return Reflect.ownKeys(s())},getOwnPropertyDescriptor(c,f){return Object.getOwnPropertyDescriptor(s(),f)},getPrototypeOf(){return Object.getPrototypeOf(s())}})},scheduleAt:()=>new Ty,option(r){return new ca(r)},result(r,n){return new pu(r,n)},identity:()=>new Ey,connectionId:()=>new Uy,timestamp:()=>new Ry,timeDuration:()=>new Ny,uuid:()=>new Py,byteArray:()=>new by},da=d.object("BsatnRowList",{get sizeHint(){return Jy},rowsData:d.byteArray()}),jy=d.object("CallProcedure",{requestId:d.u32(),flags:d.u8(),procedure:d.string(),args:d.byteArray()}),Oy=d.object("CallReducer",{requestId:d.u32(),flags:d.u8(),reducer:d.string(),args:d.byteArray()}),xs=d.enum("ClientMessage",{get Subscribe(){return Yy},get Unsubscribe(){return nw},get OneOffQuery(){return Fy},get CallReducer(){return Oy},get CallProcedure(){return jy}}),Dy=d.object("EventTableRows",{get events(){return da}}),zy=d.object("InitialConnection",{identity:d.identity(),connectionId:d.connectionId(),token:d.string()}),Fy=d.object("OneOffQuery",{requestId:d.u32(),queryString:d.string()}),$y=d.object("OneOffQueryResult",{requestId:d.u32(),get result(){return d.result(Ou,d.string())}}),Ly=d.object("PersistentTableRows",{get inserts(){return da},get deletes(){return da}}),Vy=d.object("ProcedureResult",{get status(){return qy},timestamp:d.timestamp(),totalHostExecutionDuration:d.timeDuration(),requestId:d.u32()}),qy=d.enum("ProcedureStatus",{Returned:d.byteArray(),InternalError:d.string()}),Ou=d.object("QueryRows",{get tables(){return d.array(Xy)}}),Ei=d.object("QuerySetId",{id:d.u32()}),Hy=d.object("QuerySetUpdate",{get querySetId(){return Ei},get tables(){return d.array(tw)}}),Ky=d.object("ReducerOk",{retValue:d.byteArray(),get transactionUpdate(){return Ah}}),Wy=d.enum("ReducerOutcome",{get Ok(){return Ky},OkEmpty:d.unit(),Err:d.byteArray(),InternalError:d.string()}),Qy=d.object("ReducerResult",{requestId:d.u32(),timestamp:d.timestamp(),get result(){return Wy}}),Jy=d.enum("RowSizeHint",{FixedSize:d.u16(),RowOffsets:d.array(d.u64())}),Gy=d.enum("ServerMessage",{get InitialConnection(){return zy},get SubscribeApplied(){return Zy},get UnsubscribeApplied(){return iw},get SubscriptionError(){return ew},get TransactionUpdate(){return Ah},get OneOffQueryResult(){return $y},get ReducerResult(){return Qy},get ProcedureResult(){return Vy}}),Xy=d.object("SingleTableRows",{table:d.string(),get rows(){return da}}),Yy=d.object("Subscribe",{requestId:d.u32(),get querySetId(){return Ei},queryStrings:d.array(d.string())}),Zy=d.object("SubscribeApplied",{requestId:d.u32(),get querySetId(){return Ei},get rows(){return Ou}}),ew=d.object("SubscriptionError",{requestId:d.option(d.u32()),get querySetId(){return Ei},error:d.string()}),tw=d.object("TableUpdate",{tableName:d.string(),get rows(){return d.array(rw)}}),rw=d.enum("TableUpdateRows",{get PersistentTable(){return Ly},get EventTable(){return Dy}}),Ah=d.object("TransactionUpdate",{get querySets(){return d.array(Hy)}}),nw=d.object("Unsubscribe",{requestId:d.u32(),get querySetId(){return Ei},get flags(){return Mh}}),iw=d.object("UnsubscribeApplied",{requestId:d.u32(),get querySetId(){return Ei},get rows(){return d.option(Ou)}}),Mh=d.enum("UnsubscribeFlags",{Default:d.unit(),SendDroppedRows:d.unit()}),Du=class{#e=new Map;on(r,n){let s=this.#e.get(r);s||(s=new Set,this.#e.set(r,s)),s.add(n)}off(r,n){const s=this.#e.get(r);s&&s.delete(n)}emit(r,...n){const s=this.#e.get(r);if(s)for(const a of s)a(...n)}},sw={component:"📦",info:"ℹ️",warn:"⚠️",error:"❌",debug:"🐛",trace:"🔍"},ow={component:"color: #fff; background-color: #8D6FDD; padding: 2px 5px; border-radius: 3px;",info:"color: #fff; background-color: #007bff; padding: 2px 5px; border-radius: 3px;",warn:"color: #fff; background-color: #ffc107; padding: 2px 5px; border-radius: 3px;",error:"color: #fff; background-color: #dc3545; padding: 2px 5px; border-radius: 3px;",debug:"color: #fff; background-color: #28a745; padding: 2px 5px; border-radius: 3px;",trace:"color: #fff; background-color: #17a2b8; padding: 2px 5px; border-radius: 3px;"},aw={component:"color: #8D6FDD;",info:"color: #007bff;",warn:"color: #ffc107;",error:"color: #dc3545;",debug:"color: #28a745;",trace:"color: #17a2b8;"},rh={error:0,warn:1,info:2,debug:3,trace:4},lw="info",uw=r=>rh[r]<=rh[lw],nh=r=>typeof r=="function"?r():r,ih=r=>Array.from(r).map(n=>n.toString(16).padStart(2,"0")).join(""),cw=25,dw=10,fw=new Set(["token","authToken","authorization","accessToken","refreshToken"]),au=r=>Lf(r,(n,s)=>{if(fw.has(n))return"[REDACTED]";if(s&&typeof s=="object"&&"__identity__"in s&&typeof s.__identity__=="bigint")return bh(s.__identity__);if(s&&typeof s=="object"&&"__connection_id__"in s&&typeof s.__connection_id__=="bigint")return Ih(s.__connection_id__);if(s instanceof Uint8Array){if(s.length<25)return`0x${ih(s)}`;const a=s.subarray(0,10);return`Uint8Array(len=${s.length}, head=0x${ih(a)})`}if(Array.isArray(s)&&s.length>=cw){const a=Lf(s.slice(0,dw));return`Array(len=${s.length}, head=${a??"[]"})`}return s}),et=(r,n,...s)=>{if(!uw(r))return;const a=nh(n),c=s.map(nh);console.log(`%c${sw[r]} ${r.toUpperCase()}%c ${a}`,ow[r],aw[r],...c)},sh=(r,n)=>r===n?0:rs.map(y=>v[y]),c=(v,y)=>{const x=a(v),R=Array.isArray(y)?y:[y],N=Math.max(0,R.length-1);for(let q=0;q0||$===0&&Q.tag==="excluded")return!1}return!0}else return!!Is(O,j)},f=r.constraints.some(v=>v.constraint!=="unique"?!1:Is(v.columns,n.columns)),p=this;return f?{find:y=>{const x=Array.isArray(y)?y:[y];for(const R of p.iter())if(Is(a(R),x))return R;return null}}:{*filter(y){for(const x of p.iter())c(x,y)&&(yield x)}}}count(){return BigInt(this.rows.size)}iter(){function*r(n){for(const[s]of n.values())yield s}return r(this.rows)}[Symbol.iterator](){return this.iter()}applyOperations=(r,n)=>{const s=[];if(this.tableDef.isEvent){for(const c of r)c.type==="insert"&&s.push({type:"insert",table:this.tableDef.sourceName,cb:()=>{this.emitter.emit("insert",n,c.row)}});return s}if(Object.values(this.tableDef.columns).some(c=>c.columnMetadata.isPrimaryKey===!0)){const c=new Map,f=new Map;for(const p of r)if(p.type==="insert"){const[v,y]=c.get(p.rowId)||[p,0];c.set(p.rowId,[p,y+1])}else{const[v,y]=f.get(p.rowId)||[p,0];f.set(p.rowId,[p,y+1])}for(const[p,[v,y]]of c){const x=f.get(p);if(x){const[R,N]=x,j=y-N,O=this.update(n,p,v.row,j);O&&s.push(O),f.delete(p)}else{const R=this.insert(n,v,y);R&&s.push(R)}}for(const[p,v]of f.values()){const y=this.delete(n,p,v);y&&s.push(y)}}else for(const c of r)if(c.type==="insert"){const f=this.insert(n,c);f&&s.push(f)}else{const f=this.delete(n,c);f&&s.push(f)}return s};update=(r,n,s,a=0)=>{const c=this.rows.get(n);if(!c){et("error",`Updating a row that was not present in the cache. Table: ${this.tableDef.sourceName}, RowId: ${n}`);return}const[f,p]=c,v=Math.max(1,p+a);if(p+a<=0){et("error",`Negative reference count for in table ${this.tableDef.sourceName} row ${n} (${p} + ${a})`);return}return this.rows.set(n,[s,v]),p===0?(et("error",`Updating a row id in table ${this.tableDef.sourceName} which was not present in the cache (rowId: ${n})`),{type:"insert",table:this.tableDef.sourceName,cb:()=>{this.emitter.emit("insert",r,s)}}):{type:"update",table:this.tableDef.sourceName,cb:()=>{this.emitter.emit("update",r,f,s)}}};insert=(r,n,s=1)=>{const[a,c]=this.rows.get(n.rowId)||[n.row,0];if(this.rows.set(n.rowId,[n.row,c+s]),c===0)return{type:"insert",table:this.tableDef.sourceName,cb:()=>{this.emitter.emit("insert",r,n.row)}}};delete=(r,n,s=1)=>{const[a,c]=this.rows.get(n.rowId)||[n.row,0];if(c===0){et("warn","Deleting a row that was not present in the cache");return}if(c<=s)return this.rows.delete(n.rowId),{type:"delete",table:this.tableDef.sourceName,cb:()=>{this.emitter.emit("delete",r,n.row)}};this.rows.set(n.rowId,[n.row,c-s])};onInsert=r=>{this.emitter.on("insert",r)};onDelete=r=>{this.emitter.on("delete",r)};onUpdate=r=>{this.emitter.on("update",r)};removeOnInsert=r=>{this.emitter.off("insert",r)};removeOnDelete=r=>{this.emitter.off("delete",r)};removeOnUpdate=r=>{this.emitter.off("update",r)}},pw=class{map=new Map;get(r){return this.map.get(r)}set(r,n){return this.map.set(r,n),this}has(r){return this.map.has(r)}delete(r){return this.map.delete(r)}keys(){return this.map.keys()}values(){return this.map.values()}entries(){return this.map.entries()}[Symbol.iterator](){return this.entries()}},gw=class{tables=new pw;getTable(r){const n=this.tables.get(r);if(!n)throw console.error("The table has not been registered for this client. Please register the table before using it. If you have registered global tables using the SpacetimeDBClient.registerTables() or `registerTable()` method, please make sure that is executed first!"),new Error(`Table ${String(r)} does not exist`);return n}getOrCreateTable(r){const n=r.accessorName,s=this.tables.get(n);if(s)return s;const a=new hw(r);return this.tables.set(n,a),a}};function mw(r,n){const s=Math.min(r.length,n.length);for(let a=0;aisNaN(Number(x))?x:Number(x)):null,y=a[5]||null;return new Cu(c,f,p,v,y)}},Oh=new jh(1,4,0);function yw(r){if(r===void 0)throw new Error(oh(r));if(jh.parseVersionString(r).compare(Oh)<0)throw new Error(oh(r))}function oh(r){return`Module code was generated with an incompatible version of the spacetimedb cli (${r}). Update the cli version to at least ${Oh.toString()} and regenerate the bindings. You can upgrade to the latest cli version by running: spacetime version upgrade`}async function ww(r,n,s=128*1024){let a=0;const c=new ReadableStream({pull(O){if(a{const a=await this.#t(new Uint8Array(s.data));n({data:a})}}set onerror(n){this.#e.onerror=n}#e;async#t(n){const s=n[0],a=n.subarray(1);switch(s){case 0:return a;case 1:throw new Error("Brotli Compression not supported. Please use gzip or none compression in withCompression method on DbConnection.");case 2:return await ww(a,"gzip");default:throw new Error("Unexpected Compression Algorithm. Please use `gzip` or `none`")}}send(n){this.#e.send(n)}close(){this.#e.close()}constructor(n){n.binaryType="arraybuffer",this.#e=n}static async createWebSocketFn({url:n,nameOrAddress:s,wsProtocol:a,authToken:c,compression:f,lightMode:p,confirmedReads:v}){const y=new Headers,x=await vw();let R;if(c){y.set("Authorization",`Bearer ${c}`);const O=new URL("v1/identity/websocket-token",n);O.protocol=n.protocol==="wss:"?"https:":"http:";const q=await fetch(O,{method:"POST",headers:y});if(q.ok){const{token:Q}=await q.json();R=Q}else return Promise.reject(new Error(`Failed to verify token: ${q.statusText}`))}const N=new URL(`v1/database/${s}/subscribe`,n);R&&N.searchParams.set("token",R),N.searchParams.set("compression",f==="gzip"?"Gzip":"None"),p&&N.searchParams.set("light","true"),v!==void 0&&N.searchParams.set("confirmed",v.toString());const j=new x(N.toString(),a);return new Dh(j)}},Sw=class{constructor(n,s){this.remoteModule=n,this.dbConnectionCtor=s,this.#o=_w.createWebSocketFn}#e;#t;#n;#r;#i=new Du;#a="gzip";#s=!1;#l;#o;withUri(n){return this.#e=new URL(n),this}withDatabaseName(n){return this.#t=n,this}withToken(n){return this.#r=n,this}withWSFn(n){return this.#o=n,this}withCompression(n){return this.#a=n,this}withLightMode(n){return this.#s=n,this}withConfirmedReads(n){return this.#l=n,this}onConnect(n){return this.#i.on("connect",n),this}onConnectError(n){return this.#i.on("connectError",n),this}onDisconnect(n){return this.#i.on("disconnect",n),this}getUri(){return this.#e?.toString()??""}getModuleName(){return this.#t??""}build(){if(!this.#e)throw new Error("URI is required to connect to SpacetimeDB");if(!this.#t)throw new Error("Database name or address is required to connect to SpacetimeDB");return yw(this.remoteModule.versionInfo?.cliVersion),this.dbConnectionCtor({uri:this.#e,nameOrAddress:this.#t,identity:this.#n,token:this.#r,emitter:this.#i,compression:this.#a,lightMode:this.#s,confirmedReads:this.#l,createWSFn:this.#o,remoteModule:this.remoteModule})}},zh=Symbol("INTERNAL_REMOTE_MODULE"),Fh=class{constructor(r){this.db=r}#e=void 0;#t=void 0;onApplied(r){return this.#e=r,this}onError(r){return this.#t=r,this}subscribe(r){let n;if(typeof r=="function"){const a=this.db.getTablesMap?.(),c=r(a);n=Array.isArray(c)?c:[c]}else n=Array.isArray(r)?r:[r];if(n.length===0)throw new Error("Subscriptions must have at least one query");const s=n.map(a=>{if(typeof a=="string")return a;if(Zm(a))return ey(a);throw new Error("Subscriptions must be SQL strings or typed queries")});return new Iw(this.db,s,this.#e,this.#t)}subscribeToAllTables(){const r=this.db[zh](),n=Object.values(r.tables).map(s=>`SELECT * FROM ${s.sourceName}`);this.subscribe(n)}},xw=class{subscriptions=new Map},Iw=class{constructor(r,n,s,a){this.db=r,this.#i.on("applied",c=>{this.#r=!0,s&&s(c)}),this.#i.on("error",(c,f)=>{this.#r=!1,this.#n=!0,a&&a(c,f)}),this.#e=this.db.registerSubscription(this,this.#i,n)}#e;#t=!1;#n=!1;#r=!1;#i=new Du;unsubscribe(){if(this.#t)throw new Error("Unsubscribe has already been called");this.#t=!0,this.db.unregisterSubscription(this.#e),this.#i.on("end",r=>{this.#n=!0,this.#r=!1})}unsubscribeThen(r){if(this.#n)throw new Error("Subscription has already ended");if(this.#t)throw new Error("Unsubscribe has already been called");this.#t=!0,this.db.unregisterSubscription(this.#e),this.#i.on("end",n=>{this.#n=!0,this.#r=!1,r(n)})}isEnded(){return this.#n}isActive(){return this.#r}},kw=class{isActive=!1;identity=void 0;token=void 0;[zh](){return this.#l}db;reducers;procedures;connectionId=ga.random();#e=0;#t=0;#n=0;#r;#i=Promise.resolve();#a=[];#s=new xw;#l;#o=new Map;#y=new Map;#w=new Map;#v;#f;#h;#u;clientCache;ws;wsPromise;constructor({uri:r,nameOrAddress:n,identity:s,token:a,emitter:c,remoteModule:f,createWSFn:p,compression:v,lightMode:y,confirmedReads:x}){et("info","Connecting to SpacetimeDB WS...");const R=new URL(r.toString());/^wss?:/.test(r.protocol)||(R.protocol=R.protocol==="https:"?"wss:":"ws:"),this.identity=s,this.token=a,this.#l=f,this.#r=c,this.#v=Object.create(null),this.#u=Object.create(null);for(const j of Object.values(f.tables))this.#v[j.sourceName]=pr.makeDeserializer(j.rowType),this.#u[j.sourceName]=j;this.#f=Object.create(null);for(const j of f.reducers)this.#f[j.name]={serialize:pr.makeSerializer(j.paramsType),deserialize:pr.makeDeserializer(j.paramsType)};this.#h=Object.create(null);for(const j of f.procedures)this.#h[j.name]={serializeArgs:pr.makeSerializer(new ki(j.params).algebraicType.value),deserializeReturn:oe.makeDeserializer(j.returnType.algebraicType)};const N=this.connectionId.toHexString();R.searchParams.set("connection_id",N),this.clientCache=new gw,this.db=this.#C(),this.reducers=this.#T(f),this.procedures=this.#E(f),this.wsPromise=p({url:R,nameOrAddress:n,wsProtocol:"v2.bsatn.spacetimedb",authToken:a,compression:v,lightMode:y,confirmedReads:x}).then(j=>(this.ws=j,this.ws.onclose=()=>{this.#r.emit("disconnect",this),this.isActive=!1},this.ws.onerror=O=>{this.#r.emit("connectError",this,O),this.isActive=!1},this.ws.onopen=this.#P.bind(this),this.ws.onmessage=this.#A.bind(this),j)).catch(j=>{et("error","Error connecting to SpacetimeDB WS"),this.#r.emit("connectError",this,j)})}#b=()=>{const r=this.#e;return this.#e+=1,r};#p=()=>this.#t++;#C(){const r=Object.create(null);for(const n of Object.values(this.#u)){const s=n.accessorName;Object.defineProperty(r,s,{enumerable:!0,configurable:!1,get:()=>this.clientCache.getOrCreateTable(n)})}return r}#T(r){const n={},s=new Pe(1024);for(const a of r.reducers){const c=a.name,f=a.accessorName,{serialize:p}=this.#f[c];n[f]=v=>{s.clear(),p(s,v);const y=s.getBuffer();return this.callReducer(c,y,v)}}return n}#E(r){const n={},s=new Pe(1024);for(const a of r.procedures){const c=a.name,f=a.accessorName,{serializeArgs:p,deserializeReturn:v}=this.#h[c];n[f]=y=>{s.clear(),p(s,y);const x=s.getBuffer();return this.callProcedure(c,x).then(R=>v(new ze(R)))}}return n}#c(r){return{db:this.db,reducers:this.reducers,isActive:this.isActive,subscriptionBuilder:this.subscriptionBuilder.bind(this),disconnect:this.disconnect.bind(this),event:r}}subscriptionBuilder=()=>new Fh(this);getTablesMap(){return Nh({tables:this.#l.tables})}registerSubscription(r,n,s){const a=this.#b();this.#s.subscriptions.set(a,{handle:r,emitter:n});const c=this.#p();return this.#m(xs.Subscribe({queryStrings:s,querySetId:{id:a},requestId:c})),a}unregisterSubscription(r){const n=this.#p();this.#m(xs.Unsubscribe({querySetId:{id:r},requestId:n,flags:Mh.SendDroppedRows}))}#g(r,n,s){const a=s.rowsData,c=new ze(a),f=[],p=this.#v[n],v=this.#u[n],x=Object.entries(v.columns).find(N=>N[1].columnMetadata.isPrimaryKey);let R=0;for(;c.remaining>0;){const N=p(c);let j;if(x!==void 0){const O=x[0],q=x[1].typeBuilder.algebraicType;j=oe.intoMapKey(q,N[O])}else{const O=a.subarray(R,c.offset);j=Mu.fromByteArray(O)}R=c.offset,f.push({type:r,rowId:j,row:N})}return f}#_(r){const n=new Map;for(const s of r){const a=n.get(s.tableName);if(a)for(const c of s.operations)a.push(c);else n.set(s.tableName,s.operations.slice())}return Array.from(n,([s,a])=>({tableName:s,operations:a}))}#x(r,n){const s=[];for(const a of r.tables)s.push({tableName:a.table,operations:this.#g(n,a.table,a.rows)});return this.#_(s)}#U(r,n){if(n.tag==="PersistentTable"){const s=this.#g("insert",r,n.value.inserts),a=this.#g("delete",r,n.value.deletes);return s.concat(a)}return n.tag==="EventTable"?this.#g("insert",r,n.value.events):[]}#R(r){const n=[];for(const s of r.tables){let a=[];for(const c of s.rows)a=a.concat(this.#U(s.tableName,c));n.push({tableName:s.tableName,operations:a})}return this.#_(n)}#I(r){const n=this.#a.splice(0);for(const s of n)r.send(s)}#N=new Pe(1024);#m(r){const n=this.#N;n.clear(),xs.serialize(n,r);const s=n.getBuffer();this.ws&&this.isActive?(this.#a.length&&this.#I(this.ws),et("trace",()=>`Sending message to server: ${au(r)}`),this.ws.send(s)):(et("trace",()=>`Queuing message to server: ${au(r)}`),this.#a.push(s.slice()))}#d(){return this.#n+=1,`${this.connectionId.toHexString()}:${this.#n}`}#P(){this.isActive=!0,this.ws&&this.#I(this.ws)}#S(r,n){const s=[];for(const a of r){const c=a.tableName,f=this.#u[c],v=this.clientCache.getOrCreateTable(f).applyOperations(a.operations,n);for(const y of v)s.push(y)}return s}#k(r,n){const s=[];for(const a of n.querySets){const c=this.#R(a);for(const f of c)s.push(f)}return this.#S(this.#_(s),r)}async#B(r){const n=Gy.deserialize(new ze(r));switch(et("trace",()=>`Processing server message: ${au(n)}`),n.tag){case"InitialConnection":{this.identity=n.value.identity,!this.token&&n.value.token&&(this.token=n.value.token),this.connectionId=n.value.connectionId,this.#r.emit("connect",this,this.identity,this.token);break}case"SubscribeApplied":{const s=n.value.querySetId.id,a=this.#s.subscriptions.get(s);if(!a){et("error",`Received SubscribeApplied for unknown querySetId ${s}.`);return}const c={id:this.#d(),tag:"SubscribeApplied"},f=this.#c(c),p=this.#x(n.value.rows,"insert"),v=this.#S(p,f),{event:y,...x}=f;a.emitter.emit("applied",x),et("trace",()=>`Calling ${v.length} triggered row callbacks`);for(const R of v)R.cb();break}case"UnsubscribeApplied":{const s=n.value.querySetId.id,a=this.#s.subscriptions.get(s);if(!a){et("error",`Received UnsubscribeApplied for unknown querySetId ${s}.`);return}const c={id:this.#d(),tag:"UnsubscribeApplied"},f=this.#c(c),p=n.value.rows?this.#x(n.value.rows,"delete"):[],v=this.#S(p,f),{event:y,...x}=f;a.emitter.emit("end",x),this.#s.subscriptions.delete(s),et("trace",()=>`Calling ${v.length} triggered row callbacks`);for(const R of v)R.cb();break}case"SubscriptionError":{const s=n.value.querySetId.id,a=n.value.requestId,c=Error(n.value.error),f={id:this.#d(),tag:"Error",value:c},v={...this.#c(f),event:c};if(a==null){et("error",`Disconnecting due to error for a previously applied subscription: ${n.value.error}`),this.disconnect();break}const y=this.#s.subscriptions.get(s);y?(y.emitter.emit("error",v,c),this.#s.subscriptions.delete(s)):et("error",`Received SubscriptionError for unknown querySetId ${s}:`,c);break}case"TransactionUpdate":{const s={id:this.#d(),tag:"Transaction"},a=this.#c(s),c=this.#k(a,n.value);et("trace",()=>`Calling ${c.length} triggered row callbacks`);for(const f of c)f.cb();break}case"ReducerResult":{const{requestId:s,result:a}=n.value;if(a.tag==="Ok"){const f=this.#y.get(s),p=this.#d(),v=f?{id:p,tag:"Reducer",value:{timestamp:n.value.timestamp,outcome:a,reducer:{name:f.name,args:f.args}}}:{id:p,tag:"Transaction"},y=this.#c(v),x=this.#k(y,a.value.transactionUpdate);et("trace",()=>`Calling ${x.length} triggered row callbacks`);for(const R of x)R.cb()}this.#y.delete(s);const c=this.#o.get(s);this.#o.delete(s),c?.(a);break}case"ProcedureResult":{const{status:s,requestId:a}=n.value,c=s.tag==="Returned"?{tag:"Ok",value:s.value}:{tag:"Err",value:s.value},f=this.#w.get(a);this.#w.delete(a),f?.(c);break}case"OneOffQueryResult":{et("warn","Received OneOffQueryResult but SDK does not expose one-off query APIs yet.");break}}}#A(r){this.#i=this.#i.then(()=>this.#B(r.data))}callReducer(r,n,s){const{promise:a,resolve:c,reject:f}=Promise.withResolvers(),p=this.#p(),v=xs.CallReducer({reducer:r,args:n,requestId:p,flags:0});return this.#m(v),s&&this.#y.set(p,{name:r,args:s}),this.#o.set(p,y=>{if(y.tag==="Ok"||y.tag==="OkEmpty")c();else if(y.tag==="Err"){const R=new ze(y.value).readString();f(new Km(R))}else y.tag==="InternalError"?f(new Wm(y.value)):f(new Error("Unexpected reducer result"))}),a}callReducerWithParams(r,n,s){const a=new Pe(1024);this.#f[r].serialize(a,s);const c=a.getBuffer();return this.callReducer(r,c,s)}callProcedure(r,n){const{promise:s,resolve:a,reject:c}=Promise.withResolvers(),f=this.#p(),p=xs.CallProcedure({procedure:r,args:n,requestId:f,flags:0});return this.#m(p),this.#w.set(f,v=>{v.tag==="Ok"?a(v.value):c(v.value)}),s}callProcedureWithParams(r,n,s,a){const c=new Pe(1024),{serializeArgs:f,deserializeReturn:p}=this.#h[r];f(c,s);const v=c.getBuffer();return this.callProcedure(r,v).then(y=>p(new ze(y)))}disconnect(){this.wsPromise.then(r=>r?.close())}on(r,n){this.#r.on(r,n)}off(r,n){this.#r.off(r,n)}onConnect(r){this.#r.on("connect",r)}onDisconnect(r){this.#r.on("disconnect",r)}onConnectError(r){this.#r.on("connectError",r)}removeOnConnect(r){this.#r.off("connect",r)}removeOnDisconnect(r){this.#r.off("disconnect",r)}removeOnConnectError(r){this.#r.off("connectError",r)}};function bw(r,n){const s=Object.create(null);for(const[a,c]of Object.entries(n))s[a]=Cw(a,c,c.tableDef(r,a));return{tables:s}}function Cw(r,n,s){const a=f=>n.rowType.algebraicType.value.elements[f].name,c=s.indexes.map(f=>{const p=f.accessorName;if(typeof p!="string"||p.length===0)throw new TypeError(`Index '${f.sourceName??""}' on table '${s.sourceName}' is missing accessor name`);const v=f.algorithm.tag==="Direct"?[f.algorithm.value]:f.algorithm.value,y=s.constraints.some(R=>R.data.tag==="Unique"&&R.data.value.columns.every(N=>v.includes(N))),x={BTree:"btree",Hash:"hash",Direct:"direct"}[f.algorithm.tag];return{name:p,unique:y,algorithm:x,columns:v.map(a)}});return{sourceName:n.tableName||r,accessorName:r,columns:n.rowType.row,rowType:n.rowSpacetimeType,indexes:n.idxs,constraints:s.constraints.map(f=>({name:f.sourceName,constraint:"unique",columns:f.data.value.columns.map(a)})),resolvedIndexes:c,tableDef:s,...s.isEvent?{isEvent:!0}:{}}}var Tw=class{#e=new Map;#t={typespace:{types:[]},tables:[],reducers:[],types:[],rowLevelSecurity:[],schedules:[],procedures:[],views:[],lifeCycleReducers:[],caseConversionPolicy:{tag:"SnakeCase"},explicitNames:{entries:[]}};get moduleDef(){return this.#t}rawModuleDefV10(){const r=[],n=a=>{a&&r.push(a)},s=this.#t;return n(s.typespace&&{tag:"Typespace",value:s.typespace}),n(s.types&&{tag:"Types",value:s.types}),n(s.tables&&{tag:"Tables",value:s.tables}),n(s.reducers&&{tag:"Reducers",value:s.reducers}),n(s.procedures&&{tag:"Procedures",value:s.procedures}),n(s.views&&{tag:"Views",value:s.views}),n(s.schedules&&{tag:"Schedules",value:s.schedules}),n(s.lifeCycleReducers&&{tag:"LifeCycleReducers",value:s.lifeCycleReducers}),n(s.rowLevelSecurity&&{tag:"RowLevelSecurity",value:s.rowLevelSecurity}),n(s.explicitNames&&{tag:"ExplicitNames",value:s.explicitNames}),n(s.caseConversionPolicy&&{tag:"CaseConversionPolicy",value:s.caseConversionPolicy}),{sections:r}}setCaseConversionPolicy(r){this.#t.caseConversionPolicy=r}get typespace(){return this.#t.typespace}resolveType(r){let n=r.algebraicType;for(;n.tag==="Ref";)n=this.typespace.types[n.value];return n}registerTypesRecursively(r){return r instanceof ki&&!Ew(r)||r instanceof gu||r instanceof wn?this.#n(r):r instanceof ca?new ca(this.registerTypesRecursively(r.value)):r instanceof pu?new pu(this.registerTypesRecursively(r.ok),this.registerTypesRecursively(r.err)):r instanceof hu?new hu(this.registerTypesRecursively(r.element)):r}#n(r){const n=r.algebraicType,s=r.typeName;if(s===void 0)throw new Error(`Missing type name for ${r.constructor.name??"TypeBuilder"} ${JSON.stringify(r)}`);let a=this.#e.get(n);if(a!=null)return a;const c=r instanceof wn||r instanceof ki?{tag:"Product",value:{elements:[]}}:{tag:"Sum",value:{variants:[]}};if(a=new Ay(this.#t.typespace.types.length),this.#t.typespace.types.push(c),this.#e.set(n,a),r instanceof wn)for(const[f,p]of Object.entries(r.row))c.value.elements.push({name:f,algebraicType:this.registerTypesRecursively(p.typeBuilder).algebraicType});else if(r instanceof ki)for(const[f,p]of Object.entries(r.elements))c.value.elements.push({name:f,algebraicType:this.registerTypesRecursively(p).algebraicType});else if(r instanceof gu)for(const[f,p]of Object.entries(r.variants))c.value.variants.push({name:f,algebraicType:this.registerTypesRecursively(p).algebraicType});return this.#t.types.push({sourceName:Uw(s),ty:a.ref,customOrdering:!0}),a}};function Ew(r){return r.typeName==null&&r.algebraicType.value.elements.length===0}function Uw(r){const n=r.split(".");return{sourceName:n.pop(),scope:n}}var Rw=class{constructor(r){this.schemaType=r}};function Nw(r){const n=new Tw;return new Rw(bw(n,r))}function Pw(r){return Object.fromEntries(r.map(n=>[n.accessorName,n]))}var Wt=d.enum("AlgebraicType",{Ref:d.u32(),get Sum(){return _v},get Product(){return _n},get Array(){return Wt},String:d.unit(),Bool:d.unit(),I8:d.unit(),U8:d.unit(),I16:d.unit(),U16:d.unit(),I32:d.unit(),U32:d.unit(),I64:d.unit(),U64:d.unit(),I128:d.unit(),U128:d.unit(),I256:d.unit(),U256:d.unit(),F32:d.unit(),F64:d.unit()}),Bw=d.enum("CaseConversionPolicy",{None:d.unit(),SnakeCase:d.unit()}),$h=d.enum("ExplicitNameEntry",{get Table(){return lu},get Function(){return lu},get Index(){return lu}}),Aw=d.object("ExplicitNames",{get entries(){return d.array($h)}}),Lh=d.enum("FunctionVisibility",{Private:d.unit(),ClientCallable:d.unit()}),Mw=d.object("HttpHeaderPair",{name:d.string(),value:d.byteArray()}),Vh=d.object("HttpHeaders",{get entries(){return d.array(Mw)}}),jw=d.enum("HttpMethod",{Get:d.unit(),Head:d.unit(),Post:d.unit(),Put:d.unit(),Delete:d.unit(),Connect:d.unit(),Options:d.unit(),Trace:d.unit(),Patch:d.unit(),Extension:d.string()});d.object("HttpRequest",{get method(){return jw},get headers(){return Vh},timeout:d.option(d.timeDuration()),uri:d.string(),get version(){return qh}});d.object("HttpResponse",{get headers(){return Vh},get version(){return qh},code:d.u16()});var qh=d.enum("HttpVersion",{Http09:d.unit(),Http10:d.unit(),Http11:d.unit(),Http2:d.unit(),Http3:d.unit()}),Ow=d.enum("IndexType",{BTree:d.unit(),Hash:d.unit()}),Hh=d.enum("Lifecycle",{Init:d.unit(),OnConnect:d.unit(),OnDisconnect:d.unit()}),Dw=d.enum("MiscModuleExport",{get TypeAlias(){return Iv}}),lu=d.object("NameMapping",{sourceName:d.string(),canonicalName:d.string()}),_n=d.object("ProductType",{get elements(){return d.array(Kh)}}),Kh=d.object("ProductTypeElement",{name:d.option(d.string()),get algebraicType(){return Wt}}),zw=d.object("RawColumnDefV8",{colName:d.string(),get colType(){return Wt}}),Fw=d.object("RawColumnDefaultValueV10",{colId:d.u16(),value:d.byteArray()}),$w=d.object("RawColumnDefaultValueV9",{table:d.string(),colId:d.u16(),value:d.byteArray()}),Wh=d.enum("RawConstraintDataV9",{get Unique(){return mv}}),Lw=d.object("RawConstraintDefV10",{sourceName:d.option(d.string()),get data(){return Wh}}),Vw=d.object("RawConstraintDefV8",{constraintName:d.string(),constraints:d.u8(),columns:d.array(d.u16())}),qw=d.object("RawConstraintDefV9",{name:d.option(d.string()),get data(){return Wh}}),Es=d.enum("RawIndexAlgorithm",{BTree:d.array(d.u16()),Hash:d.array(d.u16()),Direct:d.u16()}),Hw=d.object("RawIndexDefV10",{sourceName:d.option(d.string()),accessorName:d.option(d.string()),get algorithm(){return Es}}),Kw=d.object("RawIndexDefV8",{indexName:d.string(),isUnique:d.bool(),get indexType(){return Ow},columns:d.array(d.u16())}),Ww=d.object("RawIndexDefV9",{name:d.option(d.string()),accessorName:d.option(d.string()),get algorithm(){return Es}}),Qw=d.object("RawLifeCycleReducerDefV10",{get lifecycleSpec(){return Hh},functionName:d.string()}),Jw=d.enum("RawMiscModuleExportV9",{get ColumnDefaultValue(){return $w},get Procedure(){return tv},get View(){return wv}});d.enum("RawModuleDef",{get V8BackCompat(){return Yw},get V9(){return Zw},get V10(){return Gw}});var Gw=d.object("RawModuleDefV10",{get sections(){return d.array(Xw)}}),Xw=d.enum("RawModuleDefV10Section",{get Typespace(){return zu},get Types(){return d.array(pv)},get Tables(){return d.array(dv)},get Reducers(){return d.array(rv)},get Procedures(){return d.array(ev)},get Views(){return d.array(yv)},get Schedules(){return d.array(iv)},get LifeCycleReducers(){return d.array(Qw)},get RowLevelSecurity(){return d.array(Qh)},get CaseConversionPolicy(){return Bw},get ExplicitNames(){return Aw}}),Yw=d.object("RawModuleDefV8",{get typespace(){return zu},get tables(){return d.array(xv)},get reducers(){return d.array(vv)},get miscExports(){return d.array(Dw)}}),Zw=d.object("RawModuleDefV9",{get typespace(){return zu},get tables(){return d.array(hv)},get reducers(){return d.array(nv)},get types(){return d.array(gv)},get miscExports(){return d.array(Jw)},get rowLevelSecurity(){return d.array(Qh)}}),ev=d.object("RawProcedureDefV10",{sourceName:d.string(),get params(){return _n},get returnType(){return Wt},get visibility(){return Lh}}),tv=d.object("RawProcedureDefV9",{name:d.string(),get params(){return _n},get returnType(){return Wt}}),rv=d.object("RawReducerDefV10",{sourceName:d.string(),get params(){return _n},get visibility(){return Lh},get okReturnType(){return Wt},get errReturnType(){return Wt}}),nv=d.object("RawReducerDefV9",{name:d.string(),get params(){return _n},get lifecycle(){return d.option(Hh)}}),Qh=d.object("RawRowLevelSecurityDefV9",{sql:d.string()}),iv=d.object("RawScheduleDefV10",{sourceName:d.option(d.string()),tableName:d.string(),scheduleAtCol:d.u16(),functionName:d.string()}),sv=d.object("RawScheduleDefV9",{name:d.option(d.string()),reducerName:d.string(),scheduledAtColumn:d.u16()}),ov=d.object("RawScopedTypeNameV10",{scope:d.array(d.string()),sourceName:d.string()}),av=d.object("RawScopedTypeNameV9",{scope:d.array(d.string()),name:d.string()}),lv=d.object("RawSequenceDefV10",{sourceName:d.option(d.string()),column:d.u16(),start:d.option(d.i128()),minValue:d.option(d.i128()),maxValue:d.option(d.i128()),increment:d.i128()}),uv=d.object("RawSequenceDefV8",{sequenceName:d.string(),colPos:d.u16(),increment:d.i128(),start:d.option(d.i128()),minValue:d.option(d.i128()),maxValue:d.option(d.i128()),allocated:d.i128()}),cv=d.object("RawSequenceDefV9",{name:d.option(d.string()),column:d.u16(),start:d.option(d.i128()),minValue:d.option(d.i128()),maxValue:d.option(d.i128()),increment:d.i128()}),dv=d.object("RawTableDefV10",{sourceName:d.string(),productTypeRef:d.u32(),primaryKey:d.array(d.u16()),get indexes(){return d.array(Hw)},get constraints(){return d.array(Lw)},get sequences(){return d.array(lv)},get tableType(){return Gh},get tableAccess(){return Jh},get defaultValues(){return d.array(Fw)},isEvent:d.bool()}),fv=d.object("RawTableDefV8",{tableName:d.string(),get columns(){return d.array(zw)},get indexes(){return d.array(Kw)},get constraints(){return d.array(Vw)},get sequences(){return d.array(uv)},tableType:d.string(),tableAccess:d.string(),scheduled:d.option(d.string())}),hv=d.object("RawTableDefV9",{name:d.string(),productTypeRef:d.u32(),primaryKey:d.array(d.u16()),get indexes(){return d.array(Ww)},get constraints(){return d.array(qw)},get sequences(){return d.array(cv)},get schedule(){return d.option(sv)},get tableType(){return Gh},get tableAccess(){return Jh}}),pv=d.object("RawTypeDefV10",{get sourceName(){return ov},ty:d.u32(),customOrdering:d.bool()}),gv=d.object("RawTypeDefV9",{get name(){return av},ty:d.u32(),customOrdering:d.bool()}),mv=d.object("RawUniqueConstraintDataV9",{columns:d.array(d.u16())}),yv=d.object("RawViewDefV10",{sourceName:d.string(),index:d.u32(),isPublic:d.bool(),isAnonymous:d.bool(),get params(){return _n},get returnType(){return Wt}}),wv=d.object("RawViewDefV9",{name:d.string(),index:d.u32(),isPublic:d.bool(),isAnonymous:d.bool(),get params(){return _n},get returnType(){return Wt}}),vv=d.object("ReducerDef",{name:d.string(),get args(){return d.array(Kh)}}),_v=d.object("SumType",{get variants(){return d.array(Sv)}}),Sv=d.object("SumTypeVariant",{name:d.option(d.string()),get algebraicType(){return Wt}}),Jh=d.enum("TableAccess",{Public:d.unit(),Private:d.unit()}),xv=d.object("TableDesc",{get schema(){return fv},data:d.u32()}),Gh=d.enum("TableType",{System:d.unit(),User:d.unit()}),Iv=d.object("TypeAlias",{name:d.string(),ty:d.u32()}),zu=d.object("Typespace",{get types(){return d.array(Wt)}});d.enum("ViewResultHeader",{RowData:d.unit(),RawSql:d.string()});function dr(r,n,...s){const{name:a,public:c=!1,indexes:f=[],scheduled:p,event:v=!1}=r,y=new Map,x=[];n instanceof wn||(n=new wn(n)),n.algebraicType.value.elements.forEach((T,A)=>{y.set(T.name,A),x.push(T.name)});const R=[],N=[],j=[],O=[];let q;const Q=[];for(const[T,A]of Object.entries(n.row)){const L=A.columnMetadata;L.isPrimaryKey&&R.push(y.get(T));const J=L.isUnique||L.isPrimaryKey;if(L.indexType||J){const Y=L.indexType??"btree",ge=y.get(T);let me;switch(Y){case"btree":me=Es.BTree([ge]);break;case"hash":me=Es.Hash([ge]);break;case"direct":me=Es.Direct(ge);break}N.push({sourceName:void 0,accessorName:T,algorithm:me})}if(J&&j.push({sourceName:void 0,data:{tag:"Unique",value:{columns:[y.get(T)]}}}),L.isAutoIncrement&&O.push({sourceName:void 0,start:void 0,minValue:void 0,maxValue:void 0,column:y.get(T),increment:1n}),L.defaultValue){const Y=new Pe(16);A.serialize(Y,L.defaultValue),Q.push({colId:y.get(T),value:Y.getBuffer()})}if(p){const Y=A.typeBuilder.algebraicType;Uh.isScheduleAt(Y)&&(q=y.get(T))}}for(const T of f??[]){const A=T.accessor;if(typeof A!="string"||A.length===0){const J=a??"",Y=T.name??"";throw new TypeError(`Index '${Y}' on table '${J}' must define a non-empty 'accessor'`)}let L;switch(T.algorithm){case"btree":L={tag:"BTree",value:T.columns.map(J=>y.get(J))};break;case"hash":L={tag:"Hash",value:T.columns.map(J=>y.get(J))};break;case"direct":L={tag:"Direct",value:y.get(T.column)};break}N.push({sourceName:void 0,accessorName:A,algorithm:L,canonicalName:T.name})}for(const T of r.constraints??[])if(T.constraint==="unique"){const A={tag:"Unique",value:{columns:T.columns.map(L=>y.get(L))}};j.push({sourceName:T.name,data:A});continue}const $=n.algebraicType.value;return{rowType:n,tableName:a,rowSpacetimeType:$,tableDef:(T,A)=>{const L=a??A;n.typeName===void 0&&(n.typeName=Fm(L));for(const J of N){const ge=(J.algorithm.tag==="Direct"?[J.algorithm.value]:J.algorithm.value).map(Re=>x[Re]).join("_"),me=J.sourceName=`${A}_${ge}_idx_${J.algorithm.tag.toLowerCase()}`,{canonicalName:ue}=J;ue!==void 0&&T.moduleDef.explicitNames.entries.push($h.Index({sourceName:me,canonicalName:ue}))}return{sourceName:A,productTypeRef:T.registerTypesRecursively(n).ref,primaryKey:R,indexes:N,constraints:j,sequences:O,tableType:{tag:"User"},tableAccess:{tag:c?"Public":"Private"},defaultValues:Q,isEvent:v}},idxs:f,constraints:j,schedule:p&&q!==void 0?{scheduleAtCol:q,reducer:p}:void 0}}var kv=class{reducersType;constructor(r){this.reducersType=bv(r)}};function bv(r){return{reducers:r.map(a=>{const c=a.params.row;return{name:a.reducerName,accessorName:a.accessorName,params:c,paramsType:a.paramsSpacetimeType}})}}function Cv(...r){const n=r.length===1&&Array.isArray(r[0])?r[0]:r;return new kv(n)}function jt(r,n){const s={elements:Object.entries(n).map(([a,c])=>({name:a,algebraicType:"typeBuilder"in c?c.typeBuilder.algebraicType:c.algebraicType}))};return{reducerName:r,accessorName:Ch(r),params:new wn(n),paramsSpacetimeType:s,reducerDef:{name:r,params:s,lifecycle:void 0}}}function Tv(...r){return{procedures:r.length===1&&Array.isArray(r[0])?r[0]:r}}const Ev={name:d.string(),serverId:d.u64(),isVoice:d.bool()},Uv={name:d.string()},Rv={name:d.string(),channelId:d.u64(),parentMessageId:d.u64()},Nv={channelId:d.u64()},Pv={},Bv={username:d.string(),password:d.string()},Av={username:d.string(),password:d.string()},Mv={receiver:d.identity(),candidate:d.string(),channelId:d.u64()},jv={text:d.string(),channelId:d.u64(),threadId:d.option(d.u64())},Ov={receiver:d.identity(),sdp:d.string(),channelId:d.u64()},Dv={receiver:d.identity(),sdp:d.string(),channelId:d.u64()},zv={name:d.string()};d.object("Channel",{id:d.u64(),serverId:d.u64(),name:d.string(),get kind(){return Xh}});const Xh=d.enum("ChannelKind",{Text:d.unit(),Voice:d.unit()});d.object("IceCandidate",{sender:d.identity(),receiver:d.identity(),candidate:d.string(),channelId:d.u64()});d.object("Message",{id:d.u64(),sender:d.identity(),sent:d.timestamp(),text:d.string(),channelId:d.u64(),threadId:d.option(d.u64())});d.object("SdpAnswer",{sender:d.identity(),receiver:d.identity(),sdp:d.string(),channelId:d.u64()});d.object("SdpOffer",{sender:d.identity(),receiver:d.identity(),sdp:d.string(),channelId:d.u64()});d.object("Server",{id:d.u64(),name:d.string(),owner:d.option(d.identity())});d.object("Thread",{id:d.u64(),channelId:d.u64(),parentMessageId:d.u64(),name:d.string()});d.object("User",{identity:d.identity(),name:d.option(d.string()),online:d.bool(),issuer:d.option(d.string()),subject:d.option(d.string()),username:d.option(d.string()),password:d.option(d.string())});d.object("VoiceState",{identity:d.identity(),channelId:d.u64()});const Fv=d.row({id:d.u64().primaryKey(),serverId:d.u64().name("server_id"),name:d.string(),get kind(){return Xh}}),$v=d.row({sender:d.identity(),receiver:d.identity(),candidate:d.string(),channelId:d.u64().name("channel_id")}),Lv=d.row({id:d.u64().primaryKey(),sender:d.identity(),sent:d.timestamp(),text:d.string(),channelId:d.u64().name("channel_id"),threadId:d.option(d.u64()).name("thread_id")}),Vv=d.row({sender:d.identity(),receiver:d.identity(),sdp:d.string(),channelId:d.u64().name("channel_id")}),qv=d.row({sender:d.identity(),receiver:d.identity(),sdp:d.string(),channelId:d.u64().name("channel_id")}),Hv=d.row({id:d.u64().primaryKey(),name:d.string(),owner:d.option(d.identity())}),Kv=d.row({id:d.u64().primaryKey(),channelId:d.u64().name("channel_id"),parentMessageId:d.u64().name("parent_message_id"),name:d.string()}),Wv=d.row({identity:d.identity().primaryKey(),name:d.option(d.string()),online:d.bool(),issuer:d.option(d.string()),subject:d.option(d.string()),username:d.option(d.string()),password:d.option(d.string())}),Qv=d.row({identity:d.identity().primaryKey(),channelId:d.u64().name("channel_id")}),Yh=Nw({channel:dr({name:"channel",indexes:[{accessor:"id",name:"channel_id_idx_btree",algorithm:"btree",columns:["id"]},{accessor:"by_server_id",name:"channel_server_id_idx_btree",algorithm:"btree",columns:["serverId"]}],constraints:[{name:"channel_id_key",constraint:"unique",columns:["id"]}]},Fv),ice_candidate:dr({name:"ice_candidate",indexes:[{accessor:"by_receiver",name:"ice_candidate_receiver_idx_btree",algorithm:"btree",columns:["receiver"]}],constraints:[]},$v),message:dr({name:"message",indexes:[{accessor:"by_channel_id",name:"message_channel_id_idx_btree",algorithm:"btree",columns:["channelId"]},{accessor:"id",name:"message_id_idx_btree",algorithm:"btree",columns:["id"]},{accessor:"by_thread_id",name:"message_thread_id_idx_btree",algorithm:"btree",columns:["threadId"]}],constraints:[{name:"message_id_key",constraint:"unique",columns:["id"]}]},Lv),sdp_answer:dr({name:"sdp_answer",indexes:[{accessor:"by_receiver",name:"sdp_answer_receiver_idx_btree",algorithm:"btree",columns:["receiver"]}],constraints:[]},Vv),sdp_offer:dr({name:"sdp_offer",indexes:[{accessor:"by_receiver",name:"sdp_offer_receiver_idx_btree",algorithm:"btree",columns:["receiver"]}],constraints:[]},qv),server:dr({name:"server",indexes:[{accessor:"id",name:"server_id_idx_btree",algorithm:"btree",columns:["id"]}],constraints:[{name:"server_id_key",constraint:"unique",columns:["id"]}]},Hv),thread:dr({name:"thread",indexes:[{accessor:"by_channel_id",name:"thread_channel_id_idx_btree",algorithm:"btree",columns:["channelId"]},{accessor:"id",name:"thread_id_idx_btree",algorithm:"btree",columns:["id"]},{accessor:"parent_message_id",name:"thread_parent_message_id_idx_btree",algorithm:"btree",columns:["parentMessageId"]}],constraints:[{name:"thread_id_key",constraint:"unique",columns:["id"]},{name:"thread_parent_message_id_key",constraint:"unique",columns:["parentMessageId"]}]},Kv),user:dr({name:"user",indexes:[{accessor:"identity",name:"user_identity_idx_btree",algorithm:"btree",columns:["identity"]}],constraints:[{name:"user_identity_key",constraint:"unique",columns:["identity"]}]},Wv),voice_state:dr({name:"voice_state",indexes:[{accessor:"by_channel_id",name:"voice_state_channel_id_idx_btree",algorithm:"btree",columns:["channelId"]},{accessor:"identity",name:"voice_state_identity_idx_btree",algorithm:"btree",columns:["identity"]}],constraints:[{name:"voice_state_identity_key",constraint:"unique",columns:["identity"]}]},Qv)}),Zh=Cv(jt("create_channel",Ev),jt("create_server",Uv),jt("create_thread",Rv),jt("join_voice",Nv),jt("leave_voice",Pv),jt("login",Bv),jt("register",Av),jt("send_ice_candidate",Mv),jt("send_message",jv),jt("send_sdp_answer",Ov),jt("send_sdp_offer",Dv),jt("set_name",zv)),Jv=Tv(),Gv={versionInfo:{cliVersion:"2.1.0"},tables:Yh.schemaType.tables,reducers:Zh.reducersType.reducers,...Jv},fi=Nh(Yh.schemaType),fr=Pw(Zh.reducersType.reducers);class Xv extends Fh{}class Yv extends Sw{}class Fu extends kw{static builder=()=>new Yv(Gv,n=>new Fu(n));subscriptionBuilder=()=>new Xv(this)}var ep=class ia{__time_duration_micros__;static MICROS_PER_MILLIS=1000n;static getAlgebraicType(){return Be.Product({elements:[{name:"__time_duration_micros__",algebraicType:Be.I64}]})}static isTimeDuration(n){if(n.tag!=="Product")return!1;const s=n.value.elements;if(s.length!==1)return!1;const a=s[0];return a.name==="__time_duration_micros__"&&a.algebraicType.tag==="I64"}get micros(){return this.__time_duration_micros__}get millis(){return Number(this.micros/ia.MICROS_PER_MILLIS)}constructor(n){this.__time_duration_micros__=n}static fromMillis(n){return new ia(BigInt(n)*ia.MICROS_PER_MILLIS)}toString(){const n=this.micros,s=n<0?"-":"+",a=n<0?-n:n,c=a/1000000n,f=a%1000000n;return`${s}${c}.${String(f).padStart(6,"0")}`}},tp=class mn{__timestamp_micros_since_unix_epoch__;static MICROS_PER_MILLIS=1000n;get microsSinceUnixEpoch(){return this.__timestamp_micros_since_unix_epoch__}constructor(n){this.__timestamp_micros_since_unix_epoch__=n}static getAlgebraicType(){return Be.Product({elements:[{name:"__timestamp_micros_since_unix_epoch__",algebraicType:Be.I64}]})}static isTimestamp(n){if(n.tag!=="Product")return!1;const s=n.value.elements;if(s.length!==1)return!1;const a=s[0];return a.name==="__timestamp_micros_since_unix_epoch__"&&a.algebraicType.tag==="I64"}static UNIX_EPOCH=new mn(0n);static now(){return mn.fromDate(new Date)}toMillis(){return this.microsSinceUnixEpoch/1000n}static fromDate(n){const s=n.getTime(),a=BigInt(s)*mn.MICROS_PER_MILLIS;return new mn(a)}toDate(){const s=this.__timestamp_micros_since_unix_epoch__/mn.MICROS_PER_MILLIS;if(s>BigInt(Number.MAX_SAFE_INTEGER)||sBigInt(Number.MAX_SAFE_INTEGER)||s_t.MAX_UUID_BIGINT)throw new Error("Invalid UUID: must be between 0 and `MAX_UUID_BIGINT`");this.__uuid__=n}static fromRandomBytesV4(n){if(n.length!==16)throw new Error("UUID v4 requires 16 bytes");const s=new Uint8Array(n);return s[6]=s[6]&15|64,s[8]=s[8]&63|128,new _t(_t.bytesToBigInt(s))}static fromCounterV7(n,s,a){if(a.length!==4)throw new Error("`fromCounterV7` requires `randomBytes.length == 4`");if(n.value<0)throw new Error("`fromCounterV7` uuid `counter` must be non-negative");if(s.__timestamp_micros_since_unix_epoch__<0)throw new Error("`fromCounterV7` `timestamp` before unix epoch");const c=n.value;n.value=c+1&2147483647;const f=s.toMillis()&0xffffffffffffn,p=new Uint8Array(16);return p[0]=Number(f>>40n&0xffn),p[1]=Number(f>>32n&0xffn),p[2]=Number(f>>24n&0xffn),p[3]=Number(f>>16n&0xffn),p[4]=Number(f>>8n&0xffn),p[5]=Number(f&0xffn),p[7]=c>>>23&255,p[9]=c>>>15&255,p[10]=c>>>7&255,p[11]=(c&127)<<1&255,p[12]|=a[0]&127,p[13]=a[1],p[14]=a[2],p[15]=a[3],p[6]=p[6]&15|112,p[8]=p[8]&63|128,new _t(_t.bytesToBigInt(p))}static parse(n){const s=n.replace(/-/g,"");if(s.length!==32)throw new Error("Invalid hex UUID");let a=0n;for(let c=0;c<32;c+=2)a=a<<8n|BigInt(parseInt(s.slice(c,c+2),16));return new _t(a)}toString(){const s=[..._t.bigIntToBytes(this.__uuid__)].map(a=>a.toString(16).padStart(2,"0")).join("");return s.slice(0,8)+"-"+s.slice(8,12)+"-"+s.slice(12,16)+"-"+s.slice(16,20)+"-"+s.slice(20)}asBigInt(){return this.__uuid__}toBytes(){return _t.bigIntToBytes(this.__uuid__)}static bytesToBigInt(n){let s=0n;for(const a of n)s=s<<8n|BigInt(a);return s}static bigIntToBytes(n){const s=new Uint8Array(16);for(let a=15;a>=0;a--)s[a]=Number(n&0xffn),n>>=8n;return s}getVersion(){const n=this.toBytes()[6]>>4&15;switch(n){case 4:return"V4";case 7:return"V7";default:if(this==_t.NIL)return"Nil";if(this==_t.MAX)return"Max";throw new Error(`Unsupported UUID version: ${n}`)}}getCounter(){const n=this.toBytes(),s=n[7],a=n[9],c=n[10],f=n[11]>>>1;return s<<23|a<<15|c<<7|f|0}compareTo(n){return this.__uuid__n.__uuid__?1:0}static getAlgebraicType(){return Be.Product({elements:[{name:"__uuid__",algebraicType:Be.U128}]})}},Ze=class{view;offset=0;constructor(r){this.view=r instanceof DataView?r:new DataView(r.buffer,r.byteOffset,r.byteLength),this.offset=0}reset(r){this.view=r,this.offset=0}get remaining(){return this.view.byteLength-this.offset}#e(r){if(this.offset+r>this.view.byteLength)throw new RangeError(`Tried to read ${r} byte(s) at relative offset ${this.offset}, but only ${this.remaining} byte(s) remain`)}readUInt8Array(){const r=this.readU32();return this.#e(r),this.readBytes(r)}readBool(){const r=this.view.getUint8(this.offset);return this.offset+=1,r!==0}readByte(){const r=this.view.getUint8(this.offset);return this.offset+=1,r}readBytes(r){const n=new Uint8Array(this.view.buffer,this.view.byteOffset+this.offset,r);return this.offset+=r,n}readI8(){const r=this.view.getInt8(this.offset);return this.offset+=1,r}readU8(){return this.readByte()}readI16(){const r=this.view.getInt16(this.offset,!0);return this.offset+=2,r}readU16(){const r=this.view.getUint16(this.offset,!0);return this.offset+=2,r}readI32(){const r=this.view.getInt32(this.offset,!0);return this.offset+=4,r}readU32(){const r=this.view.getUint32(this.offset,!0);return this.offset+=4,r}readI64(){const r=this.view.getBigInt64(this.offset,!0);return this.offset+=8,r}readU64(){const r=this.view.getBigUint64(this.offset,!0);return this.offset+=8,r}readU128(){const r=this.view.getBigUint64(this.offset,!0),n=this.view.getBigUint64(this.offset+8,!0);return this.offset+=16,(n<>BigInt(64);this.view.setBigUint64(this.offset,n,!0),this.view.setBigUint64(this.offset+8,s,!0),this.offset+=16}writeI128(r){this.expandBuffer(16);const n=r&BigInt("0xFFFFFFFFFFFFFFFF"),s=r>>BigInt(64);this.view.setBigInt64(this.offset,n,!0),this.view.setBigInt64(this.offset+8,s,!0),this.offset+=16}writeU256(r){this.expandBuffer(32);const n=BigInt("0xFFFFFFFFFFFFFFFF"),s=r&n,a=r>>BigInt(64)&n,c=r>>BigInt(128)&n,f=r>>BigInt(192);this.view.setBigUint64(this.offset+0,s,!0),this.view.setBigUint64(this.offset+8,a,!0),this.view.setBigUint64(this.offset+16,c,!0),this.view.setBigUint64(this.offset+24,f,!0),this.offset+=32}writeI256(r){this.expandBuffer(32);const n=BigInt("0xFFFFFFFFFFFFFFFF"),s=r&n,a=r>>BigInt(64)&n,c=r>>BigInt(128)&n,f=r>>BigInt(192);this.view.setBigUint64(this.offset+0,s,!0),this.view.setBigUint64(this.offset+8,a,!0),this.view.setBigUint64(this.offset+16,c,!0),this.view.setBigInt64(this.offset+24,f,!0),this.offset+=32}writeF32(r){this.expandBuffer(4),this.view.setFloat32(this.offset,r,!0),this.offset+=4}writeF64(r){this.expandBuffer(8),this.view.setFloat64(this.offset,r,!0),this.offset+=8}writeString(r){const s=new TextEncoder().encode(r);this.writeUInt8Array(s)}};function rp(r){return Array.prototype.map.call(r.reverse(),n=>("00"+n.toString(16)).slice(-2)).join("")}function r_(r){if(r.length!=16)throw new Error(`Uint8Array is not 16 bytes long: ${r}`);return new Ze(r).readU128()}function n_(r){if(r.length!=32)throw new Error(`Uint8Array is not 32 bytes long: [${r}]`);return new Ze(r).readU256()}function np(r){r.startsWith("0x")&&(r=r.slice(2));const n=r.match(/.{1,2}/g)||[];return Uint8Array.from(n.map(a=>parseInt(a,16))).reverse()}function i_(r){return r_(np(r))}function s_(r){return n_(np(r))}function ip(r){const n=new Ke(16);return n.writeU128(r),n.getBuffer()}function o_(r){return rp(ip(r))}function sp(r){const n=new Ke(32);return n.writeU256(r),n.getBuffer()}function a_(r){return rp(sp(r))}var ah=Object.hasOwn,l_=class Tu{__identity__;constructor(n){this.__identity__=typeof n=="string"?s_(n):n}static getAlgebraicType(){return Be.Product({elements:[{name:"__identity__",algebraicType:Be.U256}]})}isEqual(n){return this.toHexString()===n.toHexString()}equals(n){return this.isEqual(n)}toHexString(){return a_(this.__identity__)}toUint8Array(){return sp(this.__identity__)}static fromString(n){return new Tu(n)}static zero(){return new Tu(0n)}toString(){return this.toHexString()}},Us=new Map,Rs=new Map,Be={Ref:r=>({tag:"Ref",value:r}),Sum:r=>({tag:"Sum",value:r}),Product:r=>({tag:"Product",value:r}),Array:r=>({tag:"Array",value:r}),String:{tag:"String"},Bool:{tag:"Bool"},I8:{tag:"I8"},U8:{tag:"U8"},I16:{tag:"I16"},U16:{tag:"U16"},I32:{tag:"I32"},U32:{tag:"U32"},I64:{tag:"I64"},U64:{tag:"U64"},I128:{tag:"I128"},U128:{tag:"U128"},I256:{tag:"I256"},U256:{tag:"U256"},F32:{tag:"F32"},F64:{tag:"F64"},makeSerializer(r,n){if(r.tag==="Ref"){if(!n)throw new Error("cannot serialize refs without a typespace");for(;r.tag==="Ref";)r=n.types[r.value]}switch(r.tag){case"Product":return Ns.makeSerializer(r.value,n);case"Sum":return fa.makeSerializer(r.value,n);case"Array":if(r.value.tag==="U8")return u_;{const s=Be.makeSerializer(r.value,n);return(a,c)=>{a.writeU32(c.length);for(const f of c)s(a,f)}}default:return op[r.tag]}},serializeValue(r,n,s,a){Be.makeSerializer(n,a)(r,s)},makeDeserializer(r,n){if(r.tag==="Ref"){if(!n)throw new Error("cannot deserialize refs without a typespace");for(;r.tag==="Ref";)r=n.types[r.value]}switch(r.tag){case"Product":return Ns.makeDeserializer(r.value,n);case"Sum":return fa.makeDeserializer(r.value,n);case"Array":if(r.value.tag==="U8")return c_;{const s=Be.makeDeserializer(r.value,n);return a=>{const c=a.readU32(),f=Array(c);for(let p=0;pr.elements.every(({algebraicType:n})=>d_.has(n.tag)),f_=r=>r.elements.reduce((n,{algebraicType:s})=>n+Ii[s.tag],0),Xo={Bool:"Uint8",I8:"Int8",U8:"Uint8",I16:"Int16",U16:"Uint16",I32:"Int32",U32:"Uint32",I64:"BigInt64",U64:"BigUint64",F32:"Float32",F64:"Float64"},sa={__time_duration_micros__:r=>new ep(r.readI64()),__timestamp_micros_since_unix_epoch__:r=>new tp(r.readI64()),__identity__:r=>new l_(r.readU256()),__connection_id__:r=>new $u(r.readU128()),__uuid__:r=>new Zv(r.readU128())};Object.freeze(sa);var h_=()=>({}),uh=r=>{let n;switch(r.algebraicType.tag){case"String":n="''";break;case"Bool":n="false";break;case"I8":case"U8":case"I16":case"U16":case"I32":case"U32":n="0";break;case"I64":case"U64":case"I128":case"U128":case"I256":case"U256":n="0n";break;case"F32":case"F64":n="0.0";break;default:n="undefined"}return`${r.name}: ${n}`},Ns={makeSerializer(r,n){let s=Us.get(r);if(s!=null)return s;if(lh(r)){const p=`"use strict"; +writer.expandBuffer(${f_(r)}); +const view = writer.view; +${r.elements.map(({name:v,algebraicType:{tag:y}})=>y in Xo?`view.set${Xo[y]}(writer.offset, value.${v}, ${Ii[y]>1?"true":""}); +writer.offset += ${Ii[y]};`:`writer.write${y}(value.${v});`).join(` +`)}`;return s=Function("writer","value",p),Us.set(r,s),s}const a={},c=`"use strict"; +`+r.elements.map(f=>`this.${f.name}(writer, value.${f.name});`).join(` +`);s=Function("writer","value",c).bind(a),Us.set(r,s);for(const{name:f,algebraicType:p}of r.elements)a[f]=Be.makeSerializer(p,n);return Object.freeze(a),s},serializeValue(r,n,s,a){Ns.makeSerializer(n,a)(r,s)},makeDeserializer(r,n){switch(r.elements.length){case 0:return h_;case 1:{const c=r.elements[0].name;if(ah(sa,c))return sa[c]}}let s=Rs.get(r);if(s!=null)return s;if(lh(r)){const c=`"use strict"; +const result = { ${r.elements.map(uh).join(", ")} }; +const view = reader.view; +${r.elements.map(({name:f,algebraicType:{tag:p}})=>p in Xo?p==="Bool"?`result.${f} = view.getUint8(reader.offset) !== 0; +reader.offset += 1;`:`result.${f} = view.get${Xo[p]}(reader.offset, ${Ii[p]>1?"true":""}); +reader.offset += ${Ii[p]};`:`result.${f} = reader.read${p}();`).join(` +`)} +return result;`;return s=Function("reader",c),Rs.set(r,s),s}const a={};s=Function("reader",`"use strict"; +const result = { ${r.elements.map(uh).join(", ")} }; +${r.elements.map(({name:c})=>`result.${c} = this.${c}(reader);`).join(` +`)} +return result;`).bind(a),Rs.set(r,s);for(const{name:c,algebraicType:f}of r.elements)a[c]=Be.makeDeserializer(f,n);return Object.freeze(a),s},deserializeValue(r,n,s){return Ns.makeDeserializer(n,s)(r)},intoMapKey(r,n){if(r.elements.length===1){const a=r.elements[0].name;if(ah(sa,a))return n[a]}const s=new Ke(10);return Be.serializeValue(s,Be.Product(r),n),s.toBase64()}},fa={makeSerializer(r,n){if(r.variants.length==2&&r.variants[0].name==="some"&&r.variants[1].name==="none"){const s=Be.makeSerializer(r.variants[0].algebraicType,n);return(a,c)=>{c!=null?(a.writeByte(0),s(a,c)):a.writeByte(1)}}else if(r.variants.length==2&&r.variants[0].name==="ok"&&r.variants[1].name==="err"){const s=Be.makeSerializer(r.variants[0].algebraicType,n),a=Be.makeSerializer(r.variants[0].algebraicType,n);return(c,f)=>{if("ok"in f)c.writeU8(0),s(c,f.ok);else if("err"in f)c.writeU8(1),a(c,f.err);else throw new TypeError("could not serialize result: object had neither a `ok` nor an `err` field")}}else{let s=Us.get(r);if(s!=null)return s;const a={},c=`switch (value.tag) { +${r.variants.map(({name:f},p)=>` case ${JSON.stringify(f)}: + writer.writeByte(${p}); + return this.${f}(writer, value.value);`).join(` +`)} + default: + throw new TypeError( + \`Could not serialize sum type; unknown tag \${value.tag}\` + ) +} +`;s=Function("writer","value",c).bind(a),Us.set(r,s);for(const{name:f,algebraicType:p}of r.variants)a[f]=Be.makeSerializer(p,n);return Object.freeze(a),s}},serializeValue(r,n,s,a){fa.makeSerializer(n,a)(r,s)},makeDeserializer(r,n){if(r.variants.length==2&&r.variants[0].name==="some"&&r.variants[1].name==="none"){const s=Be.makeDeserializer(r.variants[0].algebraicType,n);return a=>{const c=a.readU8();if(c===0)return s(a);if(c===1)return;throw`Can't deserialize an option type, couldn't find ${c} tag`}}else if(r.variants.length==2&&r.variants[0].name==="ok"&&r.variants[1].name==="err"){const s=Be.makeDeserializer(r.variants[0].algebraicType,n),a=Be.makeDeserializer(r.variants[1].algebraicType,n);return c=>{const f=c.readByte();if(f===0)return{ok:s(c)};if(f===1)return{err:a(c)};throw`Can't deserialize a result type, couldn't find ${f} tag`}}else{let s=Rs.get(r);if(s!=null)return s;const a={};s=Function("reader",`switch (reader.readU8()) { +${r.variants.map(({name:c},f)=>`case ${f}: return { tag: ${JSON.stringify(c)}, value: this.${c}(reader) };`).join(` +`)} }`).bind(a),Rs.set(r,s);for(const{name:c,algebraicType:f}of r.variants)a[c]=Be.makeDeserializer(f,n);return Object.freeze(a),s}},deserializeValue(r,n,s){return fa.makeDeserializer(n,s)(r)}},$u=class oa{__connection_id__;constructor(n){this.__connection_id__=n}static getAlgebraicType(){return Be.Product({elements:[{name:"__connection_id__",algebraicType:Be.U128}]})}isZero(){return this.__connection_id__===BigInt(0)}static nullIfZero(n){return n.isZero()?null:n}static random(){function n(){return Math.floor(Math.random()*255)}let s=BigInt(0);for(let a=0;a<16;a++)s=s<Ot(r.right,n);case"gte":return Ot(r.left,n)>=Ot(r.right,n);case"lt":return Ot(r.left,n)aa(s,n));case"or":return r.clauses.some(s=>aa(s,n));case"not":return!aa(r.clause,n)}}function Ot(r,n){return g_(r)?ch(r.value):ch(n[r.column])}function m_(r){return!!r&&typeof r=="object"&&typeof r.toHexString=="function"}function y_(r){return!r||typeof r!="object"?!1:r instanceof tp?!0:typeof r.__timestamp_micros_since_unix_epoch__=="bigint"}function ch(r){return m_(r)?r.toHexString():y_(r)?r.__timestamp_micros_since_unix_epoch__:r}function w_(r){if(r.table)return r.table.accessorName;if(r.accessorName)return r.accessorName;if(r.sourceQuery)return r.sourceQuery.table.accessorName;throw new Error("Cannot extract accessor name from query")}function v_(r){if(r.whereClause)return r.whereClause}var lp=ae.createContext(void 0);function Lu(){const r=ae.useContext(lp);if(!r)throw new Error("useSpacetimeDB must be used within a SpacetimeDBProvider component. Did you forget to add a `SpacetimeDBProvider` to your component tree?");return r}function __(){return{isActive:!1,identity:void 0,token:void 0,connectionId:$u.random(),connectionError:void 0}}var S_=class up{#e=new Map;static getKey(n,s){return`${n}::${s}`}getKey(n,s){return up.getKey(n,s)}#t(n){const s=this.#e.get(n);if(s)return s;const a={connection:void 0,refCount:0,state:__(),listeners:new Set,pendingRelease:null};return this.#e.set(n,a),a}#n(n){for(const s of n.listeners)s()}retain(n,s){const a=this.#t(n);if(a.pendingRelease&&(clearTimeout(a.pendingRelease),a.pendingRelease=null),a.refCount+=1,a.connection)return a.connection;const c=s.build();a.connection=c;const f=p=>{a.state={...a.state,...p},this.#n(a)};return f({isActive:c.isActive,identity:c.identity,token:c.token,connectionId:c.connectionId,connectionError:void 0}),a.onConnect=p=>{f({isActive:p.isActive,identity:p.identity,token:p.token,connectionId:p.connectionId,connectionError:void 0})},a.onDisconnect=(p,v)=>{f({isActive:p.isActive,connectionError:v??void 0})},a.onConnectError=(p,v)=>{f({isActive:p.isActive,connectionError:v})},s.onConnect(a.onConnect),s.onDisconnect(a.onDisconnect),s.onConnectError(a.onConnectError),c}release(n){const s=this.#e.get(n);s&&(s.refCount-=1,!(s.refCount>0||s.pendingRelease)&&(s.pendingRelease=setTimeout(()=>{s.pendingRelease=null,!(s.refCount>0)&&(s.connection&&(s.onConnect&&s.connection.removeOnConnect(s.onConnect),s.onDisconnect&&s.connection.removeOnDisconnect(s.onDisconnect),s.onConnectError&&s.connection.removeOnConnectError(s.onConnectError),s.connection.disconnect()),this.#e.delete(n))},0)))}subscribe(n,s){const a=this.#t(n);return a.listeners.add(s),()=>{a.listeners.delete(s),a.refCount<=0&&a.listeners.size===0&&!a.connection&&this.#e.delete(n)}}getSnapshot(n){return this.#e.get(n)?.state}getConnection(n){return this.#e.get(n)?.connection??null}},hi=new S_;function x_({connectionBuilder:r,children:n}){const s=r.getUri(),a=r.getModuleName(),c=ae.useMemo(()=>hi.getKey(s,a),[s,a]),f=ae.useRef({isActive:!1,identity:void 0,token:void 0,connectionId:$u.random(),connectionError:void 0}),p=ae.useCallback(j=>hi.subscribe(c,j),[c]),v=ae.useCallback(()=>hi.getSnapshot(c)??f.current,[c]),y=ae.useCallback(()=>f.current,[]),x=ae.useSyncExternalStore(p,v,y),R=ae.useCallback(()=>hi.getConnection(c),[c]),N=ae.useMemo(()=>({...x,getConnection:R}),[x,R]);return ae.useEffect(()=>(hi.retain(c,r),()=>{hi.release(c)}),[c,r]),ae.createElement(lp.Provider,{value:N},n)}function I_(r,n,s){if(!r)return"stayIn";const a=Ps(r,n),c=Ps(r,s);return a&&!c?"leave":!a&&c?"enter":a&&c?"stayIn":"stayOut"}function pi(r,n){const s=w_(r),a=v_(r),[c,f]=ae.useState(!1);let p;try{p=Lu()}catch{throw new Error("Could not find SpacetimeDB client! Did you forget to add a `SpacetimeDBProvider`? `useTable` must be used in the React component tree under a `SpacetimeDBProvider` component.")}const v=p_(r),y=ae.useRef(null),x=ae.useRef(null),R=ae.useCallback(()=>{const O=p.getConnection();if(!O)return[[],!1];const q=O.db[s];return[a?Array.from(q.iter()).filter($=>Ps(a,$)):Array.from(q.iter()),c]},[p,s,v,c]);ae.useEffect(()=>{x.current=null},[R]),ae.useEffect(()=>{const O=p.getConnection();if(p.isActive&&O){const q=O.subscriptionBuilder().onApplied(()=>{f(!0)}).subscribe(v);return()=>{q.unsubscribe()}}},[v,p.isActive,p]);const N=ae.useCallback(O=>{const q=(A,L)=>{a&&!Ps(a,L)||A.event.id!==y.current&&(y.current=A.event.id,x.current=R(),O())},Q=(A,L)=>{a&&!Ps(a,L)||A.event.id!==y.current&&(y.current=A.event.id,x.current=R(),O())},$=(A,L,J)=>{switch(I_(a,L,J)){case"leave":break;case"enter":break;case"stayIn":break;case"stayOut":return}A.event.id!==y.current&&(y.current=A.event.id,x.current=R(),O())},fe=p.getConnection();if(!fe)return()=>{};const T=fe.db[s];return T.onInsert(q),T.onDelete(Q),T.onUpdate?.($),()=>{T.removeOnInsert(q),T.removeOnDelete(Q),T.removeOnUpdate?.($)}},[p,s,v,R,n?.onDelete,n?.onInsert,n?.onUpdate]),j=ae.useCallback(()=>(x.current||(x.current=R()),x.current),[R]);return ae.useSyncExternalStore(N,j,j)}function hr(r){const{getConnection:n,isActive:s}=Lu(),a=r.accessorName,c=ae.useRef([]);return ae.useEffect(()=>{const f=n();if(!f)return;const p=f.reducers[a];if(c.current.length){const v=c.current.splice(0);for(const y of v)p(...y.params).then(y.resolve,y.reject)}},[n,a,s]),ae.useCallback((...f)=>{const p=n();if(!p)return new Promise((y,x)=>{c.current.push({params:f,resolve:y,reject:x})});const v=p.reducers[a];return v(...f)},[n,a])}class ks extends Error{}ks.prototype.name="InvalidTokenError";function k_(r){return decodeURIComponent(atob(r).replace(/(.)/g,(n,s)=>{let a=s.charCodeAt(0).toString(16).toUpperCase();return a.length<2&&(a="0"+a),"%"+a}))}function b_(r){let n=r.replace(/-/g,"+").replace(/_/g,"/");switch(n.length%4){case 0:break;case 2:n+="==";break;case 3:n+="=";break;default:throw new Error("base64 string is not of the correct length")}try{return k_(n)}catch{return atob(n)}}function C_(r,n){if(typeof r!="string")throw new ks("Invalid token specified: must be a string");n||(n={});const s=n.header===!0?0:1,a=r.split(".")[s];if(typeof a!="string")throw new ks(`Invalid token specified: missing part #${s+1}`);let c;try{c=b_(a)}catch(f){throw new ks(`Invalid token specified: invalid base64 for part #${s+1} (${f.message})`)}try{return JSON.parse(c)}catch(f){throw new ks(`Invalid token specified: invalid json for part #${s+1} (${f.message})`)}}var T_={debug:()=>{},info:()=>{},warn:()=>{},error:()=>{}},er,tr,ha=(r=>(r[r.NONE=0]="NONE",r[r.ERROR=1]="ERROR",r[r.WARN=2]="WARN",r[r.INFO=3]="INFO",r[r.DEBUG=4]="DEBUG",r))(ha||{});(r=>{function n(){er=3,tr=T_}r.reset=n;function s(c){if(!(0<=c&&c<=4))throw new Error("Invalid log level");er=c}r.setLevel=s;function a(c){tr=c}r.setLogger=a})(ha||(ha={}));var Se=class Zt{constructor(n){this._name=n}debug(...n){er>=4&&tr.debug(Zt._format(this._name,this._method),...n)}info(...n){er>=3&&tr.info(Zt._format(this._name,this._method),...n)}warn(...n){er>=2&&tr.warn(Zt._format(this._name,this._method),...n)}error(...n){er>=1&&tr.error(Zt._format(this._name,this._method),...n)}throw(n){throw this.error(n),n}create(n){const s=Object.create(this);return s._method=n,s.debug("begin"),s}static createStatic(n,s){const a=new Zt(`${n}.${s}`);return a.debug("begin"),a}static _format(n,s){const a=`[${n}]`;return s?`${a} ${s}:`:a}static debug(n,...s){er>=4&&tr.debug(Zt._format(n),...s)}static info(n,...s){er>=3&&tr.info(Zt._format(n),...s)}static warn(n,...s){er>=2&&tr.warn(Zt._format(n),...s)}static error(n,...s){er>=1&&tr.error(Zt._format(n),...s)}};ha.reset();var Ms=class{static decode(r){try{return C_(r)}catch(n){throw Se.error("JwtUtils.decode",n),n}}static async generateSignedJwt(r,n,s){const a=Je.encodeBase64Url(new TextEncoder().encode(JSON.stringify(r))),c=Je.encodeBase64Url(new TextEncoder().encode(JSON.stringify(n))),f=`${a}.${c}`,p=await window.crypto.subtle.sign({name:"ECDSA",hash:{name:"SHA-256"}},s,new TextEncoder().encode(f)),v=Je.encodeBase64Url(new Uint8Array(p));return`${f}.${v}`}static async generateSignedJwtWithHmac(r,n,s){const a=Je.encodeBase64Url(new TextEncoder().encode(JSON.stringify(r))),c=Je.encodeBase64Url(new TextEncoder().encode(JSON.stringify(n))),f=`${a}.${c}`,p=await window.crypto.subtle.sign("HMAC",s,new TextEncoder().encode(f)),v=Je.encodeBase64Url(new Uint8Array(p));return`${f}.${v}`}},E_="10000000-1000-4000-8000-100000000000",Eu=r=>btoa([...new Uint8Array(r)].map(n=>String.fromCharCode(n)).join("")),cp=class Kt{static _randomWord(){const n=new Uint32Array(1);return crypto.getRandomValues(n),n[0]}static generateUUIDv4(){return E_.replace(/[018]/g,s=>(+s^Kt._randomWord()&15>>+s/4).toString(16)).replace(/-/g,"")}static generateCodeVerifier(){return Kt.generateUUIDv4()+Kt.generateUUIDv4()+Kt.generateUUIDv4()}static async generateCodeChallenge(n){if(!crypto.subtle)throw new Error("Crypto.subtle is available only in secure contexts (HTTPS).");try{const a=new TextEncoder().encode(n),c=await crypto.subtle.digest("SHA-256",a);return Eu(c).replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/,"")}catch(s){throw Se.error("CryptoUtils.generateCodeChallenge",s),s}}static generateBasicAuth(n,s){const c=new TextEncoder().encode([n,s].join(":"));return Eu(c)}static async hash(n,s){const a=new TextEncoder().encode(s),c=await crypto.subtle.digest(n,a);return new Uint8Array(c)}static async customCalculateJwkThumbprint(n){let s;switch(n.kty){case"RSA":s={e:n.e,kty:n.kty,n:n.n};break;case"EC":s={crv:n.crv,kty:n.kty,x:n.x,y:n.y};break;case"OKP":s={crv:n.crv,kty:n.kty,x:n.x};break;case"oct":s={crv:n.k,kty:n.kty};break;default:throw new Error("Unknown jwk type")}const a=await Kt.hash("SHA-256",JSON.stringify(s));return Kt.encodeBase64Url(a)}static async generateDPoPProof({url:n,accessToken:s,httpMethod:a,keyPair:c,nonce:f}){let p,v;const y={jti:window.crypto.randomUUID(),htm:a??"GET",htu:n,iat:Math.floor(Date.now()/1e3)};s&&(p=await Kt.hash("SHA-256",s),v=Kt.encodeBase64Url(p),y.ath=v),f&&(y.nonce=f);try{const x=await crypto.subtle.exportKey("jwk",c.publicKey),R={alg:"ES256",typ:"dpop+jwt",jwk:{crv:x.crv,kty:x.kty,x:x.x,y:x.y}};return await Ms.generateSignedJwt(R,y,c.privateKey)}catch(x){throw x instanceof TypeError?new Error(`Error exporting dpop public key: ${x.message}`):x}}static async generateDPoPJkt(n){try{const s=await crypto.subtle.exportKey("jwk",n.publicKey);return await Kt.customCalculateJwkThumbprint(s)}catch(s){throw s instanceof TypeError?new Error(`Could not retrieve dpop keys from storage: ${s.message}`):s}}static async generateDPoPKeys(){return await window.crypto.subtle.generateKey({name:"ECDSA",namedCurve:"P-256"},!1,["sign","verify"])}static async generateClientAssertionJwt(n,s,a,c="HS256"){const f=Math.floor(Date.now()/1e3),p={alg:c,typ:"JWT"},v={iss:n,sub:n,aud:a,jti:Kt.generateUUIDv4(),exp:f+300,iat:f},x={HS256:"SHA-256",HS384:"SHA-384",HS512:"SHA-512"}[c];if(!x)throw new Error(`Unsupported algorithm: ${c}. Supported algorithms are: HS256, HS384, HS512`);const R=new TextEncoder,N=await crypto.subtle.importKey("raw",R.encode(s),{name:"HMAC",hash:x},!1,["sign"]);return await Ms.generateSignedJwtWithHmac(p,v,N)}};cp.encodeBase64Url=r=>Eu(r).replace(/=/g,"").replace(/\+/g,"-").replace(/\//g,"_");var Je=cp,Or=class{constructor(r){this._name=r,this._callbacks=[],this._logger=new Se(`Event('${this._name}')`)}addHandler(r){return this._callbacks.push(r),()=>this.removeHandler(r)}removeHandler(r){const n=this._callbacks.lastIndexOf(r);n>=0&&this._callbacks.splice(n,1)}async raise(...r){this._logger.debug("raise:",...r);for(const n of this._callbacks)await n(...r)}},dh=class{static center({...r}){var n,s,a;return r.width==null&&(r.width=(n=[800,720,600,480].find(c=>c<=window.outerWidth/1.618))!=null?n:360),(s=r.left)!=null||(r.left=Math.max(0,Math.round(window.screenX+(window.outerWidth-r.width)/2))),r.height!=null&&((a=r.top)!=null||(r.top=Math.max(0,Math.round(window.screenY+(window.outerHeight-r.height)/2)))),r}static serialize(r){return Object.entries(r).filter(([,n])=>n!=null).map(([n,s])=>`${n}=${typeof s!="boolean"?s:s?"yes":"no"}`).join(",")}},gr=class la extends Or{constructor(){super(...arguments),this._logger=new Se(`Timer('${this._name}')`),this._timerHandle=null,this._expiration=0,this._callback=()=>{const n=this._expiration-la.getEpochTime();this._logger.debug("timer completes in",n),this._expiration<=la.getEpochTime()&&(this.cancel(),super.raise())}}static getEpochTime(){return Math.floor(Date.now()/1e3)}init(n){const s=this._logger.create("init");n=Math.max(Math.floor(n),1);const a=la.getEpochTime()+n;if(this.expiration===a&&this._timerHandle){s.debug("skipping since already initialized for expiration at",this.expiration);return}this.cancel(),s.debug("using duration",n),this._expiration=a;const c=Math.min(n,5);this._timerHandle=setInterval(this._callback,c*1e3)}get expiration(){return this._expiration}cancel(){this._logger.create("cancel"),this._timerHandle&&(clearInterval(this._timerHandle),this._timerHandle=null)}},Uu=class{static readParams(r,n="query"){if(!r)throw new TypeError("Invalid URL");const a=new URL(r,"http://127.0.0.1")[n==="fragment"?"hash":"search"];return new URLSearchParams(a.slice(1))}},Ti=";",vn=class extends Error{constructor(r,n){var s,a,c;if(super(r.error_description||r.error||""),this.form=n,this.name="ErrorResponse",!r.error)throw Se.error("ErrorResponse","No error passed"),new Error("No error passed");this.error=r.error,this.error_description=(s=r.error_description)!=null?s:null,this.error_uri=(a=r.error_uri)!=null?a:null,this.state=r.userState,this.session_state=(c=r.session_state)!=null?c:null,this.url_state=r.url_state}},Vu=class extends Error{constructor(r){super(r),this.name="ErrorTimeout"}},U_=class{constructor(r){this._logger=new Se("AccessTokenEvents"),this._expiringTimer=new gr("Access token expiring"),this._expiredTimer=new gr("Access token expired"),this._expiringNotificationTimeInSeconds=r.expiringNotificationTimeInSeconds}async load(r){const n=this._logger.create("load");if(r.access_token&&r.expires_in!==void 0){const s=r.expires_in;if(n.debug("access token present, remaining duration:",s),s>0){let c=s-this._expiringNotificationTimeInSeconds;c<=0&&(c=1),n.debug("registering expiring timer, raising in",c,"seconds"),this._expiringTimer.init(c)}else n.debug("canceling existing expiring timer because we're past expiration."),this._expiringTimer.cancel();const a=s+1;n.debug("registering expired timer, raising in",a,"seconds"),this._expiredTimer.init(a)}else this._expiringTimer.cancel(),this._expiredTimer.cancel()}async unload(){this._logger.debug("unload: canceling existing access token timers"),this._expiringTimer.cancel(),this._expiredTimer.cancel()}addAccessTokenExpiring(r){return this._expiringTimer.addHandler(r)}removeAccessTokenExpiring(r){this._expiringTimer.removeHandler(r)}addAccessTokenExpired(r){return this._expiredTimer.addHandler(r)}removeAccessTokenExpired(r){this._expiredTimer.removeHandler(r)}},R_=class{constructor(r,n,s,a,c){this._callback=r,this._client_id=n,this._intervalInSeconds=a,this._stopOnError=c,this._logger=new Se("CheckSessionIFrame"),this._timer=null,this._session_state=null,this._message=p=>{p.origin===this._frame_origin&&p.source===this._frame.contentWindow&&(p.data==="error"?(this._logger.error("error message from check session op iframe"),this._stopOnError&&this.stop()):p.data==="changed"?(this._logger.debug("changed message from check session op iframe"),this.stop(),this._callback()):this._logger.debug(p.data+" message from check session op iframe"))};const f=new URL(s);this._frame_origin=f.origin,this._frame=window.document.createElement("iframe"),this._frame.style.visibility="hidden",this._frame.style.position="fixed",this._frame.style.left="-1000px",this._frame.style.top="0",this._frame.width="0",this._frame.height="0",this._frame.src=f.href}load(){return new Promise(r=>{this._frame.onload=()=>{r()},window.document.body.appendChild(this._frame),window.addEventListener("message",this._message,!1)})}start(r){if(this._session_state===r)return;this._logger.create("start"),this.stop(),this._session_state=r;const n=()=>{!this._frame.contentWindow||!this._session_state||this._frame.contentWindow.postMessage(this._client_id+" "+this._session_state,this._frame_origin)};n(),this._timer=setInterval(n,this._intervalInSeconds*1e3)}stop(){this._logger.create("stop"),this._session_state=null,this._timer&&(clearInterval(this._timer),this._timer=null)}},dp=class{constructor(){this._logger=new Se("InMemoryWebStorage"),this._data={}}clear(){this._logger.create("clear"),this._data={}}getItem(r){return this._logger.create(`getItem('${r}')`),this._data[r]}setItem(r,n){this._logger.create(`setItem('${r}')`),this._data[r]=n}removeItem(r){this._logger.create(`removeItem('${r}')`),delete this._data[r]}get length(){return Object.getOwnPropertyNames(this._data).length}key(r){return Object.getOwnPropertyNames(this._data)[r]}},Ru=class extends Error{constructor(r,n){super(n),this.name="ErrorDPoPNonce",this.nonce=r}},qu=class{constructor(r=[],n=null,s={}){this._jwtHandler=n,this._extraHeaders=s,this._logger=new Se("JsonService"),this._contentTypes=[],this._contentTypes.push(...r,"application/json"),n&&this._contentTypes.push("application/jwt")}async fetchWithTimeout(r,n={}){const{timeoutInSeconds:s,...a}=n;if(!s)return await fetch(r,a);const c=new AbortController,f=setTimeout(()=>c.abort(),s*1e3);try{return await fetch(r,{...n,signal:c.signal})}catch(p){throw p instanceof DOMException&&p.name==="AbortError"?new Vu("Network timed out"):p}finally{clearTimeout(f)}}async getJson(r,{token:n,credentials:s,timeoutInSeconds:a}={}){const c=this._logger.create("getJson"),f={Accept:this._contentTypes.join(", ")};n&&(c.debug("token passed, setting Authorization header"),f.Authorization="Bearer "+n),this._appendExtraHeaders(f);let p;try{c.debug("url:",r),p=await this.fetchWithTimeout(r,{method:"GET",headers:f,timeoutInSeconds:a,credentials:s})}catch(x){throw c.error("Network Error"),x}c.debug("HTTP response received, status",p.status);const v=p.headers.get("Content-Type");if(v&&!this._contentTypes.find(x=>v.startsWith(x))&&c.throw(new Error(`Invalid response Content-Type: ${v??"undefined"}, from URL: ${r}`)),p.ok&&this._jwtHandler&&v?.startsWith("application/jwt"))return await this._jwtHandler(await p.text());let y;try{y=await p.json()}catch(x){throw c.error("Error parsing JSON response",x),p.ok?x:new Error(`${p.statusText} (${p.status})`)}if(!p.ok)throw c.error("Error from server:",y),y.error?new vn(y):new Error(`${p.statusText} (${p.status}): ${JSON.stringify(y)}`);return y}async postForm(r,{body:n,basicAuth:s,timeoutInSeconds:a,initCredentials:c,extraHeaders:f}){const p=this._logger.create("postForm"),v={Accept:this._contentTypes.join(", "),"Content-Type":"application/x-www-form-urlencoded",...f};s!==void 0&&(v.Authorization="Basic "+s),this._appendExtraHeaders(v);let y;try{p.debug("url:",r),y=await this.fetchWithTimeout(r,{method:"POST",headers:v,body:n,timeoutInSeconds:a,credentials:c})}catch(j){throw p.error("Network error"),j}p.debug("HTTP response received, status",y.status);const x=y.headers.get("Content-Type");if(x&&!this._contentTypes.find(j=>x.startsWith(j)))throw new Error(`Invalid response Content-Type: ${x??"undefined"}, from URL: ${r}`);const R=await y.text();let N={};if(R)try{N=JSON.parse(R)}catch(j){throw p.error("Error parsing JSON response",j),y.ok?j:new Error(`${y.statusText} (${y.status})`)}if(!y.ok){if(p.error("Error from server:",N),y.headers.has("dpop-nonce")){const j=y.headers.get("dpop-nonce");throw new Ru(j,`${JSON.stringify(N)}`)}throw N.error?new vn(N,n):new Error(`${y.statusText} (${y.status}): ${JSON.stringify(N)}`)}return N}_appendExtraHeaders(r){const n=this._logger.create("appendExtraHeaders"),s=Object.keys(this._extraHeaders),a=["accept","content-type"],c=["authorization"];s.length!==0&&s.forEach(f=>{if(a.includes(f.toLocaleLowerCase())){n.warn("Protected header could not be set",f,a);return}if(c.includes(f.toLocaleLowerCase())&&Object.keys(r).includes(f)){n.warn("Header could not be overridden",f,c);return}const p=typeof this._extraHeaders[f]=="function"?this._extraHeaders[f]():this._extraHeaders[f];p&&p!==""&&(r[f]=p)})}},N_=class{constructor(r){this._settings=r,this._logger=new Se("MetadataService"),this._signingKeys=null,this._metadata=null,this._metadataUrl=this._settings.metadataUrl,this._jsonService=new qu(["application/jwk-set+json"],null,this._settings.extraHeaders),this._settings.signingKeys&&(this._logger.debug("using signingKeys from settings"),this._signingKeys=this._settings.signingKeys),this._settings.metadata&&(this._logger.debug("using metadata from settings"),this._metadata=this._settings.metadata),this._settings.fetchRequestCredentials&&(this._logger.debug("using fetchRequestCredentials from settings"),this._fetchRequestCredentials=this._settings.fetchRequestCredentials)}resetSigningKeys(){this._signingKeys=null}async getMetadata(){const r=this._logger.create("getMetadata");if(this._metadata)return r.debug("using cached values"),this._metadata;if(!this._metadataUrl)throw r.throw(new Error("No authority or metadataUrl configured on settings")),null;r.debug("getting metadata from",this._metadataUrl);const n=await this._jsonService.getJson(this._metadataUrl,{credentials:this._fetchRequestCredentials,timeoutInSeconds:this._settings.requestTimeoutInSeconds});return r.debug("merging remote JSON with seed metadata"),this._metadata=Object.assign({},n,this._settings.metadataSeed),this._metadata}getIssuer(){return this._getMetadataProperty("issuer")}getAuthorizationEndpoint(){return this._getMetadataProperty("authorization_endpoint")}getUserInfoEndpoint(){return this._getMetadataProperty("userinfo_endpoint")}getTokenEndpoint(r=!0){return this._getMetadataProperty("token_endpoint",r)}getCheckSessionIframe(){return this._getMetadataProperty("check_session_iframe",!0)}getEndSessionEndpoint(){return this._getMetadataProperty("end_session_endpoint",!0)}getRevocationEndpoint(r=!0){return this._getMetadataProperty("revocation_endpoint",r)}getKeysEndpoint(r=!0){return this._getMetadataProperty("jwks_uri",r)}async _getMetadataProperty(r,n=!1){const s=this._logger.create(`_getMetadataProperty('${r}')`),a=await this.getMetadata();if(s.debug("resolved"),a[r]===void 0){if(n===!0){s.warn("Metadata does not contain optional property");return}s.throw(new Error("Metadata does not contain property "+r))}return a[r]}async getSigningKeys(){const r=this._logger.create("getSigningKeys");if(this._signingKeys)return r.debug("returning signingKeys from cache"),this._signingKeys;const n=await this.getKeysEndpoint(!1);r.debug("got jwks_uri",n);const s=await this._jsonService.getJson(n,{timeoutInSeconds:this._settings.requestTimeoutInSeconds});if(r.debug("got key set",s),!Array.isArray(s.keys))throw r.throw(new Error("Missing keys on keyset")),null;return this._signingKeys=s.keys,this._signingKeys}},fp=class{constructor({prefix:r="oidc.",store:n=localStorage}={}){this._logger=new Se("WebStorageStateStore"),this._store=n,this._prefix=r}async set(r,n){this._logger.create(`set('${r}')`),r=this._prefix+r,await this._store.setItem(r,n)}async get(r){return this._logger.create(`get('${r}')`),r=this._prefix+r,await this._store.getItem(r)}async remove(r){this._logger.create(`remove('${r}')`),r=this._prefix+r;const n=await this._store.getItem(r);return await this._store.removeItem(r),n}async getAllKeys(){this._logger.create("getAllKeys");const r=await this._store.length,n=[];for(let s=0;s{const a=this._logger.create("_getClaimsFromJwt");try{const c=Ms.decode(s);return a.debug("JWT decoding successful"),c}catch(c){throw a.error("Error parsing JWT response"),c}},this._jsonService=new qu(void 0,this._getClaimsFromJwt,this._settings.extraHeaders)}async getClaims(r){const n=this._logger.create("getClaims");r||this._logger.throw(new Error("No token passed"));const s=await this._metadataService.getUserInfoEndpoint();n.debug("got userinfo url",s);const a=await this._jsonService.getJson(s,{token:r,credentials:this._settings.fetchRequestCredentials,timeoutInSeconds:this._settings.requestTimeoutInSeconds});return n.debug("got claims",a),a}},hp=class{constructor(r,n){this._settings=r,this._metadataService=n,this._logger=new Se("TokenClient"),this._jsonService=new qu(this._settings.revokeTokenAdditionalContentTypes,null,this._settings.extraHeaders)}async exchangeCode({grant_type:r="authorization_code",redirect_uri:n=this._settings.redirect_uri,client_id:s=this._settings.client_id,client_secret:a=this._settings.client_secret,extraHeaders:c,...f}){const p=this._logger.create("exchangeCode");s||p.throw(new Error("A client_id is required")),n||p.throw(new Error("A redirect_uri is required")),f.code||p.throw(new Error("A code is required"));const v=new URLSearchParams({grant_type:r,redirect_uri:n});for(const[N,j]of Object.entries(f))j!=null&&v.set(N,j);if((this._settings.client_authentication==="client_secret_basic"||this._settings.client_authentication==="client_secret_jwt")&&a==null)throw p.throw(new Error("A client_secret is required")),null;let y;const x=await this._metadataService.getTokenEndpoint(!1);switch(this._settings.client_authentication){case"client_secret_basic":y=Je.generateBasicAuth(s,a);break;case"client_secret_post":v.append("client_id",s),a&&v.append("client_secret",a);break;case"client_secret_jwt":{const N=await Je.generateClientAssertionJwt(s,a,x,this._settings.token_endpoint_auth_signing_alg);v.append("client_id",s),v.append("client_assertion_type","urn:ietf:params:oauth:client-assertion-type:jwt-bearer"),v.append("client_assertion",N);break}}p.debug("got token endpoint");const R=await this._jsonService.postForm(x,{body:v,basicAuth:y,timeoutInSeconds:this._settings.requestTimeoutInSeconds,initCredentials:this._settings.fetchRequestCredentials,extraHeaders:c});return p.debug("got response"),R}async exchangeCredentials({grant_type:r="password",client_id:n=this._settings.client_id,client_secret:s=this._settings.client_secret,scope:a=this._settings.scope,...c}){const f=this._logger.create("exchangeCredentials");n||f.throw(new Error("A client_id is required"));const p=new URLSearchParams({grant_type:r});this._settings.omitScopeWhenRequesting||p.set("scope",a);for(const[R,N]of Object.entries(c))N!=null&&p.set(R,N);if((this._settings.client_authentication==="client_secret_basic"||this._settings.client_authentication==="client_secret_jwt")&&s==null)throw f.throw(new Error("A client_secret is required")),null;let v;const y=await this._metadataService.getTokenEndpoint(!1);switch(this._settings.client_authentication){case"client_secret_basic":v=Je.generateBasicAuth(n,s);break;case"client_secret_post":p.append("client_id",n),s&&p.append("client_secret",s);break;case"client_secret_jwt":{const R=await Je.generateClientAssertionJwt(n,s,y,this._settings.token_endpoint_auth_signing_alg);p.append("client_id",n),p.append("client_assertion_type","urn:ietf:params:oauth:client-assertion-type:jwt-bearer"),p.append("client_assertion",R);break}}f.debug("got token endpoint");const x=await this._jsonService.postForm(y,{body:p,basicAuth:v,timeoutInSeconds:this._settings.requestTimeoutInSeconds,initCredentials:this._settings.fetchRequestCredentials});return f.debug("got response"),x}async exchangeRefreshToken({grant_type:r="refresh_token",client_id:n=this._settings.client_id,client_secret:s=this._settings.client_secret,timeoutInSeconds:a,extraHeaders:c,...f}){const p=this._logger.create("exchangeRefreshToken");n||p.throw(new Error("A client_id is required")),f.refresh_token||p.throw(new Error("A refresh_token is required"));const v=new URLSearchParams({grant_type:r});for(const[N,j]of Object.entries(f))Array.isArray(j)?j.forEach(O=>v.append(N,O)):j!=null&&v.set(N,j);if((this._settings.client_authentication==="client_secret_basic"||this._settings.client_authentication==="client_secret_jwt")&&s==null)throw p.throw(new Error("A client_secret is required")),null;let y;const x=await this._metadataService.getTokenEndpoint(!1);switch(this._settings.client_authentication){case"client_secret_basic":y=Je.generateBasicAuth(n,s);break;case"client_secret_post":v.append("client_id",n),s&&v.append("client_secret",s);break;case"client_secret_jwt":{const N=await Je.generateClientAssertionJwt(n,s,x,this._settings.token_endpoint_auth_signing_alg);v.append("client_id",n),v.append("client_assertion_type","urn:ietf:params:oauth:client-assertion-type:jwt-bearer"),v.append("client_assertion",N);break}}p.debug("got token endpoint");const R=await this._jsonService.postForm(x,{body:v,basicAuth:y,timeoutInSeconds:a,initCredentials:this._settings.fetchRequestCredentials,extraHeaders:c});return p.debug("got response"),R}async revoke(r){var n;const s=this._logger.create("revoke");r.token||s.throw(new Error("A token is required"));const a=await this._metadataService.getRevocationEndpoint(!1);s.debug(`got revocation endpoint, revoking ${(n=r.token_type_hint)!=null?n:"default token type"}`);const c=new URLSearchParams;for(const[f,p]of Object.entries(r))p!=null&&c.set(f,p);c.set("client_id",this._settings.client_id),this._settings.client_secret&&c.set("client_secret",this._settings.client_secret),await this._jsonService.postForm(a,{body:c,timeoutInSeconds:this._settings.requestTimeoutInSeconds}),s.debug("got response")}},O_=class{constructor(r,n,s){this._settings=r,this._metadataService=n,this._claimsService=s,this._logger=new Se("ResponseValidator"),this._userInfoService=new j_(this._settings,this._metadataService),this._tokenClient=new hp(this._settings,this._metadataService)}async validateSigninResponse(r,n,s){const a=this._logger.create("validateSigninResponse");this._processSigninState(r,n),a.debug("state processed"),await this._processCode(r,n,s),a.debug("code processed"),r.isOpenId&&this._validateIdTokenAttributes(r,"",n.nonce),a.debug("tokens validated"),await this._processClaims(r,n?.skipUserInfo,r.isOpenId),a.debug("claims processed")}async validateCredentialsResponse(r,n){const s=this._logger.create("validateCredentialsResponse"),a=r.isOpenId&&!!r.id_token;a&&this._validateIdTokenAttributes(r),s.debug("tokens validated"),await this._processClaims(r,n,a),s.debug("claims processed")}async validateRefreshResponse(r,n){var s,a;const c=this._logger.create("validateRefreshResponse");r.userState=n.data,(s=r.session_state)!=null||(r.session_state=n.session_state),(a=r.scope)!=null||(r.scope=n.scope),r.isOpenId&&r.id_token&&(this._validateIdTokenAttributes(r,n.id_token),c.debug("ID Token validated")),r.id_token||(r.id_token=n.id_token,r.profile=n.profile);const f=r.isOpenId&&!!r.id_token;await this._processClaims(r,!1,f),c.debug("claims processed")}validateSignoutResponse(r,n){const s=this._logger.create("validateSignoutResponse");if(n.id!==r.state&&s.throw(new Error("State does not match")),s.debug("state validated"),r.userState=n.data,r.error)throw s.warn("Response was error",r.error),new vn(r)}_processSigninState(r,n){var s;const a=this._logger.create("_processSigninState");if(n.id!==r.state&&a.throw(new Error("State does not match")),n.client_id||a.throw(new Error("No client_id on state")),n.authority||a.throw(new Error("No authority on state")),this._settings.authority!==n.authority&&a.throw(new Error("authority mismatch on settings vs. signin state")),this._settings.client_id&&this._settings.client_id!==n.client_id&&a.throw(new Error("client_id mismatch on settings vs. signin state")),a.debug("state validated"),r.userState=n.data,r.url_state=n.url_state,(s=r.scope)!=null||(r.scope=n.scope),r.error)throw a.warn("Response was error",r.error),new vn(r);n.code_verifier&&!r.code&&a.throw(new Error("Expected code in response"))}async _processClaims(r,n=!1,s=!0){const a=this._logger.create("_processClaims");if(r.profile=this._claimsService.filterProtocolClaims(r.profile),n||!this._settings.loadUserInfo||!r.access_token){a.debug("not loading user info");return}a.debug("loading user info");const c=await this._userInfoService.getClaims(r.access_token);a.debug("user info claims received from user info endpoint"),s&&c.sub!==r.profile.sub&&a.throw(new Error("subject from UserInfo response does not match subject in ID Token")),r.profile=this._claimsService.mergeClaims(r.profile,this._claimsService.filterProtocolClaims(c)),a.debug("user info claims received, updated profile:",r.profile)}async _processCode(r,n,s){const a=this._logger.create("_processCode");if(r.code){a.debug("Validating code");const c=await this._tokenClient.exchangeCode({client_id:n.client_id,client_secret:n.client_secret,code:r.code,redirect_uri:n.redirect_uri,code_verifier:n.code_verifier,extraHeaders:s,...n.extraTokenParams});Object.assign(r,c)}else a.debug("No code to process")}_validateIdTokenAttributes(r,n,s){var a;const c=this._logger.create("_validateIdTokenAttributes");c.debug("decoding ID Token JWT");const f=Ms.decode((a=r.id_token)!=null?a:"");if(f.sub||c.throw(new Error("ID Token is missing a subject claim")),s&&f.nonce!==s&&c.throw(new Error("nonce in id_token does not match nonce in client storage")),n){const p=Ms.decode(n);f.sub!==p.sub&&c.throw(new Error("sub in id_token does not match current sub")),f.auth_time&&f.auth_time!==p.auth_time&&c.throw(new Error("auth_time in id_token does not match original auth_time")),f.azp&&f.azp!==p.azp&&c.throw(new Error("azp in id_token does not match original azp")),!f.azp&&p.azp&&c.throw(new Error("azp not in id_token, but present in original id_token"))}r.profile=f}},pa=class Pu{constructor(n){this.id=n.id||Je.generateUUIDv4(),this.data=n.data,n.created&&n.created>0?this.created=n.created:this.created=gr.getEpochTime(),this.request_type=n.request_type,this.url_state=n.url_state}toStorageString(){return new Se("State").create("toStorageString"),JSON.stringify({id:this.id,data:this.data,created:this.created,request_type:this.request_type,url_state:this.url_state})}static fromStorageString(n){return Se.createStatic("State","fromStorageString"),Promise.resolve(new Pu(JSON.parse(n)))}static async clearStaleState(n,s){const a=Se.createStatic("State","clearStaleState"),c=gr.getEpochTime()-s,f=await n.getAllKeys();a.debug("got keys",f);for(let p=0;pY.searchParams.append("resource",ue));for(const[me,ue]of Object.entries({response_mode:y,...L,...Q}))ue!=null&&Y.searchParams.append(me,ue.toString());return new mp({url:Y.href,state:J})}};gp._logger=new Se("SigninRequest");var D_=gp,z_="openid",uu=class{constructor(r){if(this.access_token="",this.token_type="",this.profile={},this.state=r.get("state"),this.session_state=r.get("session_state"),this.state){const n=decodeURIComponent(this.state).split(Ti);this.state=n[0],n.length>1&&(this.url_state=n.slice(1).join(Ti))}this.error=r.get("error"),this.error_description=r.get("error_description"),this.error_uri=r.get("error_uri"),this.code=r.get("code")}get expires_in(){if(this.expires_at!==void 0)return this.expires_at-gr.getEpochTime()}set expires_in(r){typeof r=="string"&&(r=Number(r)),r!==void 0&&r>=0&&(this.expires_at=Math.floor(r)+gr.getEpochTime())}get isOpenId(){var r;return((r=this.scope)==null?void 0:r.split(" ").includes(z_))||!!this.id_token}},F_=class{constructor({url:r,state_data:n,id_token_hint:s,post_logout_redirect_uri:a,extraQueryParams:c,request_type:f,client_id:p,url_state:v}){if(this._logger=new Se("SignoutRequest"),!r)throw this._logger.error("ctor: No url passed"),new Error("url");const y=new URL(r);if(s&&y.searchParams.append("id_token_hint",s),p&&y.searchParams.append("client_id",p),a&&(y.searchParams.append("post_logout_redirect_uri",a),n||v)){this.state=new pa({data:n,request_type:f,url_state:v});let x=this.state.id;v&&(x=`${x}${Ti}${v}`),y.searchParams.append("state",x)}for(const[x,R]of Object.entries({...c}))R!=null&&y.searchParams.append(x,R.toString());this.url=y.href}},$_=class{constructor(r){if(this.state=r.get("state"),this.state){const n=decodeURIComponent(this.state).split(Ti);this.state=n[0],n.length>1&&(this.url_state=n.slice(1).join(Ti))}this.error=r.get("error"),this.error_description=r.get("error_description"),this.error_uri=r.get("error_uri")}},L_=["nbf","jti","auth_time","nonce","acr","amr","azp","at_hash"],V_=["sub","iss","aud","exp","iat"],q_=class{constructor(r){this._settings=r,this._logger=new Se("ClaimsService")}filterProtocolClaims(r){const n={...r};if(this._settings.filterProtocolClaims){let s;Array.isArray(this._settings.filterProtocolClaims)?s=this._settings.filterProtocolClaims:s=L_;for(const a of s)V_.includes(a)||delete n[a]}return n}mergeClaims(r,n){const s={...r};for(const[a,c]of Object.entries(n))if(s[a]!==c)if(Array.isArray(s[a])||Array.isArray(c))if(this._settings.mergeClaimsStrategy.array=="replace")s[a]=c;else{const f=Array.isArray(s[a])?s[a]:[s[a]];for(const p of Array.isArray(c)?c:[c])f.includes(p)||f.push(p);s[a]=f}else typeof s[a]=="object"&&typeof c=="object"?s[a]=this.mergeClaims(s[a],c):s[a]=c;return s}},yp=class{constructor(r,n){this.keys=r,this.nonce=n}},H_=class{constructor(r,n){this._logger=new Se("OidcClient"),this.settings=r instanceof Nu?r:new Nu(r),this.metadataService=n??new N_(this.settings),this._claimsService=new q_(this.settings),this._validator=new O_(this.settings,this.metadataService,this._claimsService),this._tokenClient=new hp(this.settings,this.metadataService)}async createSigninRequest({state:r,request:n,request_uri:s,request_type:a,id_token_hint:c,login_hint:f,skipUserInfo:p,nonce:v,url_state:y,response_type:x=this.settings.response_type,scope:R=this.settings.scope,redirect_uri:N=this.settings.redirect_uri,prompt:j=this.settings.prompt,display:O=this.settings.display,max_age:q=this.settings.max_age,ui_locales:Q=this.settings.ui_locales,acr_values:$=this.settings.acr_values,resource:fe=this.settings.resource,response_mode:T=this.settings.response_mode,extraQueryParams:A=this.settings.extraQueryParams,extraTokenParams:L=this.settings.extraTokenParams,dpopJkt:J,omitScopeWhenRequesting:Y=this.settings.omitScopeWhenRequesting}){const ge=this._logger.create("createSigninRequest");if(x!=="code")throw new Error("Only the Authorization Code flow (with PKCE) is supported");const me=await this.metadataService.getAuthorizationEndpoint();ge.debug("Received authorization endpoint",me);const ue=await D_.create({url:me,authority:this.settings.authority,client_id:this.settings.client_id,redirect_uri:N,response_type:x,scope:R,state_data:r,url_state:y,prompt:j,display:O,max_age:q,ui_locales:Q,id_token_hint:c,login_hint:f,acr_values:$,dpopJkt:J,resource:fe,request:n,request_uri:s,extraQueryParams:A,extraTokenParams:L,request_type:a,response_mode:T,client_secret:this.settings.client_secret,skipUserInfo:p,nonce:v,disablePKCE:this.settings.disablePKCE,omitScopeWhenRequesting:Y});await this.clearStaleState();const Re=ue.state;return await this.settings.stateStore.set(Re.id,Re.toStorageString()),ue}async readSigninResponseState(r,n=!1){const s=this._logger.create("readSigninResponseState"),a=new uu(Uu.readParams(r,this.settings.response_mode));if(!a.state)throw s.throw(new Error("No state in response")),null;const c=await this.settings.stateStore[n?"remove":"get"](a.state);if(!c)throw s.throw(new Error("No matching state found in storage")),null;return{state:await pp.fromStorageString(c),response:a}}async processSigninResponse(r,n,s=!0){const a=this._logger.create("processSigninResponse"),{state:c,response:f}=await this.readSigninResponseState(r,s);if(a.debug("received state from storage; validating response"),this.settings.dpop&&this.settings.dpop.store){const p=await this.getDpopProof(this.settings.dpop.store);n={...n,DPoP:p}}try{await this._validator.validateSigninResponse(f,c,n)}catch(p){if(p instanceof Ru&&this.settings.dpop){const v=await this.getDpopProof(this.settings.dpop.store,p.nonce);n.DPoP=v,await this._validator.validateSigninResponse(f,c,n)}else throw p}return f}async getDpopProof(r,n){let s,a;return(await r.getAllKeys()).includes(this.settings.client_id)?(a=await r.get(this.settings.client_id),a.nonce!==n&&n&&(a.nonce=n,await r.set(this.settings.client_id,a))):(s=await Je.generateDPoPKeys(),a=new yp(s,n),await r.set(this.settings.client_id,a)),await Je.generateDPoPProof({url:await this.metadataService.getTokenEndpoint(!1),httpMethod:"POST",keyPair:a.keys,nonce:a.nonce})}async processResourceOwnerPasswordCredentials({username:r,password:n,skipUserInfo:s=!1,extraTokenParams:a={}}){const c=await this._tokenClient.exchangeCredentials({username:r,password:n,...a}),f=new uu(new URLSearchParams);return Object.assign(f,c),await this._validator.validateCredentialsResponse(f,s),f}async useRefreshToken({state:r,redirect_uri:n,resource:s,timeoutInSeconds:a,extraHeaders:c,extraTokenParams:f}){var p;const v=this._logger.create("useRefreshToken");let y;if(this.settings.refreshTokenAllowedScope===void 0)y=r.scope;else{const N=this.settings.refreshTokenAllowedScope.split(" ");y=(((p=r.scope)==null?void 0:p.split(" "))||[]).filter(O=>N.includes(O)).join(" ")}if(this.settings.dpop&&this.settings.dpop.store){const N=await this.getDpopProof(this.settings.dpop.store);c={...c,DPoP:N}}let x;try{x=await this._tokenClient.exchangeRefreshToken({refresh_token:r.refresh_token,scope:y,redirect_uri:n,resource:s,timeoutInSeconds:a,extraHeaders:c,...f})}catch(N){if(N instanceof Ru&&this.settings.dpop)c.DPoP=await this.getDpopProof(this.settings.dpop.store,N.nonce),x=await this._tokenClient.exchangeRefreshToken({refresh_token:r.refresh_token,scope:y,redirect_uri:n,resource:s,timeoutInSeconds:a,extraHeaders:c,...f});else throw N}const R=new uu(new URLSearchParams);return Object.assign(R,x),v.debug("validating response",R),await this._validator.validateRefreshResponse(R,{...r,scope:y}),R}async createSignoutRequest({state:r,id_token_hint:n,client_id:s,request_type:a,url_state:c,post_logout_redirect_uri:f=this.settings.post_logout_redirect_uri,extraQueryParams:p=this.settings.extraQueryParams}={}){const v=this._logger.create("createSignoutRequest"),y=await this.metadataService.getEndSessionEndpoint();if(!y)throw v.throw(new Error("No end session endpoint")),null;v.debug("Received end session endpoint",y),!s&&f&&!n&&(s=this.settings.client_id);const x=new F_({url:y,id_token_hint:n,client_id:s,post_logout_redirect_uri:f,state_data:r,extraQueryParams:p,request_type:a,url_state:c});await this.clearStaleState();const R=x.state;return R&&(v.debug("Signout request has state to persist"),await this.settings.stateStore.set(R.id,R.toStorageString())),x}async readSignoutResponseState(r,n=!1){const s=this._logger.create("readSignoutResponseState"),a=new $_(Uu.readParams(r,this.settings.response_mode));if(!a.state){if(s.debug("No state in response"),a.error)throw s.warn("Response was error:",a.error),new vn(a);return{state:void 0,response:a}}const c=await this.settings.stateStore[n?"remove":"get"](a.state);if(!c)throw s.throw(new Error("No matching state found in storage")),null;return{state:await pa.fromStorageString(c),response:a}}async processSignoutResponse(r){const n=this._logger.create("processSignoutResponse"),{state:s,response:a}=await this.readSignoutResponseState(r,!0);return s?(n.debug("Received state from storage; validating response"),this._validator.validateSignoutResponse(a,s)):n.debug("No state from storage; skipping response validation"),a}clearStaleState(){return this._logger.create("clearStaleState"),pa.clearStaleState(this.settings.stateStore,this.settings.staleStateAgeInSeconds)}async revokeToken(r,n){return this._logger.create("revokeToken"),await this._tokenClient.revoke({token:r,token_type_hint:n})}},K_=class{constructor(r){this._userManager=r,this._logger=new Se("SessionMonitor"),this._start=async n=>{const s=n.session_state;if(!s)return;const a=this._logger.create("_start");if(n.profile?(this._sub=n.profile.sub,a.debug("session_state",s,", sub",this._sub)):(this._sub=void 0,a.debug("session_state",s,", anonymous user")),this._checkSessionIFrame){this._checkSessionIFrame.start(s);return}try{const c=await this._userManager.metadataService.getCheckSessionIframe();if(c){a.debug("initializing check session iframe");const f=this._userManager.settings.client_id,p=this._userManager.settings.checkSessionIntervalInSeconds,v=this._userManager.settings.stopCheckSessionOnError,y=new R_(this._callback,f,c,p,v);await y.load(),this._checkSessionIFrame=y,y.start(s)}else a.warn("no check session iframe found in the metadata")}catch(c){a.error("Error from getCheckSessionIframe:",c instanceof Error?c.message:c)}},this._stop=()=>{const n=this._logger.create("_stop");if(this._sub=void 0,this._checkSessionIFrame&&this._checkSessionIFrame.stop(),this._userManager.settings.monitorAnonymousSession){const s=setInterval(async()=>{clearInterval(s);try{const a=await this._userManager.querySessionStatus();if(a){const c={session_state:a.session_state,profile:a.sub?{sub:a.sub}:null};this._start(c)}}catch(a){n.error("error from querySessionStatus",a instanceof Error?a.message:a)}},1e3)}},this._callback=async()=>{const n=this._logger.create("_callback");try{const s=await this._userManager.querySessionStatus();let a=!0;s&&this._checkSessionIFrame?s.sub===this._sub?(a=!1,this._checkSessionIFrame.start(s.session_state),n.debug("same sub still logged in at OP, session state has changed, restarting check session iframe; session_state",s.session_state),await this._userManager.events._raiseUserSessionChanged()):n.debug("different subject signed into OP",s.sub):n.debug("subject no longer signed into OP"),a?this._sub?await this._userManager.events._raiseUserSignedOut():await this._userManager.events._raiseUserSignedIn():n.debug("no change in session detected, no event to raise")}catch(s){this._sub&&(n.debug("Error calling queryCurrentSigninSession; raising signed out event",s),await this._userManager.events._raiseUserSignedOut())}},r||this._logger.throw(new Error("No user manager passed")),this._userManager.events.addUserLoaded(this._start),this._userManager.events.addUserUnloaded(this._stop),this._init().catch(n=>{this._logger.error(n)})}async _init(){this._logger.create("_init");const r=await this._userManager.getUser();if(r)this._start(r);else if(this._userManager.settings.monitorAnonymousSession){const n=await this._userManager.querySessionStatus();if(n){const s={session_state:n.session_state,profile:n.sub?{sub:n.sub}:null};this._start(s)}}}},cu=class wp{constructor(n){var s;this.id_token=n.id_token,this.session_state=(s=n.session_state)!=null?s:null,this.access_token=n.access_token,this.refresh_token=n.refresh_token,this.token_type=n.token_type,this.scope=n.scope,this.profile=n.profile,this.expires_at=n.expires_at,this.state=n.userState,this.url_state=n.url_state}get expires_in(){if(this.expires_at!==void 0)return this.expires_at-gr.getEpochTime()}set expires_in(n){n!==void 0&&(this.expires_at=Math.floor(n)+gr.getEpochTime())}get expired(){const n=this.expires_in;if(n!==void 0)return n<=0}get scopes(){var n,s;return(s=(n=this.scope)==null?void 0:n.split(" "))!=null?s:[]}toStorageString(){return new Se("User").create("toStorageString"),JSON.stringify({id_token:this.id_token,session_state:this.session_state,access_token:this.access_token,refresh_token:this.refresh_token,token_type:this.token_type,scope:this.scope,profile:this.profile,expires_at:this.expires_at})}static fromStorageString(n){return Se.createStatic("User","fromStorageString"),new wp(JSON.parse(n))}},fh="oidc-client",vp=class{constructor(){this._abort=new Or("Window navigation aborted"),this._disposeHandlers=new Set,this._window=null}async navigate(r){const n=this._logger.create("navigate");if(!this._window)throw new Error("Attempted to navigate on a disposed window");n.debug("setting URL in window"),this._window.location.replace(r.url);const{url:s,keepOpen:a}=await new Promise((c,f)=>{const p=y=>{var x;const R=y.data,N=(x=r.scriptOrigin)!=null?x:window.location.origin;if(!(y.origin!==N||R?.source!==fh)){try{const j=Uu.readParams(R.url,r.response_mode).get("state");if(j||n.warn("no state found in response url"),y.source!==this._window&&j!==r.state)return}catch{this._dispose(),f(new Error("Invalid response from window"))}c(R)}};window.addEventListener("message",p,!1),this._disposeHandlers.add(()=>window.removeEventListener("message",p,!1));const v=new BroadcastChannel(`oidc-client-popup-${r.state}`);v.addEventListener("message",p,!1),this._disposeHandlers.add(()=>v.close()),this._disposeHandlers.add(this._abort.addHandler(y=>{this._dispose(),f(y)}))});return n.debug("got response from window"),this._dispose(),a||this.close(),{url:s}}_dispose(){this._logger.create("_dispose");for(const r of this._disposeHandlers)r();this._disposeHandlers.clear()}static _notifyParent(r,n,s=!1,a=window.location.origin){const c={source:fh,url:n,keepOpen:s},f=new Se("_notifyParent");if(r)f.debug("With parent. Using parent.postMessage."),r.postMessage(c,a);else{f.debug("No parent. Using BroadcastChannel.");const p=new URL(n).searchParams.get("state");if(!p)throw new Error("No parent and no state in URL. Can't complete notification.");const v=new BroadcastChannel(`oidc-client-popup-${p}`);v.postMessage(c),v.close()}}},_p={location:!1,toolbar:!1,height:640,closePopupWindowAfterInSeconds:-1},Sp="_blank",W_=60,Q_=2,xp=10,J_=class extends Nu{constructor(r){const{popup_redirect_uri:n=r.redirect_uri,popup_post_logout_redirect_uri:s=r.post_logout_redirect_uri,popupWindowFeatures:a=_p,popupWindowTarget:c=Sp,redirectMethod:f="assign",redirectTarget:p="self",iframeNotifyParentOrigin:v=r.iframeNotifyParentOrigin,iframeScriptOrigin:y=r.iframeScriptOrigin,requestTimeoutInSeconds:x,silent_redirect_uri:R=r.redirect_uri,silentRequestTimeoutInSeconds:N,automaticSilentRenew:j=!0,validateSubOnSilentRenew:O=!0,includeIdTokenInSilentRenew:q=!1,monitorSession:Q=!1,monitorAnonymousSession:$=!1,checkSessionIntervalInSeconds:fe=Q_,query_status_response_type:T="code",stopCheckSessionOnError:A=!0,revokeTokenTypes:L=["access_token","refresh_token"],revokeTokensOnSignout:J=!1,includeIdTokenInSilentSignout:Y=!1,accessTokenExpiringNotificationTimeInSeconds:ge=W_,maxSilentRenewTimeoutRetries:me,userStore:ue}=r;if(super(r),this.popup_redirect_uri=n,this.popup_post_logout_redirect_uri=s,this.popupWindowFeatures=a,this.popupWindowTarget=c,this.redirectMethod=f,this.redirectTarget=p,this.iframeNotifyParentOrigin=v,this.iframeScriptOrigin=y,this.silent_redirect_uri=R,this.silentRequestTimeoutInSeconds=N||x||xp,this.automaticSilentRenew=j,this.validateSubOnSilentRenew=O,this.includeIdTokenInSilentRenew=q,this.monitorSession=Q,this.monitorAnonymousSession=$,this.checkSessionIntervalInSeconds=fe,this.stopCheckSessionOnError=A,this.query_status_response_type=T,this.revokeTokenTypes=L,this.revokeTokensOnSignout=J,this.includeIdTokenInSilentSignout=Y,this.accessTokenExpiringNotificationTimeInSeconds=ge,this.maxSilentRenewTimeoutRetries=me,ue)this.userStore=ue;else{const Re=typeof window<"u"?window.sessionStorage:new dp;this.userStore=new fp({store:Re})}}},hh=class Ip extends vp{constructor({silentRequestTimeoutInSeconds:n=xp}){super(),this._logger=new Se("IFrameWindow"),this._timeoutInSeconds=n,this._frame=Ip.createHiddenIframe(),this._window=this._frame.contentWindow}static createHiddenIframe(){const n=window.document.createElement("iframe");return n.style.visibility="hidden",n.style.position="fixed",n.style.left="-1000px",n.style.top="0",n.width="0",n.height="0",window.document.body.appendChild(n),n}async navigate(n){this._logger.debug("navigate: Using timeout of:",this._timeoutInSeconds);const s=setTimeout(()=>{this._abort.raise(new Vu("IFrame timed out without a response"))},this._timeoutInSeconds*1e3);return this._disposeHandlers.add(()=>clearTimeout(s)),await super.navigate(n)}close(){var n;this._frame&&(this._frame.parentNode&&(this._frame.addEventListener("load",s=>{var a;const c=s.target;(a=c.parentNode)==null||a.removeChild(c),this._abort.raise(new Error("IFrame removed from DOM"))},!0),(n=this._frame.contentWindow)==null||n.location.replace("about:blank")),this._frame=null),this._window=null}static notifyParent(n,s){return super._notifyParent(window.parent,n,!1,s)}},G_=class{constructor(r){this._settings=r,this._logger=new Se("IFrameNavigator")}async prepare({silentRequestTimeoutInSeconds:r=this._settings.silentRequestTimeoutInSeconds}){return new hh({silentRequestTimeoutInSeconds:r})}async callback(r){this._logger.create("callback"),hh.notifyParent(r,this._settings.iframeNotifyParentOrigin)}},X_=500,Y_=1e3,ph=class extends vp{constructor({popupWindowTarget:r=Sp,popupWindowFeatures:n={},popupSignal:s,popupAbortOnClose:a}){super(),this._logger=new Se("PopupWindow");const c=dh.center({..._p,...n});this._window=window.open(void 0,r,dh.serialize(c)),this.abortOnClose=!!a,s&&s.addEventListener("abort",()=>{var f;this._abort.raise(new Error((f=s.reason)!=null?f:"Popup aborted"))}),n.closePopupWindowAfterInSeconds&&n.closePopupWindowAfterInSeconds>0&&setTimeout(()=>{if(!this._window||typeof this._window.closed!="boolean"||this._window.closed){this._abort.raise(new Error("Popup blocked by user"));return}this.close()},n.closePopupWindowAfterInSeconds*Y_)}async navigate(r){var n;(n=this._window)==null||n.focus();const s=setInterval(()=>{(!this._window||this._window.closed)&&(this._logger.debug("Popup closed by user or isolated by redirect"),a(),this._disposeHandlers.delete(a),this.abortOnClose&&this._abort.raise(new Error("Popup closed by user")))},X_),a=()=>clearInterval(s);return this._disposeHandlers.add(a),await super.navigate(r)}close(){this._window&&(this._window.closed||(this._window.close(),this._abort.raise(new Error("Popup closed")))),this._window=null}static notifyOpener(r,n){super._notifyParent(window.opener,r,n),!n&&!window.opener&&window.close()}},Z_=class{constructor(r){this._settings=r,this._logger=new Se("PopupNavigator")}async prepare({popupWindowFeatures:r=this._settings.popupWindowFeatures,popupWindowTarget:n=this._settings.popupWindowTarget,popupSignal:s,popupAbortOnClose:a}){return new ph({popupWindowFeatures:r,popupWindowTarget:n,popupSignal:s,popupAbortOnClose:a})}async callback(r,{keepOpen:n=!1}){this._logger.create("callback"),ph.notifyOpener(r,n)}},eS=class{constructor(r){this._settings=r,this._logger=new Se("RedirectNavigator")}async prepare({redirectMethod:r=this._settings.redirectMethod,redirectTarget:n=this._settings.redirectTarget}){var s;this._logger.create("prepare");let a=window.self;n==="top"&&(a=(s=window.top)!=null?s:window.self);const c=a.location[r].bind(a.location);let f;return{navigate:async p=>(this._logger.create("navigate"),await new Promise((y,x)=>{f=x,window.addEventListener("pageshow",()=>y(window.location.href)),c(p.url)})),close:()=>{this._logger.create("close"),f?.(new Error("Redirect aborted")),a.stop()}}}async callback(){}},tS=class extends U_{constructor(r){super({expiringNotificationTimeInSeconds:r.accessTokenExpiringNotificationTimeInSeconds}),this._logger=new Se("UserManagerEvents"),this._userLoaded=new Or("User loaded"),this._userUnloaded=new Or("User unloaded"),this._silentRenewError=new Or("Silent renew error"),this._userSignedIn=new Or("User signed in"),this._userSignedOut=new Or("User signed out"),this._userSessionChanged=new Or("User session changed")}async load(r,n=!0){await super.load(r),n&&await this._userLoaded.raise(r)}async unload(){await super.unload(),await this._userUnloaded.raise()}addUserLoaded(r){return this._userLoaded.addHandler(r)}removeUserLoaded(r){return this._userLoaded.removeHandler(r)}addUserUnloaded(r){return this._userUnloaded.addHandler(r)}removeUserUnloaded(r){return this._userUnloaded.removeHandler(r)}addSilentRenewError(r){return this._silentRenewError.addHandler(r)}removeSilentRenewError(r){return this._silentRenewError.removeHandler(r)}async _raiseSilentRenewError(r){await this._silentRenewError.raise(r)}addUserSignedIn(r){return this._userSignedIn.addHandler(r)}removeUserSignedIn(r){this._userSignedIn.removeHandler(r)}async _raiseUserSignedIn(){await this._userSignedIn.raise()}addUserSignedOut(r){return this._userSignedOut.addHandler(r)}removeUserSignedOut(r){this._userSignedOut.removeHandler(r)}async _raiseUserSignedOut(){await this._userSignedOut.raise()}addUserSessionChanged(r){return this._userSessionChanged.addHandler(r)}removeUserSessionChanged(r){this._userSessionChanged.removeHandler(r)}async _raiseUserSessionChanged(){await this._userSessionChanged.raise()}},rS=class{constructor(r){this._userManager=r,this._logger=new Se("SilentRenewService"),this._isStarted=!1,this._retryTimer=new gr("Retry Silent Renew"),this._timeoutRetryCount=0,this._tokenExpiring=async()=>{const n=this._logger.create("_tokenExpiring");try{await this._userManager.signinSilent(),this._timeoutRetryCount=0,n.debug("silent token renewal successful")}catch(s){if(s instanceof Vu){this._timeoutRetryCount++;const a=this._userManager.settings.maxSilentRenewTimeoutRetries;if(a!==void 0&&this._timeoutRetryCount>a){n.error(`Timeout retry limit reached (${this._timeoutRetryCount} > ${a}), raising silentRenewError:`,s),this._timeoutRetryCount=0,await this._userManager.events._raiseSilentRenewError(s);return}n.warn(`ErrorTimeout from signinSilent (attempt ${this._timeoutRetryCount}), retry in 5s:`,s),this._retryTimer.init(5);return}n.error("Error from signinSilent:",s),this._timeoutRetryCount=0,await this._userManager.events._raiseSilentRenewError(s)}}}async start(){const r=this._logger.create("start");if(!this._isStarted){this._isStarted=!0,this._userManager.events.addAccessTokenExpiring(this._tokenExpiring),this._retryTimer.addHandler(this._tokenExpiring);try{await this._userManager.getUser()}catch(n){r.error("getUser error",n)}}}stop(){this._isStarted&&(this._retryTimer.cancel(),this._retryTimer.removeHandler(this._tokenExpiring),this._userManager.events.removeAccessTokenExpiring(this._tokenExpiring),this._isStarted=!1)}},nS=class{constructor(r){this.refresh_token=r.refresh_token,this.id_token=r.id_token,this.session_state=r.session_state,this.scope=r.scope,this.profile=r.profile,this.data=r.state}},iS=class{constructor(r,n,s,a){this._logger=new Se("UserManager"),this.settings=new J_(r),this._client=new H_(r),this._redirectNavigator=n??new eS(this.settings),this._popupNavigator=s??new Z_(this.settings),this._iframeNavigator=a??new G_(this.settings),this._events=new tS(this.settings),this._silentRenewService=new rS(this),this.settings.automaticSilentRenew&&this.startSilentRenew(),this._sessionMonitor=null,this.settings.monitorSession&&(this._sessionMonitor=new K_(this))}get events(){return this._events}get metadataService(){return this._client.metadataService}async getUser(r=!1){const n=this._logger.create("getUser"),s=await this._loadUser();return s?(n.info("user loaded"),await this._events.load(s,r),s):(n.info("user not found in storage"),null)}async removeUser(){const r=this._logger.create("removeUser");await this.storeUser(null),r.info("user removed from storage"),await this._events.unload()}async signinRedirect(r={}){var n;this._logger.create("signinRedirect");const{redirectMethod:s,...a}=r;let c;(n=this.settings.dpop)!=null&&n.bind_authorization_code&&(c=await this.generateDPoPJkt(this.settings.dpop));const f=await this._redirectNavigator.prepare({redirectMethod:s});await this._signinStart({request_type:"si:r",dpopJkt:c,...a},f)}async signinRedirectCallback(r=window.location.href){const n=this._logger.create("signinRedirectCallback"),s=await this._signinEnd(r);return s.profile&&s.profile.sub?n.info("success, signed in subject",s.profile.sub):n.info("no subject"),s}async signinResourceOwnerCredentials({username:r,password:n,skipUserInfo:s=!1}){const a=this._logger.create("signinResourceOwnerCredential"),c=await this._client.processResourceOwnerPasswordCredentials({username:r,password:n,skipUserInfo:s,extraTokenParams:this.settings.extraTokenParams});a.debug("got signin response");const f=await this._buildUser(c);return f.profile&&f.profile.sub?a.info("success, signed in subject",f.profile.sub):a.info("no subject"),f}async signinPopup(r={}){var n;const s=this._logger.create("signinPopup");let a;(n=this.settings.dpop)!=null&&n.bind_authorization_code&&(a=await this.generateDPoPJkt(this.settings.dpop));const{popupWindowFeatures:c,popupWindowTarget:f,popupSignal:p,popupAbortOnClose:v,...y}=r,x=this.settings.popup_redirect_uri;x||s.throw(new Error("No popup_redirect_uri configured"));const R=await this._popupNavigator.prepare({popupWindowFeatures:c,popupWindowTarget:f,popupSignal:p,popupAbortOnClose:v}),N=await this._signin({request_type:"si:p",redirect_uri:x,display:"popup",dpopJkt:a,...y},R);return N&&(N.profile&&N.profile.sub?s.info("success, signed in subject",N.profile.sub):s.info("no subject")),N}async signinPopupCallback(r=window.location.href,n=!1){const s=this._logger.create("signinPopupCallback");await this._popupNavigator.callback(r,{keepOpen:n}),s.info("success")}async signinSilent(r={}){var n,s;const a=this._logger.create("signinSilent"),{silentRequestTimeoutInSeconds:c,...f}=r;let p=await this._loadUser();if(!r.forceIframeAuth&&p?.refresh_token){a.debug("using refresh token");const N=new nS(p);return await this._useRefreshToken({state:N,redirect_uri:f.redirect_uri,resource:f.resource,extraTokenParams:f.extraTokenParams,timeoutInSeconds:c})}let v;(n=this.settings.dpop)!=null&&n.bind_authorization_code&&(v=await this.generateDPoPJkt(this.settings.dpop));const y=this.settings.silent_redirect_uri;y||a.throw(new Error("No silent_redirect_uri configured"));let x;p&&this.settings.validateSubOnSilentRenew&&(a.debug("subject prior to silent renew:",p.profile.sub),x=p.profile.sub);const R=await this._iframeNavigator.prepare({silentRequestTimeoutInSeconds:c});return p=await this._signin({request_type:"si:s",redirect_uri:y,prompt:"none",id_token_hint:this.settings.includeIdTokenInSilentRenew?p?.id_token:void 0,dpopJkt:v,...f},R,x),p&&((s=p.profile)!=null&&s.sub?a.info("success, signed in subject",p.profile.sub):a.info("no subject")),p}async _useRefreshToken(r){const n=await this._client.useRefreshToken({timeoutInSeconds:this.settings.silentRequestTimeoutInSeconds,...r}),s=new cu({...r.state,...n});return await this.storeUser(s),await this._events.load(s),s}async signinSilentCallback(r=window.location.href){const n=this._logger.create("signinSilentCallback");await this._iframeNavigator.callback(r),n.info("success")}async signinCallback(r=window.location.href){const{state:n}=await this._client.readSigninResponseState(r);switch(n.request_type){case"si:r":return await this.signinRedirectCallback(r);case"si:p":await this.signinPopupCallback(r);break;case"si:s":await this.signinSilentCallback(r);break;default:throw new Error("invalid request_type in state")}}async signoutCallback(r=window.location.href,n=!1){const{state:s}=await this._client.readSignoutResponseState(r);if(s)switch(s.request_type){case"so:r":return await this.signoutRedirectCallback(r);case"so:p":await this.signoutPopupCallback(r,n);break;case"so:s":await this.signoutSilentCallback(r);break;default:throw new Error("invalid request_type in state")}}async querySessionStatus(r={}){const n=this._logger.create("querySessionStatus"),{silentRequestTimeoutInSeconds:s,...a}=r,c=this.settings.silent_redirect_uri;c||n.throw(new Error("No silent_redirect_uri configured"));const f=await this._loadUser(),p=await this._iframeNavigator.prepare({silentRequestTimeoutInSeconds:s}),v=await this._signinStart({request_type:"si:s",redirect_uri:c,prompt:"none",id_token_hint:this.settings.includeIdTokenInSilentRenew?f?.id_token:void 0,response_type:this.settings.query_status_response_type,scope:"openid",skipUserInfo:!0,...a},p);try{const y={},x=await this._client.processSigninResponse(v.url,y);return n.debug("got signin response"),x.session_state&&x.profile.sub?(n.info("success for subject",x.profile.sub),{session_state:x.session_state,sub:x.profile.sub}):(n.info("success, user not authenticated"),null)}catch(y){if(this.settings.monitorAnonymousSession&&y instanceof vn)switch(y.error){case"login_required":case"consent_required":case"interaction_required":case"account_selection_required":return n.info("success for anonymous user"),{session_state:y.session_state}}throw y}}async _signin(r,n,s){const a=await this._signinStart(r,n);return await this._signinEnd(a.url,s)}async _signinStart(r,n){const s=this._logger.create("_signinStart");try{const a=await this._client.createSigninRequest(r);return s.debug("got signin request"),await n.navigate({url:a.url,state:a.state.id,response_mode:a.state.response_mode,scriptOrigin:this.settings.iframeScriptOrigin})}catch(a){throw s.debug("error after preparing navigator, closing navigator window"),n.close(),a}}async _signinEnd(r,n){const s=this._logger.create("_signinEnd"),a={},c=await this._client.processSigninResponse(r,a);return s.debug("got signin response"),await this._buildUser(c,n)}async _buildUser(r,n){const s=this._logger.create("_buildUser"),a=new cu(r);if(n){if(n!==a.profile.sub)throw s.debug("current user does not match user returned from signin. sub from signin:",a.profile.sub),new vn({...r,error:"login_required"});s.debug("current user matches user returned from signin")}return await this.storeUser(a),s.debug("user stored"),await this._events.load(a),a}async signoutRedirect(r={}){const n=this._logger.create("signoutRedirect"),{redirectMethod:s,...a}=r,c=await this._redirectNavigator.prepare({redirectMethod:s});await this._signoutStart({request_type:"so:r",post_logout_redirect_uri:this.settings.post_logout_redirect_uri,...a},c),n.info("success")}async signoutRedirectCallback(r=window.location.href){const n=this._logger.create("signoutRedirectCallback"),s=await this._signoutEnd(r);return n.info("success"),s}async signoutPopup(r={}){const n=this._logger.create("signoutPopup"),{popupWindowFeatures:s,popupWindowTarget:a,popupSignal:c,...f}=r,p=this.settings.popup_post_logout_redirect_uri,v=await this._popupNavigator.prepare({popupWindowFeatures:s,popupWindowTarget:a,popupSignal:c});await this._signout({request_type:"so:p",post_logout_redirect_uri:p,state:p==null?void 0:{},...f},v),n.info("success")}async signoutPopupCallback(r=window.location.href,n=!1){const s=this._logger.create("signoutPopupCallback");await this._popupNavigator.callback(r,{keepOpen:n}),s.info("success")}async _signout(r,n){const s=await this._signoutStart(r,n);return await this._signoutEnd(s.url)}async _signoutStart(r={},n){var s;const a=this._logger.create("_signoutStart");try{const c=await this._loadUser();a.debug("loaded current user from storage"),this.settings.revokeTokensOnSignout&&await this._revokeInternal(c);const f=r.id_token_hint||c&&c.id_token;f&&(a.debug("setting id_token_hint in signout request"),r.id_token_hint=f),await this.removeUser(),a.debug("user removed, creating signout request");const p=await this._client.createSignoutRequest(r);return a.debug("got signout request"),await n.navigate({url:p.url,state:(s=p.state)==null?void 0:s.id,scriptOrigin:this.settings.iframeScriptOrigin})}catch(c){throw a.debug("error after preparing navigator, closing navigator window"),n.close(),c}}async _signoutEnd(r){const n=this._logger.create("_signoutEnd"),s=await this._client.processSignoutResponse(r);return n.debug("got signout response"),s}async signoutSilent(r={}){var n;const s=this._logger.create("signoutSilent"),{silentRequestTimeoutInSeconds:a,...c}=r,f=this.settings.includeIdTokenInSilentSignout?(n=await this._loadUser())==null?void 0:n.id_token:void 0,p=this.settings.popup_post_logout_redirect_uri,v=await this._iframeNavigator.prepare({silentRequestTimeoutInSeconds:a});await this._signout({request_type:"so:s",post_logout_redirect_uri:p,id_token_hint:f,...c},v),s.info("success")}async signoutSilentCallback(r=window.location.href){const n=this._logger.create("signoutSilentCallback");await this._iframeNavigator.callback(r),n.info("success")}async revokeTokens(r){const n=await this._loadUser();await this._revokeInternal(n,r)}async _revokeInternal(r,n=this.settings.revokeTokenTypes){const s=this._logger.create("_revokeInternal");if(!r)return;const a=n.filter(c=>typeof r[c]=="string");if(!a.length){s.debug("no need to revoke due to no token(s)");return}for(const c of a)await this._client.revokeToken(r[c],c),s.info(`${c} revoked successfully`),c!=="access_token"&&(r[c]=null);await this.storeUser(r),s.debug("user stored"),await this._events.load(r)}startSilentRenew(){this._logger.create("startSilentRenew"),this._silentRenewService.start()}stopSilentRenew(){this._silentRenewService.stop()}get _userStoreKey(){return`user:${this.settings.authority}:${this.settings.client_id}`}async _loadUser(){const r=this._logger.create("_loadUser"),n=await this.settings.userStore.get(this._userStoreKey);return n?(r.debug("user storageString loaded"),cu.fromStorageString(n)):(r.debug("no user storageString"),null)}async storeUser(r){const n=this._logger.create("storeUser");if(r){n.debug("storing user");const s=r.toStorageString();await this.settings.userStore.set(this._userStoreKey,s)}else this._logger.debug("removing user"),await this.settings.userStore.remove(this._userStoreKey),this.settings.dpop&&await this.settings.dpop.store.remove(this.settings.client_id)}async clearStaleState(){await this._client.clearStaleState()}async dpopProof(r,n,s,a){var c,f;const p=await((f=(c=this.settings.dpop)==null?void 0:c.store)==null?void 0:f.get(this.settings.client_id));if(p)return await Je.generateDPoPProof({url:r,accessToken:n?.access_token,httpMethod:s,keyPair:p.keys,nonce:a})}async generateDPoPJkt(r){let n=await r.store.get(this.settings.client_id);if(!n){const s=await Je.generateDPoPKeys();n=new yp(s),await r.store.set(this.settings.client_id,n)}return await Je.generateDPoPJkt(n.keys)}},Hu=Tt.createContext(void 0);Hu.displayName="AuthContext";var sS={isLoading:!0,isAuthenticated:!1},oS=(r,n)=>{switch(n.type){case"INITIALISED":case"USER_LOADED":return{...r,user:n.user,isLoading:!1,isAuthenticated:n.user?!n.user.expired:!1,error:void 0};case"USER_SIGNED_OUT":case"USER_UNLOADED":return{...r,user:void 0,isAuthenticated:!1};case"NAVIGATOR_INIT":return{...r,isLoading:!0,activeNavigator:n.method};case"NAVIGATOR_CLOSE":return{...r,isLoading:!1,activeNavigator:void 0};case"ERROR":{const s=n.error;return s.toString=()=>`${s.name}: ${s.message}`,{...r,isLoading:!1,error:s}}default:{const s=new TypeError(`unknown type ${n.type}`),a={name:s.name,message:s.message,innerError:s,stack:s.stack,source:"unknown"};return a.toString=()=>`${a.name}: ${a.message}`,{...r,isLoading:!1,error:a}}}},aS=(r=window.location)=>{let n=new URLSearchParams(r.search);return!!((n.get("code")||n.get("error"))&&n.get("state")||(n=new URLSearchParams(r.hash.replace("#","?")),(n.get("code")||n.get("error"))&&n.get("state")))},lS=Ku("signinCallback","Sign-in failed"),uS=Ku("signoutCallback","Sign-out failed"),cS=Ku("renewSilent","Renew silent failed");function kp(r,n){return{name:du(r,"name",()=>"Error"),message:du(r,"message",()=>n),stack:du(r,"stack",()=>new Error().stack),innerError:r}}function Ku(r,n){return s=>({...kp(s,n),source:r})}function du(r,n,s){if(r&&typeof r=="object"){const a=r[n];if(typeof a=="string")return a}return s()}var dS=["clearStaleState","querySessionStatus","revokeTokens","startSilentRenew","stopSilentRenew"],fS=["signinPopup","signinSilent","signinRedirect","signinResourceOwnerCredentials","signoutPopup","signoutRedirect","signoutSilent"],gh=r=>()=>{throw new Error(`UserManager#${r} was called from an unsupported context. If this is a server-rendered page, defer this call with useEffect() or pass a custom UserManager implementation.`)},mh=typeof window>"u"?null:iS,hS=r=>{const{children:n,onSigninCallback:s,skipSigninCallback:a,matchSignoutCallback:c,onSignoutCallback:f,onRemoveUser:p,userManager:v=null,...y}=r,[x]=Tt.useState(()=>v??(mh?new mh(y):{settings:y})),[R,N]=Tt.useReducer(oS,sS),j=Tt.useMemo(()=>Object.assign({settings:x.settings,events:x.events},Object.fromEntries(dS.map($=>{var fe,T;return[$,(T=(fe=x[$])==null?void 0:fe.bind(x))!=null?T:gh($)]})),Object.fromEntries(fS.map($=>[$,x[$]?async fe=>{N({type:"NAVIGATOR_INIT",method:$});try{return await x[$](fe)}catch(T){return N({type:"ERROR",error:{...kp(T,`Unknown error while executing ${$}(...).`),source:$,args:fe}}),null}finally{N({type:"NAVIGATOR_CLOSE"})}}:gh($)]))),[x]),O=Tt.useRef(!1);Tt.useEffect(()=>{!x||O.current||(O.current=!0,(async()=>{try{let $=null;aS()&&!a&&($=await x.signinCallback(),s&&await s($)),$=$||await x.getUser(),N({type:"INITIALISED",user:$})}catch($){N({type:"ERROR",error:lS($)})}try{if(c&&c(x.settings)){const $=await x.signoutCallback();f&&await f($)}}catch($){N({type:"ERROR",error:uS($)})}})())},[x,a,s,f,c]),Tt.useEffect(()=>{if(!x)return;const $=L=>{N({type:"USER_LOADED",user:L})};x.events.addUserLoaded($);const fe=()=>{N({type:"USER_UNLOADED"})};x.events.addUserUnloaded(fe);const T=()=>{N({type:"USER_SIGNED_OUT"})};x.events.addUserSignedOut(T);const A=L=>{N({type:"ERROR",error:cS(L)})};return x.events.addSilentRenewError(A),()=>{x.events.removeUserLoaded($),x.events.removeUserUnloaded(fe),x.events.removeUserSignedOut(T),x.events.removeSilentRenewError(A)}},[x]);const q=Tt.useCallback(async()=>{await x.removeUser(),p&&await p()},[x,p]),Q=Tt.useMemo(()=>({...R,...j,removeUser:q}),[R,j,q]);return Tt.createElement(Hu.Provider,{value:Q},n)},bp=()=>{const r=Tt.useContext(Hu);return r||console.warn("AuthProvider context is undefined, please verify you are calling useAuth() as child of a component."),r};function pS(){const{identity:r,isActive:n}=Lu(),s=bp(),[a,c]=ae.useState(null),[f,p]=ae.useState(null),[v,y]=ae.useState(null),[x,R]=ae.useState(""),[N,j]=ae.useState(""),[O,q]=ae.useState(!1),[Q,$]=ae.useState(""),[fe,T]=ae.useState(!1),[A,L]=ae.useState(""),[J,Y]=ae.useState(!1),[ge,me]=ae.useState(!1),[ue,Re]=ae.useState(""),[We,Le]=ae.useState("oidc"),[Me,it]=ae.useState(""),[ke,P]=ae.useState(""),[W,M]=ae.useState(""),H=Tt.useRef(null),z=Tt.useRef(null),w=hr(fr.setName),E=hr(fr.createServer),ee=hr(fr.createChannel),ne=hr(fr.createThread),te=hr(fr.sendMessage),le=hr(fr.register),ie=hr(fr.login),he=hr(fr.joinVoice),we=hr(fr.leaveVoice),[_e]=pi(fi.server),[Ne]=pi(fi.channel),[Ge,Dt]=pi(fi.user),[mr]=pi(fi.message),[Dr]=pi(fi.thread),[Sn]=pi(fi.voice_state);ae.useEffect(()=>{!a&&_e.length>0&&c(_e[0].id)},[_e,a]),ae.useEffect(()=>{if(a){const B=Ne.filter(ye=>ye.serverId===a&&ye.kind.tag==="Text");B.length>0&&(!f||!Ne.some(ye=>ye.id===f&&ye.serverId===a))&&p(B[0].id)}},[a,Ne]);const zr=ae.useMemo(()=>_e.find(B=>B.id===a),[_e,a]),Ui=ae.useMemo(()=>Ne.find(B=>B.id===f),[Ne,f]),Ri=ae.useMemo(()=>Dr.find(B=>B.id===v),[Dr,v]),Fr=ae.useMemo(()=>a?Ne.filter(B=>B.serverId===a&&B.kind.tag==="Text"):[],[Ne,a]),yr=ae.useMemo(()=>a?Ne.filter(B=>B.serverId===a&&B.kind.tag==="Voice"):[],[Ne,a]),xn=ae.useMemo(()=>f?mr.filter(B=>B.channelId===f&&B.threadId===void 0).sort((B,ye)=>B.sent.microsSinceUnixEpochv?mr.filter(B=>B.threadId===v).sort((B,ye)=>B.sent.microsSinceUnixEpochGe.find(B=>B.identity.isEqual(r||Bs.zero())),[Ge,r]),In=ae.useMemo(()=>Sn.find(B=>B.identity.isEqual(r||Bs.zero())),[Sn,r]),Pi=ae.useMemo(()=>Ne.find(B=>B.id===In?.channelId),[Ne,In]),kn=ae.useMemo(()=>Ge.filter(B=>B.online),[Ge]),xt=ae.useMemo(()=>{if(!St)return!1;const B=!!(St.issuer&&St.subject),ye=!!(St.username&&St.password);return B||ye},[St]);ae.useEffect(()=>{H.current?.scrollIntoView({behavior:"smooth"})},[xn]),ae.useEffect(()=>{z.current?.scrollIntoView({behavior:"smooth"})},[Ni]);const js=B=>{B.preventDefault(),!(!x.trim()||!f)&&(te({text:x,channelId:f,threadId:void 0}),R(""))},$r=B=>{B.preventDefault(),!(!N.trim()||!v||!f)&&(te({text:N,channelId:f,threadId:v}),j(""))},Lr=B=>{B.preventDefault(),Q.trim()&&(E({name:Q}),$(""),q(!1))},ya=B=>{B.preventDefault(),!(!A.trim()||!a)&&(ee({name:A,serverId:a,isVoice:J}),L(""),Y(!1),T(!1))},Os=B=>{B.preventDefault(),ue.trim()&&(w({name:ue}),me(!1))},Ds=B=>{const ye=`Thread on: ${B.text.substring(0,20)}...`;ne({name:ye,channelId:B.channelId,parentMessageId:B.id})},wa=B=>{B.preventDefault(),M(""),ie({username:Me,password:ke}).catch(ye=>M(ye.message||"Login failed"))},Bi=B=>{B.preventDefault(),M(""),le({username:Me,password:ke}).then(()=>{Le("login"),M("Registration successful! Please log in.")}).catch(ye=>M(ye.message||"Registration failed"))},Ai=B=>{he({channelId:B})};if(s.isLoading)return b.jsx("div",{className:"login-screen",children:b.jsxs("div",{className:"login-card",children:[b.jsx("h1",{children:"Loading Authentication..."}),b.jsx("p",{children:"Please wait while we prepare your session."})]})});if(!n||!r)return b.jsx("div",{className:"login-screen",children:b.jsxs("div",{className:"login-card",children:[b.jsx("h1",{children:"Connecting..."}),b.jsx("p",{children:"Establishing connection to SpacetimeDB server."}),b.jsx("div",{className:"avatar",style:{width:"48px",height:"48px",fontSize:"1.2rem"},children:"..."})]})});if(!Dt)return b.jsx("div",{className:"login-screen",children:b.jsxs("div",{className:"login-card",children:[b.jsx("h1",{children:"Loading User Data..."}),b.jsx("p",{children:"Fetching your profile from the server."}),b.jsx("div",{className:"avatar",style:{width:"48px",height:"48px",fontSize:"1.2rem"},children:"..."})]})});if(!(s.isAuthenticated||xt))return b.jsx("div",{className:"login-screen",children:b.jsxs("div",{className:"login-card",children:[b.jsx("h1",{children:"Welcome to Spacetime Discord"}),b.jsx("p",{style:{marginBottom:"10px"},children:"Authentication is required to enter the community."}),b.jsxs("div",{style:{width:"100%",display:"flex",flexDirection:"column",gap:"20px"},children:[b.jsxs("div",{style:{display:"flex",flexDirection:"column",gap:"10px"},children:[b.jsx("h3",{style:{margin:0,fontSize:"0.9rem",color:"var(--text-muted)"},children:"FAST TRACK"}),b.jsxs("button",{className:"btn-primary",style:{width:"100%",display:"flex",alignItems:"center",justifyContent:"center",gap:"10px"},onClick:()=>s.signinRedirect(),children:[b.jsx("span",{style:{fontSize:"1.2rem"},children:"🌐"})," Log In with OIDC"]})]}),b.jsxs("div",{style:{display:"flex",alignItems:"center",width:"100%",gap:"10px"},children:[b.jsx("div",{style:{flex:1,height:"1px",backgroundColor:"var(--background-accent)"}}),b.jsx("span",{style:{fontSize:"0.8rem",color:"var(--text-muted)"},children:"OR USE CREDENTIALS"}),b.jsx("div",{style:{flex:1,height:"1px",backgroundColor:"var(--background-accent)"}})]}),b.jsxs("form",{onSubmit:We==="register"?Bi:wa,style:{width:"100%",display:"flex",flexDirection:"column",gap:"16px"},children:[b.jsxs("div",{style:{display:"flex",flexDirection:"column",gap:"8px"},children:[b.jsx("label",{style:{fontSize:"0.8rem",fontWeight:"bold",color:"var(--text-muted)"},children:"USERNAME"}),b.jsx("input",{autoFocus:!0,className:"chat-input",style:{backgroundColor:"var(--background-tertiary)",borderRadius:"4px",padding:"10px"},value:Me,onChange:B=>it(B.target.value)})]}),b.jsxs("div",{style:{display:"flex",flexDirection:"column",gap:"8px"},children:[b.jsx("label",{style:{fontSize:"0.8rem",fontWeight:"bold",color:"var(--text-muted)"},children:"PASSWORD"}),b.jsx("input",{type:"password",className:"chat-input",style:{backgroundColor:"var(--background-tertiary)",borderRadius:"4px",padding:"10px"},value:ke,onChange:B=>P(B.target.value)})]}),W&&b.jsx("div",{style:{color:"#da373c",fontSize:"0.85rem",textAlign:"center"},children:W}),b.jsx("button",{type:"submit",className:"btn-secondary",style:{width:"100%",backgroundColor:"var(--background-accent)"},children:We==="register"?"Create Account":"Log In"}),b.jsxs("div",{style:{fontSize:"0.9rem",color:"var(--text-muted)",textAlign:"center"},children:[We==="login"?"Need an account? ":"Already have an account? ",b.jsx("span",{style:{color:"var(--brand)",cursor:"pointer",fontWeight:"bold"},onClick:()=>{Le(We==="login"?"register":"login"),M("")},children:We==="login"?"Register":"Log In"})]})]})]})]})});const Et=B=>Ge.find(bn=>bn.identity.isEqual(B))?.name||B.toHexString().substring(0,8),Mi=B=>new Date(Number(B.microsSinceUnixEpoch/1000n)).toLocaleTimeString([],{hour:"2-digit",minute:"2-digit"});return b.jsxs("div",{className:"app-container",children:[b.jsxs("div",{className:"server-sidebar",children:[_e.map(B=>b.jsx("div",{className:`server-icon ${a===B.id?"active":""}`,onClick:()=>{c(B.id),y(null)},title:B.name,children:B.name.substring(0,2).toUpperCase()},B.id.toString())),b.jsx("div",{className:"server-icon",onClick:()=>q(!0),children:"+"})]}),b.jsxs("div",{className:"channel-sidebar",children:[b.jsxs("div",{className:"channel-header",style:{justifyContent:"space-between"},children:[b.jsx("span",{style:{overflow:"hidden",textOverflow:"ellipsis",whiteSpace:"nowrap"},children:zr?.name||"No Server Selected"}),zr&&b.jsx("button",{className:"add-btn",onClick:()=>T(!0),children:"+"})]}),b.jsxs("div",{className:"channel-list",children:[b.jsx("div",{style:{fontSize:"0.7rem",fontWeight:"bold",color:"var(--text-muted)",padding:"8px 8px 4px 8px"},children:"TEXT CHANNELS"}),Fr.map(B=>b.jsxs("div",{className:`channel-item ${f===B.id?"active":""}`,onClick:()=>{p(B.id),y(null)},children:[b.jsx("span",{className:"channel-item-hash",children:"#"}),B.name]},B.id.toString())),b.jsx("div",{style:{fontSize:"0.7rem",fontWeight:"bold",color:"var(--text-muted)",padding:"16px 8px 4px 8px"},children:"VOICE CHANNELS"}),yr.map(B=>b.jsxs("div",{children:[b.jsxs("div",{className:`channel-item ${In?.channelId===B.id?"active":""}`,onClick:()=>Ai(B.id),children:[b.jsx("span",{className:"channel-item-hash",children:"🔊"}),B.name]}),b.jsx("div",{style:{marginLeft:"24px",display:"flex",flexDirection:"column",gap:"4px",marginBottom:"8px"},children:Sn.filter(ye=>ye.channelId===B.id).map(ye=>b.jsxs("div",{style:{display:"flex",alignItems:"center",gap:"6px",fontSize:"0.85rem",color:"var(--text-muted)"},children:[b.jsx("div",{className:"avatar",style:{width:"18px",height:"18px",fontSize:"0.5rem"},children:Et(ye.identity).substring(0,2).toUpperCase()}),Et(ye.identity)]},ye.identity.toHexString()))})]},B.id.toString()))]}),Pi&&b.jsxs("div",{style:{backgroundColor:"#232428",borderBottom:"1px solid rgba(255,255,255,0.05)",padding:"10px",display:"flex",alignItems:"center",justifyContent:"space-between"},children:[b.jsxs("div",{style:{display:"flex",flexDirection:"column"},children:[b.jsx("span",{style:{color:"#23a559",fontSize:"0.8rem",fontWeight:"bold"},children:"Voice Connected"}),b.jsxs("span",{style:{color:"var(--text-muted)",fontSize:"0.75rem"},children:[Pi.name," / ",zr?.name]})]}),b.jsx("button",{className:"add-btn",style:{color:"#da373c"},onClick:()=>we(),children:"📞"})]}),b.jsxs("div",{className:"user-profile",children:[b.jsx("div",{className:"avatar",children:Et(r).substring(0,2).toUpperCase()}),b.jsxs("div",{className:"user-info",children:[b.jsx("div",{className:"username",children:Et(r)}),b.jsx("div",{className:"user-status",children:xt?"Online":"Unlinked Account"})]}),b.jsx("button",{className:"add-btn",onClick:()=>{Re(St?.name||""),me(!0)},children:"⚙️"})]})]}),b.jsxs("div",{className:"main-content",children:[b.jsxs("div",{className:"chat-header",children:[b.jsx("span",{style:{color:"var(--text-muted)",marginRight:"8px"},children:"#"}),Ui?.name||"Select a channel"]}),b.jsxs("div",{className:"messages-container",children:[xn.map(B=>b.jsxs("div",{className:"message",children:[b.jsx("div",{className:"message-avatar",children:Et(B.sender).substring(0,2).toUpperCase()}),b.jsxs("div",{className:"message-content",children:[b.jsxs("div",{className:"message-meta",children:[b.jsx("span",{className:"message-sender",children:Et(B.sender)}),b.jsx("span",{className:"message-timestamp",children:Mi(B.sent)})]}),b.jsx("div",{className:"message-text",children:B.text}),(()=>{const ye=Dr.find(bn=>bn.parentMessageId===B.id);return ye?b.jsx("button",{className:"message-thread-btn",onClick:()=>y(ye.id),children:"View Thread"}):b.jsx("button",{className:"message-thread-btn",onClick:()=>Ds(B),children:"Start Thread"})})(),Dr.filter(ye=>ye.parentMessageId===B.id).map(ye=>b.jsxs("div",{style:{marginLeft:"12px",marginTop:"4px",cursor:"pointer",color:"var(--brand)"},onClick:()=>y(ye.id),children:["↳ ",ye.name]},ye.id.toString()))]})]},B.id.toString())),b.jsx("div",{ref:H})]}),b.jsx("div",{className:"chat-input-container",children:b.jsx("form",{className:"chat-input-wrapper",onSubmit:js,children:b.jsx("input",{className:"chat-input",placeholder:xt?`Message #${Ui?.name||""}`:"Log in to chat",disabled:!xt,value:x,onChange:B=>R(B.target.value)})})})]}),b.jsx("div",{className:"right-sidebar",children:v?b.jsxs("div",{className:"thread-view",children:[b.jsxs("div",{className:"thread-header",children:[b.jsx("span",{children:"Thread"}),b.jsx("button",{className:"close-btn",onClick:()=>y(null),children:"×"})]}),b.jsxs("div",{className:"thread-messages",children:[b.jsx("div",{style:{padding:"8px",borderBottom:"1px solid var(--background-accent)",marginBottom:"8px"},children:b.jsx("div",{style:{fontWeight:"bold"},children:Ri?.name})}),Ni.map(B=>b.jsxs("div",{className:"message",style:{gap:"8px",marginBottom:"8px"},children:[b.jsx("div",{className:"message-avatar",style:{width:"32px",height:"32px"},children:Et(B.sender).substring(0,2).toUpperCase()}),b.jsxs("div",{className:"message-content",children:[b.jsx("div",{className:"message-meta",children:b.jsx("span",{className:"message-sender",style:{fontSize:"0.9rem"},children:Et(B.sender)})}),b.jsx("div",{className:"message-text",style:{fontSize:"0.9rem"},children:B.text})]})]},B.id.toString())),b.jsx("div",{ref:z})]}),b.jsx("div",{className:"chat-input-container",style:{padding:"8px"},children:b.jsx("form",{className:"chat-input-wrapper",onSubmit:$r,children:b.jsx("input",{className:"chat-input",style:{fontSize:"0.85rem"},placeholder:xt?"Reply in thread...":"Log in to chat",disabled:!xt,value:N,onChange:B=>j(B.target.value)})})})]}):b.jsxs("div",{className:"member-list",children:[b.jsxs("div",{style:{padding:"0 8px 8px 8px",fontSize:"0.75rem",fontWeight:"bold",color:"var(--text-muted)"},children:["ONLINE — ",kn.length]}),kn.map(B=>b.jsxs("div",{className:"member-item",children:[b.jsx("div",{className:"member-avatar",style:{width:"24px",height:"24px",display:"flex",alignItems:"center",justifyContent:"center",color:"white",fontSize:"0.7rem"},children:(B.name||B.identity.toHexString()).substring(0,2).toUpperCase()}),b.jsx("span",{className:"member-name",children:B.name||B.identity.toHexString().substring(0,8)})]},B.identity.toHexString()))]})}),O&&b.jsx("div",{className:"modal-overlay",children:b.jsxs("form",{className:"modal-content",onSubmit:Lr,children:[b.jsx("h2",{children:"Create Server"}),b.jsx("input",{autoFocus:!0,placeholder:"server-name",value:Q,onChange:B=>$(B.target.value)}),b.jsxs("div",{className:"modal-buttons",children:[b.jsx("button",{type:"button",className:"btn-secondary",onClick:()=>q(!1),children:"Cancel"}),b.jsx("button",{type:"submit",className:"btn-primary",disabled:!xt,children:"Create"})]})]})}),fe&&b.jsx("div",{className:"modal-overlay",children:b.jsxs("form",{className:"modal-content",onSubmit:ya,children:[b.jsx("h2",{children:"Create Channel"}),b.jsx("input",{autoFocus:!0,placeholder:"channel-name",value:A,onChange:B=>L(B.target.value)}),b.jsxs("div",{style:{display:"flex",alignItems:"center",gap:"8px",color:"var(--text-normal)"},children:[b.jsx("input",{type:"checkbox",checked:J,onChange:B=>Y(B.target.checked)}),b.jsx("label",{children:"Voice Channel"})]}),b.jsxs("div",{className:"modal-buttons",children:[b.jsx("button",{type:"button",className:"btn-secondary",onClick:()=>T(!1),children:"Cancel"}),b.jsx("button",{type:"submit",className:"btn-primary",disabled:!xt,children:"Create"})]})]})}),ge&&b.jsx("div",{className:"modal-overlay",children:b.jsxs("form",{className:"modal-content",onSubmit:Os,children:[b.jsx("h2",{children:"Account Settings"}),b.jsx("input",{autoFocus:!0,placeholder:"Display Name",value:ue,onChange:B=>Re(B.target.value)}),b.jsx("div",{style:{fontSize:"0.8rem",color:"var(--text-muted)",marginTop:"8px"},children:St?.issuer?b.jsxs(b.Fragment,{children:["Signed in via OIDC as: ",b.jsx("b",{children:s.user?.profile.name||s.user?.profile.sub})]}):St?.username?b.jsxs(b.Fragment,{children:["Logged in as: ",b.jsx("b",{children:St.username})]}):b.jsx(b.Fragment,{children:"Unlinked Anonymous Account"})}),b.jsxs("div",{className:"modal-buttons",style:{marginTop:"16px",justifyContent:"space-between"},children:[b.jsx("button",{type:"button",className:"btn-danger",onClick:()=>{s.isAuthenticated&&s.signoutRedirect(),localStorage.removeItem(Wu),window.location.reload()},children:"Sign Out / Reset"}),b.jsxs("div",{style:{display:"flex",gap:"8px"},children:[b.jsx("button",{type:"button",className:"btn-secondary",onClick:()=>me(!1),children:"Cancel"}),b.jsx("button",{type:"submit",className:"btn-primary",children:"Save"})]})]})]})})]})}const Cp="https://maincloud.spacetimedb.com",Tp="my-spacetime-app-jdhdg",Wu=`${Cp}/${Tp}/auth_token`,gS={authority:"https://accounts.google.com",client_id:"REPLACE_ME",redirect_uri:window.location.origin,scope:"openid profile email",response_type:"code",onSigninCallback:()=>{window.history.replaceState({},document.title,window.location.pathname)}},mS=(r,n,s)=>{localStorage.setItem(Wu,s),console.log("Connected to SpacetimeDB with identity:",n.toHexString())},yS=()=>{console.log("Disconnected from SpacetimeDB")},wS=(r,n)=>{console.log("Error connecting to SpacetimeDB:",n)};function vS(){const r=bp(),n=ae.useMemo(()=>{const s=Fu.builder().withUri(Cp).withDatabaseName(Tp).onConnect(mS).onDisconnect(yS).onConnectError(wS);if(r.isAuthenticated&&r.user?.id_token)return console.log("Connecting with OIDC token"),s.withToken(r.user.id_token);{const a=localStorage.getItem(Wu);if(a)return console.log("Connecting with stored SpacetimeDB token"),s.withToken(a)}return s},[r.isAuthenticated,r.user?.id_token]);return b.jsx(x_,{connectionBuilder:n,children:b.jsx(pS,{})})}Rm.createRoot(document.getElementById("root")).render(b.jsx(ae.StrictMode,{children:b.jsx(hS,{...gS,children:b.jsx(vS,{})})})); diff --git a/dist/assets/index-a-MKc3No.css b/dist/assets/index-a-MKc3No.css new file mode 100644 index 0000000..6ba8230 --- /dev/null +++ b/dist/assets/index-a-MKc3No.css @@ -0,0 +1 @@ +*,*:before,*:after{box-sizing:border-box;margin:0;padding:0}:root{--theme-color: #3dc373;--theme-color-contrast: #08180e;--textbox-color: #edfef4;color-scheme:light dark}@media(prefers-color-scheme:dark){:root{--theme-color: #4cf490;--theme-color-contrast: #132219;--textbox-color: #0f311d}}html,body,#root{height:100%;margin:0}body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,Fira Sans,Droid Sans,Helvetica Neue,sans-serif;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}code{font-family:source-code-pro,Menlo,Monaco,Consolas,Courier New,monospace}button{padding:.5rem .75rem;border:none;border-radius:.375rem;background-color:var(--theme-color);color:var(--theme-color-contrast);cursor:pointer;font-weight:600;letter-spacing:.1px;font-family:monospace}input,textarea{border:none;border-radius:.375rem;caret-color:var(--theme-color);font-family:monospace;font-weight:600;letter-spacing:.1px;padding:.5rem .75rem}input:focus,textarea:focus{outline:none;box-shadow:0 0 0 2px var(--theme-color)}:root{--background-primary: #313338;--background-secondary: #2b2d31;--background-tertiary: #1e1f22;--background-accent: #404249;--channel-sidebar-width: 240px;--server-sidebar-width: 72px;--text-normal: #dbdee1;--text-muted: #949ba4;--header-primary: #ffffff;--interactive-normal: #b5bac1;--interactive-hover: #dbdee1;--interactive-active: #ffffff;--brand: #5865f2;--brand-hover: #4752c4}body{margin:0;padding:0;background-color:var(--background-tertiary);color:var(--text-normal);font-family:gg sans,Noto Sans,Helvetica Neue,Helvetica,Arial,sans-serif;overflow:hidden}.app-container{display:flex;height:100vh;width:100vw}.login-screen{display:flex;flex-direction:column;align-items:center;justify-content:center;height:100vh;width:100vw;background-color:var(--background-tertiary);gap:20px}.login-card{background-color:var(--background-primary);padding:32px;border-radius:8px;box-shadow:0 2px 10px #0003;display:flex;flex-direction:column;align-items:center;gap:24px;width:400px}.login-card h1{margin:0;color:var(--header-primary)}.login-card p{color:var(--text-muted);text-align:center;margin:0}.server-sidebar{width:var(--server-sidebar-width);background-color:var(--background-tertiary);display:flex;flex-direction:column;align-items:center;padding-top:12px;gap:8px}.server-icon{width:48px;height:48px;background-color:var(--background-accent);border-radius:50%;display:flex;align-items:center;justify-content:center;cursor:pointer;transition:border-radius .2s,background-color .2s;color:var(--text-normal)}.server-icon:hover,.server-icon.active{border-radius:16px;background-color:var(--brand)}.channel-sidebar{width:var(--channel-sidebar-width);background-color:var(--background-secondary);display:flex;flex-direction:column}.channel-header{height:48px;padding:0 16px;display:flex;align-items:center;box-shadow:0 1px #0003;font-weight:700;color:var(--header-primary)}.channel-list{flex:1;padding:8px;overflow-y:auto}.channel-item{padding:6px 8px;border-radius:4px;cursor:pointer;display:flex;align-items:center;color:var(--interactive-normal);margin-bottom:2px}.channel-item:hover{background-color:var(--background-accent);color:var(--interactive-hover)}.channel-item.active{background-color:var(--background-accent);color:var(--interactive-active)}.channel-item-hash{margin-right:6px;color:var(--text-muted);font-size:1.2rem}.user-profile{height:52px;background-color:#232428;display:flex;align-items:center;padding:0 8px;gap:8px}.avatar{width:32px;height:32px;background-color:#5865f2;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:.8rem;color:#fff}.user-info{flex:1;overflow:hidden}.username{font-size:.85rem;font-weight:600;color:var(--header-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.user-status{font-size:.75rem;color:var(--text-muted)}.main-content{flex:1;display:flex;flex-direction:column;background-color:var(--background-primary)}.chat-header{height:48px;padding:0 16px;display:flex;align-items:center;box-shadow:0 1px #0003;color:var(--header-primary);font-weight:700}.messages-container{flex:1;overflow-y:auto;padding:16px;display:flex;flex-direction:column;gap:16px}.message{display:flex;gap:16px}.message-avatar{width:40px;height:40px;background-color:#5865f2;border-radius:50%;margin-top:2px;flex-shrink:0;display:flex;align-items:center;justify-content:center;color:#fff}.message-content{flex:1}.message-meta{display:flex;align-items:baseline;gap:8px;margin-bottom:4px}.message-sender{font-weight:500;color:var(--header-primary)}.message-timestamp{font-size:.75rem;color:var(--text-muted)}.message-text{color:var(--text-normal);line-height:1.375rem;word-wrap:break-word}.message-thread-btn{font-size:.75rem;color:var(--brand);background:none;border:none;cursor:pointer;padding:0;margin-top:4px}.message-thread-btn:hover{text-decoration:underline}.chat-input-container{padding:0 16px 24px}.chat-input-wrapper{background-color:#383a40;border-radius:8px;padding:11px 16px;display:flex;align-items:center}.chat-input{flex:1;background:none;border:none;color:var(--text-normal);font-family:inherit;font-size:1rem;outline:none}.chat-input::placeholder{color:var(--text-muted)}.right-sidebar{width:240px;background-color:var(--background-secondary);display:flex;flex-direction:column;border-left:1px solid rgba(255,255,255,.05)}.thread-view{display:flex;flex-direction:column;height:100%}.thread-header{height:48px;padding:0 16px;display:flex;align-items:center;justify-content:space-between;box-shadow:0 1px #0003;font-weight:700}.close-btn{background:none;border:none;color:var(--interactive-normal);cursor:pointer;font-size:1.2rem}.thread-messages{flex:1;overflow-y:auto;padding:8px}.member-list{padding:16px 8px}.member-item{display:flex;align-items:center;gap:8px;padding:6px 8px;border-radius:4px;color:var(--text-muted)}.member-item:hover{background-color:var(--background-accent);color:var(--interactive-hover)}.member-avatar{width:32px;height:32px;background-color:#5865f2;border-radius:50%}.member-name{font-size:.9rem;font-weight:500}.modal-overlay{position:fixed;inset:0;background-color:#000000d9;display:flex;align-items:center;justify-content:center;z-index:1000}.modal-content{background-color:var(--background-primary);padding:24px;border-radius:8px;width:400px;display:flex;flex-direction:column;gap:16px}.modal-content h2{margin:0;color:var(--header-primary)}.modal-content input{background-color:var(--background-tertiary);border:none;padding:12px;border-radius:4px;color:var(--text-normal);outline:none}.modal-buttons{display:flex;justify-content:flex-end;gap:8px}.btn-primary{background-color:var(--brand);color:#fff;border:none;padding:10px 20px;border-radius:4px;cursor:pointer}.btn-secondary{background-color:transparent;color:#fff;border:none;padding:10px 20px;cursor:pointer}.btn-danger{background-color:#da373c;color:#fff;border:none;padding:10px 20px;border-radius:4px;cursor:pointer}.btn-danger:hover{background-color:#a12829}.add-btn{background:none;border:none;color:var(--interactive-normal);cursor:pointer;font-size:1.2rem} diff --git a/dist/index.html b/dist/index.html new file mode 100644 index 0000000..0a1ec71 --- /dev/null +++ b/dist/index.html @@ -0,0 +1,14 @@ + + + + + + + Vite + React + TS + + + + +
+ + diff --git a/dist/vite.svg b/dist/vite.svg new file mode 100644 index 0000000..e7b8dfb --- /dev/null +++ b/dist/vite.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/index.html b/index.html new file mode 100644 index 0000000..e4b78ea --- /dev/null +++ b/index.html @@ -0,0 +1,13 @@ + + + + + + + Vite + React + TS + + +
+ + + diff --git a/package.json b/package.json new file mode 100644 index 0000000..bc3c3c0 --- /dev/null +++ b/package.json @@ -0,0 +1,45 @@ +{ + "name": "my-spacetime-app", + "private": true, + "version": "0.0.1", + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc -b && vite build", + "format": "prettier . --write --ignore-path ../../.prettierignore", + "lint": "eslint . && prettier . --check --ignore-path ../../.prettierignore", + "preview": "vite preview", + "test": "vitest run", + "generate": "cargo run -p gen-bindings -- --out-dir src/module_bindings --module-path spacetimedb && prettier --write src/module_bindings", + "spacetime:generate": "spacetime generate --lang typescript --out-dir src/module_bindings --module-path spacetimedb", + "spacetime:publish:local": "spacetime publish --module-path server --server local", + "spacetime:publish": "spacetime publish --module-path server --server maincloud" + }, + "dependencies": { + "oidc-client-ts": "^3.5.0", + "react": "^18.3.1", + "react-dom": "^18.3.1", + "react-oidc-context": "^3.3.1", + "spacetimedb": "^2.1.0" + }, + "devDependencies": { + "@eslint/js": "^9.17.0", + "@testing-library/jest-dom": "^6.6.3", + "@testing-library/react": "^16.2.0", + "@testing-library/user-event": "^14.6.1", + "@types/react": "^18.3.18", + "@types/react-dom": "^18.3.5", + "@vitejs/plugin-basic-ssl": "^2.3.0", + "@vitejs/plugin-react": "^5.0.2", + "eslint": "^9.17.0", + "eslint-plugin-react-hooks": "^5.0.0", + "eslint-plugin-react-refresh": "^0.4.16", + "globals": "^15.14.0", + "jsdom": "^26.0.0", + "prettier": "^3.3.3", + "typescript": "~5.6.2", + "typescript-eslint": "^8.18.2", + "vite": "^7.1.5", + "vitest": "3.2.4" + } +} \ No newline at end of file diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml new file mode 100644 index 0000000..8602592 --- /dev/null +++ b/pnpm-lock.yaml @@ -0,0 +1,2993 @@ +lockfileVersion: '9.0' + +settings: + autoInstallPeers: true + excludeLinksFromLockfile: false + +importers: + + .: + dependencies: + oidc-client-ts: + specifier: ^3.5.0 + version: 3.5.0 + react: + specifier: ^18.3.1 + version: 18.3.1 + react-dom: + specifier: ^18.3.1 + version: 18.3.1(react@18.3.1) + react-oidc-context: + specifier: ^3.3.1 + version: 3.3.1(oidc-client-ts@3.5.0)(react@18.3.1) + spacetimedb: + specifier: ^2.1.0 + version: 2.1.0(react@18.3.1) + devDependencies: + '@eslint/js': + specifier: ^9.17.0 + version: 9.39.4 + '@testing-library/jest-dom': + specifier: ^6.6.3 + version: 6.9.1 + '@testing-library/react': + specifier: ^16.2.0 + version: 16.3.2(@testing-library/dom@10.4.1)(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1) + '@testing-library/user-event': + specifier: ^14.6.1 + version: 14.6.1(@testing-library/dom@10.4.1) + '@types/react': + specifier: ^18.3.18 + version: 18.3.28 + '@types/react-dom': + specifier: ^18.3.5 + version: 18.3.7(@types/react@18.3.28) + '@vitejs/plugin-basic-ssl': + specifier: ^2.3.0 + version: 2.3.0(vite@7.3.1) + '@vitejs/plugin-react': + specifier: ^5.0.2 + version: 5.2.0(vite@7.3.1) + eslint: + specifier: ^9.17.0 + version: 9.39.4 + eslint-plugin-react-hooks: + specifier: ^5.0.0 + version: 5.2.0(eslint@9.39.4) + eslint-plugin-react-refresh: + specifier: ^0.4.16 + version: 0.4.26(eslint@9.39.4) + globals: + specifier: ^15.14.0 + version: 15.15.0 + jsdom: + specifier: ^26.0.0 + version: 26.1.0 + prettier: + specifier: ^3.3.3 + version: 3.8.1 + typescript: + specifier: ~5.6.2 + version: 5.6.3 + typescript-eslint: + specifier: ^8.18.2 + version: 8.57.2(eslint@9.39.4)(typescript@5.6.3) + vite: + specifier: ^7.1.5 + version: 7.3.1 + vitest: + specifier: 3.2.4 + version: 3.2.4(jsdom@26.1.0) + +packages: + + '@adobe/css-tools@4.4.4': + resolution: {integrity: sha512-Elp+iwUx5rN5+Y8xLt5/GRoG20WGoDCQ/1Fb+1LiGtvwbDavuSk0jhD/eZdckHAuzcDzccnkv+rEjyWfRx18gg==} + + '@asamuzakjp/css-color@3.2.0': + resolution: {integrity: sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==} + + '@babel/code-frame@7.29.0': + resolution: {integrity: sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==} + engines: {node: '>=6.9.0'} + + '@babel/compat-data@7.29.0': + resolution: {integrity: sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==} + engines: {node: '>=6.9.0'} + + '@babel/core@7.29.0': + resolution: {integrity: sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==} + engines: {node: '>=6.9.0'} + + '@babel/generator@7.29.1': + resolution: {integrity: sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==} + engines: {node: '>=6.9.0'} + + '@babel/helper-compilation-targets@7.28.6': + resolution: {integrity: sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==} + engines: {node: '>=6.9.0'} + + '@babel/helper-globals@7.28.0': + resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==} + engines: {node: '>=6.9.0'} + + '@babel/helper-module-imports@7.28.6': + resolution: {integrity: sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==} + engines: {node: '>=6.9.0'} + + '@babel/helper-module-transforms@7.28.6': + resolution: {integrity: sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0 + + '@babel/helper-plugin-utils@7.28.6': + resolution: {integrity: sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==} + engines: {node: '>=6.9.0'} + + '@babel/helper-string-parser@7.27.1': + resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==} + engines: {node: '>=6.9.0'} + + '@babel/helper-validator-identifier@7.28.5': + resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==} + engines: {node: '>=6.9.0'} + + '@babel/helper-validator-option@7.27.1': + resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==} + engines: {node: '>=6.9.0'} + + '@babel/helpers@7.29.2': + resolution: {integrity: sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==} + engines: {node: '>=6.9.0'} + + '@babel/parser@7.29.2': + resolution: {integrity: sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==} + engines: {node: '>=6.0.0'} + hasBin: true + + '@babel/plugin-transform-react-jsx-self@7.27.1': + resolution: {integrity: sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/plugin-transform-react-jsx-source@7.27.1': + resolution: {integrity: sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==} + engines: {node: '>=6.9.0'} + peerDependencies: + '@babel/core': ^7.0.0-0 + + '@babel/runtime@7.29.2': + resolution: {integrity: sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==} + engines: {node: '>=6.9.0'} + + '@babel/template@7.28.6': + resolution: {integrity: sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==} + engines: {node: '>=6.9.0'} + + '@babel/traverse@7.29.0': + resolution: {integrity: sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==} + engines: {node: '>=6.9.0'} + + '@babel/types@7.29.0': + resolution: {integrity: sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==} + engines: {node: '>=6.9.0'} + + '@csstools/color-helpers@5.1.0': + resolution: {integrity: sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==} + engines: {node: '>=18'} + + '@csstools/css-calc@2.1.4': + resolution: {integrity: sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==} + engines: {node: '>=18'} + peerDependencies: + '@csstools/css-parser-algorithms': ^3.0.5 + '@csstools/css-tokenizer': ^3.0.4 + + '@csstools/css-color-parser@3.1.0': + resolution: {integrity: sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==} + engines: {node: '>=18'} + peerDependencies: + '@csstools/css-parser-algorithms': ^3.0.5 + '@csstools/css-tokenizer': ^3.0.4 + + '@csstools/css-parser-algorithms@3.0.5': + resolution: {integrity: sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==} + engines: {node: '>=18'} + peerDependencies: + '@csstools/css-tokenizer': ^3.0.4 + + '@csstools/css-tokenizer@3.0.4': + resolution: {integrity: sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==} + engines: {node: '>=18'} + + '@esbuild/aix-ppc64@0.27.4': + resolution: {integrity: sha512-cQPwL2mp2nSmHHJlCyoXgHGhbEPMrEEU5xhkcy3Hs/O7nGZqEpZ2sUtLaL9MORLtDfRvVl2/3PAuEkYZH0Ty8Q==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [aix] + + '@esbuild/android-arm64@0.27.4': + resolution: {integrity: sha512-gdLscB7v75wRfu7QSm/zg6Rx29VLdy9eTr2t44sfTW7CxwAtQghZ4ZnqHk3/ogz7xao0QAgrkradbBzcqFPasw==} + engines: {node: '>=18'} + cpu: [arm64] + os: [android] + + '@esbuild/android-arm@0.27.4': + resolution: {integrity: sha512-X9bUgvxiC8CHAGKYufLIHGXPJWnr0OCdR0anD2e21vdvgCI8lIfqFbnoeOz7lBjdrAGUhqLZLcQo6MLhTO2DKQ==} + engines: {node: '>=18'} + cpu: [arm] + os: [android] + + '@esbuild/android-x64@0.27.4': + resolution: {integrity: sha512-PzPFnBNVF292sfpfhiyiXCGSn9HZg5BcAz+ivBuSsl6Rk4ga1oEXAamhOXRFyMcjwr2DVtm40G65N3GLeH1Lvw==} + engines: {node: '>=18'} + cpu: [x64] + os: [android] + + '@esbuild/darwin-arm64@0.27.4': + resolution: {integrity: sha512-b7xaGIwdJlht8ZFCvMkpDN6uiSmnxxK56N2GDTMYPr2/gzvfdQN8rTfBsvVKmIVY/X7EM+/hJKEIbbHs9oA4tQ==} + engines: {node: '>=18'} + cpu: [arm64] + os: [darwin] + + '@esbuild/darwin-x64@0.27.4': + resolution: {integrity: sha512-sR+OiKLwd15nmCdqpXMnuJ9W2kpy0KigzqScqHI3Hqwr7IXxBp3Yva+yJwoqh7rE8V77tdoheRYataNKL4QrPw==} + engines: {node: '>=18'} + cpu: [x64] + os: [darwin] + + '@esbuild/freebsd-arm64@0.27.4': + resolution: {integrity: sha512-jnfpKe+p79tCnm4GVav68A7tUFeKQwQyLgESwEAUzyxk/TJr4QdGog9sqWNcUbr/bZt/O/HXouspuQDd9JxFSw==} + engines: {node: '>=18'} + cpu: [arm64] + os: [freebsd] + + '@esbuild/freebsd-x64@0.27.4': + resolution: {integrity: sha512-2kb4ceA/CpfUrIcTUl1wrP/9ad9Atrp5J94Lq69w7UwOMolPIGrfLSvAKJp0RTvkPPyn6CIWrNy13kyLikZRZQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [freebsd] + + '@esbuild/linux-arm64@0.27.4': + resolution: {integrity: sha512-7nQOttdzVGth1iz57kxg9uCz57dxQLHWxopL6mYuYthohPKEK0vU0C3O21CcBK6KDlkYVcnDXY099HcCDXd9dA==} + engines: {node: '>=18'} + cpu: [arm64] + os: [linux] + + '@esbuild/linux-arm@0.27.4': + resolution: {integrity: sha512-aBYgcIxX/wd5n2ys0yESGeYMGF+pv6g0DhZr3G1ZG4jMfruU9Tl1i2Z+Wnj9/KjGz1lTLCcorqE2viePZqj4Eg==} + engines: {node: '>=18'} + cpu: [arm] + os: [linux] + + '@esbuild/linux-ia32@0.27.4': + resolution: {integrity: sha512-oPtixtAIzgvzYcKBQM/qZ3R+9TEUd1aNJQu0HhGyqtx6oS7qTpvjheIWBbes4+qu1bNlo2V4cbkISr8q6gRBFA==} + engines: {node: '>=18'} + cpu: [ia32] + os: [linux] + + '@esbuild/linux-loong64@0.27.4': + resolution: {integrity: sha512-8mL/vh8qeCoRcFH2nM8wm5uJP+ZcVYGGayMavi8GmRJjuI3g1v6Z7Ni0JJKAJW+m0EtUuARb6Lmp4hMjzCBWzA==} + engines: {node: '>=18'} + cpu: [loong64] + os: [linux] + + '@esbuild/linux-mips64el@0.27.4': + resolution: {integrity: sha512-1RdrWFFiiLIW7LQq9Q2NES+HiD4NyT8Itj9AUeCl0IVCA459WnPhREKgwrpaIfTOe+/2rdntisegiPWn/r/aAw==} + engines: {node: '>=18'} + cpu: [mips64el] + os: [linux] + + '@esbuild/linux-ppc64@0.27.4': + resolution: {integrity: sha512-tLCwNG47l3sd9lpfyx9LAGEGItCUeRCWeAx6x2Jmbav65nAwoPXfewtAdtbtit/pJFLUWOhpv0FpS6GQAmPrHA==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [linux] + + '@esbuild/linux-riscv64@0.27.4': + resolution: {integrity: sha512-BnASypppbUWyqjd1KIpU4AUBiIhVr6YlHx/cnPgqEkNoVOhHg+YiSVxM1RLfiy4t9cAulbRGTNCKOcqHrEQLIw==} + engines: {node: '>=18'} + cpu: [riscv64] + os: [linux] + + '@esbuild/linux-s390x@0.27.4': + resolution: {integrity: sha512-+eUqgb/Z7vxVLezG8bVB9SfBie89gMueS+I0xYh2tJdw3vqA/0ImZJ2ROeWwVJN59ihBeZ7Tu92dF/5dy5FttA==} + engines: {node: '>=18'} + cpu: [s390x] + os: [linux] + + '@esbuild/linux-x64@0.27.4': + resolution: {integrity: sha512-S5qOXrKV8BQEzJPVxAwnryi2+Iq5pB40gTEIT69BQONqR7JH1EPIcQ/Uiv9mCnn05jff9umq/5nqzxlqTOg9NA==} + engines: {node: '>=18'} + cpu: [x64] + os: [linux] + + '@esbuild/netbsd-arm64@0.27.4': + resolution: {integrity: sha512-xHT8X4sb0GS8qTqiwzHqpY00C95DPAq7nAwX35Ie/s+LO9830hrMd3oX0ZMKLvy7vsonee73x0lmcdOVXFzd6Q==} + engines: {node: '>=18'} + cpu: [arm64] + os: [netbsd] + + '@esbuild/netbsd-x64@0.27.4': + resolution: {integrity: sha512-RugOvOdXfdyi5Tyv40kgQnI0byv66BFgAqjdgtAKqHoZTbTF2QqfQrFwa7cHEORJf6X2ht+l9ABLMP0dnKYsgg==} + engines: {node: '>=18'} + cpu: [x64] + os: [netbsd] + + '@esbuild/openbsd-arm64@0.27.4': + resolution: {integrity: sha512-2MyL3IAaTX+1/qP0O1SwskwcwCoOI4kV2IBX1xYnDDqthmq5ArrW94qSIKCAuRraMgPOmG0RDTA74mzYNQA9ow==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openbsd] + + '@esbuild/openbsd-x64@0.27.4': + resolution: {integrity: sha512-u8fg/jQ5aQDfsnIV6+KwLOf1CmJnfu1ShpwqdwC0uA7ZPwFws55Ngc12vBdeUdnuWoQYx/SOQLGDcdlfXhYmXQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [openbsd] + + '@esbuild/openharmony-arm64@0.27.4': + resolution: {integrity: sha512-JkTZrl6VbyO8lDQO3yv26nNr2RM2yZzNrNHEsj9bm6dOwwu9OYN28CjzZkH57bh4w0I2F7IodpQvUAEd1mbWXg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openharmony] + + '@esbuild/sunos-x64@0.27.4': + resolution: {integrity: sha512-/gOzgaewZJfeJTlsWhvUEmUG4tWEY2Spp5M20INYRg2ZKl9QPO3QEEgPeRtLjEWSW8FilRNacPOg8R1uaYkA6g==} + engines: {node: '>=18'} + cpu: [x64] + os: [sunos] + + '@esbuild/win32-arm64@0.27.4': + resolution: {integrity: sha512-Z9SExBg2y32smoDQdf1HRwHRt6vAHLXcxD2uGgO/v2jK7Y718Ix4ndsbNMU/+1Qiem9OiOdaqitioZwxivhXYg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [win32] + + '@esbuild/win32-ia32@0.27.4': + resolution: {integrity: sha512-DAyGLS0Jz5G5iixEbMHi5KdiApqHBWMGzTtMiJ72ZOLhbu/bzxgAe8Ue8CTS3n3HbIUHQz/L51yMdGMeoxXNJw==} + engines: {node: '>=18'} + cpu: [ia32] + os: [win32] + + '@esbuild/win32-x64@0.27.4': + resolution: {integrity: sha512-+knoa0BDoeXgkNvvV1vvbZX4+hizelrkwmGJBdT17t8FNPwG2lKemmuMZlmaNQ3ws3DKKCxpb4zRZEIp3UxFCg==} + engines: {node: '>=18'} + cpu: [x64] + os: [win32] + + '@eslint-community/eslint-utils@4.9.1': + resolution: {integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + + '@eslint-community/regexpp@4.12.2': + resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==} + engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + + '@eslint/config-array@0.21.2': + resolution: {integrity: sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/config-helpers@0.4.2': + resolution: {integrity: sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/core@0.17.0': + resolution: {integrity: sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/eslintrc@3.3.5': + resolution: {integrity: sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/js@9.39.4': + resolution: {integrity: sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/object-schema@2.1.7': + resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@eslint/plugin-kit@0.4.1': + resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@humanfs/core@0.19.1': + resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==} + engines: {node: '>=18.18.0'} + + '@humanfs/node@0.16.7': + resolution: {integrity: sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==} + engines: {node: '>=18.18.0'} + + '@humanwhocodes/module-importer@1.0.1': + resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} + engines: {node: '>=12.22'} + + '@humanwhocodes/retry@0.4.3': + resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==} + engines: {node: '>=18.18'} + + '@jridgewell/gen-mapping@0.3.13': + resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==} + + '@jridgewell/remapping@2.3.5': + resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==} + + '@jridgewell/resolve-uri@3.1.2': + resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} + engines: {node: '>=6.0.0'} + + '@jridgewell/sourcemap-codec@1.5.5': + resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==} + + '@jridgewell/trace-mapping@0.3.31': + resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==} + + '@rolldown/pluginutils@1.0.0-rc.3': + resolution: {integrity: sha512-eybk3TjzzzV97Dlj5c+XrBFW57eTNhzod66y9HrBlzJ6NsCrWCp/2kaPS3K9wJmurBC0Tdw4yPjXKZqlznim3Q==} + + '@rollup/rollup-android-arm-eabi@4.60.0': + resolution: {integrity: sha512-WOhNW9K8bR3kf4zLxbfg6Pxu2ybOUbB2AjMDHSQx86LIF4rH4Ft7vmMwNt0loO0eonglSNy4cpD3MKXXKQu0/A==} + cpu: [arm] + os: [android] + + '@rollup/rollup-android-arm64@4.60.0': + resolution: {integrity: sha512-u6JHLll5QKRvjciE78bQXDmqRqNs5M/3GVqZeMwvmjaNODJih/WIrJlFVEihvV0MiYFmd+ZyPr9wxOVbPAG2Iw==} + cpu: [arm64] + os: [android] + + '@rollup/rollup-darwin-arm64@4.60.0': + resolution: {integrity: sha512-qEF7CsKKzSRc20Ciu2Zw1wRrBz4g56F7r/vRwY430UPp/nt1x21Q/fpJ9N5l47WWvJlkNCPJz3QRVw008fi7yA==} + cpu: [arm64] + os: [darwin] + + '@rollup/rollup-darwin-x64@4.60.0': + resolution: {integrity: sha512-WADYozJ4QCnXCH4wPB+3FuGmDPoFseVCUrANmA5LWwGmC6FL14BWC7pcq+FstOZv3baGX65tZ378uT6WG8ynTw==} + cpu: [x64] + os: [darwin] + + '@rollup/rollup-freebsd-arm64@4.60.0': + resolution: {integrity: sha512-6b8wGHJlDrGeSE3aH5mGNHBjA0TTkxdoNHik5EkvPHCt351XnigA4pS7Wsj/Eo9Y8RBU6f35cjN9SYmCFBtzxw==} + cpu: [arm64] + os: [freebsd] + + '@rollup/rollup-freebsd-x64@4.60.0': + resolution: {integrity: sha512-h25Ga0t4jaylMB8M/JKAyrvvfxGRjnPQIR8lnCayyzEjEOx2EJIlIiMbhpWxDRKGKF8jbNH01NnN663dH638mA==} + cpu: [x64] + os: [freebsd] + + '@rollup/rollup-linux-arm-gnueabihf@4.60.0': + resolution: {integrity: sha512-RzeBwv0B3qtVBWtcuABtSuCzToo2IEAIQrcyB/b2zMvBWVbjo8bZDjACUpnaafaxhTw2W+imQbP2BD1usasK4g==} + cpu: [arm] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-arm-musleabihf@4.60.0': + resolution: {integrity: sha512-Sf7zusNI2CIU1HLzuu9Tc5YGAHEZs5Lu7N1ssJG4Tkw6e0MEsN7NdjUDDfGNHy2IU+ENyWT+L2obgWiguWibWQ==} + cpu: [arm] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-arm64-gnu@4.60.0': + resolution: {integrity: sha512-DX2x7CMcrJzsE91q7/O02IJQ5/aLkVtYFryqCjduJhUfGKG6yJV8hxaw8pZa93lLEpPTP/ohdN4wFz7yp/ry9A==} + cpu: [arm64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-arm64-musl@4.60.0': + resolution: {integrity: sha512-09EL+yFVbJZlhcQfShpswwRZ0Rg+z/CsSELFCnPt3iK+iqwGsI4zht3secj5vLEs957QvFFXnzAT0FFPIxSrkQ==} + cpu: [arm64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-loong64-gnu@4.60.0': + resolution: {integrity: sha512-i9IcCMPr3EXm8EQg5jnja0Zyc1iFxJjZWlb4wr7U2Wx/GrddOuEafxRdMPRYVaXjgbhvqalp6np07hN1w9kAKw==} + cpu: [loong64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-loong64-musl@4.60.0': + resolution: {integrity: sha512-DGzdJK9kyJ+B78MCkWeGnpXJ91tK/iKA6HwHxF4TAlPIY7GXEvMe8hBFRgdrR9Ly4qebR/7gfUs9y2IoaVEyog==} + cpu: [loong64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-ppc64-gnu@4.60.0': + resolution: {integrity: sha512-RwpnLsqC8qbS8z1H1AxBA1H6qknR4YpPR9w2XX0vo2Sz10miu57PkNcnHVaZkbqyw/kUWfKMI73jhmfi9BRMUQ==} + cpu: [ppc64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-ppc64-musl@4.60.0': + resolution: {integrity: sha512-Z8pPf54Ly3aqtdWC3G4rFigZgNvd+qJlOE52fmko3KST9SoGfAdSRCwyoyG05q1HrrAblLbk1/PSIV+80/pxLg==} + cpu: [ppc64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-riscv64-gnu@4.60.0': + resolution: {integrity: sha512-3a3qQustp3COCGvnP4SvrMHnPQ9d1vzCakQVRTliaz8cIp/wULGjiGpbcqrkv0WrHTEp8bQD/B3HBjzujVWLOA==} + cpu: [riscv64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-riscv64-musl@4.60.0': + resolution: {integrity: sha512-pjZDsVH/1VsghMJ2/kAaxt6dL0psT6ZexQVrijczOf+PeP2BUqTHYejk3l6TlPRydggINOeNRhvpLa0AYpCWSQ==} + cpu: [riscv64] + os: [linux] + libc: [musl] + + '@rollup/rollup-linux-s390x-gnu@4.60.0': + resolution: {integrity: sha512-3ObQs0BhvPgiUVZrN7gqCSvmFuMWvWvsjG5ayJ3Lraqv+2KhOsp+pUbigqbeWqueGIsnn+09HBw27rJ+gYK4VQ==} + cpu: [s390x] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-x64-gnu@4.60.0': + resolution: {integrity: sha512-EtylprDtQPdS5rXvAayrNDYoJhIz1/vzN2fEubo3yLE7tfAw+948dO0g4M0vkTVFhKojnF+n6C8bDNe+gDRdTg==} + cpu: [x64] + os: [linux] + libc: [glibc] + + '@rollup/rollup-linux-x64-musl@4.60.0': + resolution: {integrity: sha512-k09oiRCi/bHU9UVFqD17r3eJR9bn03TyKraCrlz5ULFJGdJGi7VOmm9jl44vOJvRJ6P7WuBi/s2A97LxxHGIdw==} + cpu: [x64] + os: [linux] + libc: [musl] + + '@rollup/rollup-openbsd-x64@4.60.0': + resolution: {integrity: sha512-1o/0/pIhozoSaDJoDcec+IVLbnRtQmHwPV730+AOD29lHEEo4F5BEUB24H0OBdhbBBDwIOSuf7vgg0Ywxdfiiw==} + cpu: [x64] + os: [openbsd] + + '@rollup/rollup-openharmony-arm64@4.60.0': + resolution: {integrity: sha512-pESDkos/PDzYwtyzB5p/UoNU/8fJo68vcXM9ZW2V0kjYayj1KaaUfi1NmTUTUpMn4UhU4gTuK8gIaFO4UGuMbA==} + cpu: [arm64] + os: [openharmony] + + '@rollup/rollup-win32-arm64-msvc@4.60.0': + resolution: {integrity: sha512-hj1wFStD7B1YBeYmvY+lWXZ7ey73YGPcViMShYikqKT1GtstIKQAtfUI6yrzPjAy/O7pO0VLXGmUVWXQMaYgTQ==} + cpu: [arm64] + os: [win32] + + '@rollup/rollup-win32-ia32-msvc@4.60.0': + resolution: {integrity: sha512-SyaIPFoxmUPlNDq5EHkTbiKzmSEmq/gOYFI/3HHJ8iS/v1mbugVa7dXUzcJGQfoytp9DJFLhHH4U3/eTy2Bq4w==} + cpu: [ia32] + os: [win32] + + '@rollup/rollup-win32-x64-gnu@4.60.0': + resolution: {integrity: sha512-RdcryEfzZr+lAr5kRm2ucN9aVlCCa2QNq4hXelZxb8GG0NJSazq44Z3PCCc8wISRuCVnGs0lQJVX5Vp6fKA+IA==} + cpu: [x64] + os: [win32] + + '@rollup/rollup-win32-x64-msvc@4.60.0': + resolution: {integrity: sha512-PrsWNQ8BuE00O3Xsx3ALh2Df8fAj9+cvvX9AIA6o4KpATR98c9mud4XtDWVvsEuyia5U4tVSTKygawyJkjm60w==} + cpu: [x64] + os: [win32] + + '@testing-library/dom@10.4.1': + resolution: {integrity: sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==} + engines: {node: '>=18'} + + '@testing-library/jest-dom@6.9.1': + resolution: {integrity: sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==} + engines: {node: '>=14', npm: '>=6', yarn: '>=1'} + + '@testing-library/react@16.3.2': + resolution: {integrity: sha512-XU5/SytQM+ykqMnAnvB2umaJNIOsLF3PVv//1Ew4CTcpz0/BRyy/af40qqrt7SjKpDdT1saBMc42CUok5gaw+g==} + engines: {node: '>=18'} + peerDependencies: + '@testing-library/dom': ^10.0.0 + '@types/react': ^18.0.0 || ^19.0.0 + '@types/react-dom': ^18.0.0 || ^19.0.0 + react: ^18.0.0 || ^19.0.0 + react-dom: ^18.0.0 || ^19.0.0 + peerDependenciesMeta: + '@types/react': + optional: true + '@types/react-dom': + optional: true + + '@testing-library/user-event@14.6.1': + resolution: {integrity: sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==} + engines: {node: '>=12', npm: '>=6'} + peerDependencies: + '@testing-library/dom': '>=7.21.4' + + '@types/aria-query@5.0.4': + resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==} + + '@types/babel__core@7.20.5': + resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==} + + '@types/babel__generator@7.27.0': + resolution: {integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==} + + '@types/babel__template@7.4.4': + resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==} + + '@types/babel__traverse@7.28.0': + resolution: {integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==} + + '@types/chai@5.2.3': + resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==} + + '@types/deep-eql@4.0.2': + resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==} + + '@types/estree@1.0.8': + resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==} + + '@types/json-schema@7.0.15': + resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} + + '@types/prop-types@15.7.15': + resolution: {integrity: sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==} + + '@types/react-dom@18.3.7': + resolution: {integrity: sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==} + peerDependencies: + '@types/react': ^18.0.0 + + '@types/react@18.3.28': + resolution: {integrity: sha512-z9VXpC7MWrhfWipitjNdgCauoMLRdIILQsAEV+ZesIzBq/oUlxk0m3ApZuMFCXdnS4U7KrI+l3WRUEGQ8K1QKw==} + + '@typescript-eslint/eslint-plugin@8.57.2': + resolution: {integrity: sha512-NZZgp0Fm2IkD+La5PR81sd+g+8oS6JwJje+aRWsDocxHkjyRw0J5L5ZTlN3LI1LlOcGL7ph3eaIUmTXMIjLk0w==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + '@typescript-eslint/parser': ^8.57.2 + eslint: ^8.57.0 || ^9.0.0 || ^10.0.0 + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/parser@8.57.2': + resolution: {integrity: sha512-30ScMRHIAD33JJQkgfGW1t8CURZtjc2JpTrq5n2HFhOefbAhb7ucc7xJwdWcrEtqUIYJ73Nybpsggii6GtAHjA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 || ^10.0.0 + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/project-service@8.57.2': + resolution: {integrity: sha512-FuH0wipFywXRTHf+bTTjNyuNQQsQC3qh/dYzaM4I4W0jrCqjCVuUh99+xd9KamUfmCGPvbO8NDngo/vsnNVqgw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/scope-manager@8.57.2': + resolution: {integrity: sha512-snZKH+W4WbWkrBqj4gUNRIGb/jipDW3qMqVJ4C9rzdFc+wLwruxk+2a5D+uoFcKPAqyqEnSb4l2ULuZf95eSkw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@typescript-eslint/tsconfig-utils@8.57.2': + resolution: {integrity: sha512-3Lm5DSM+DCowsUOJC+YqHHnKEfFh5CoGkj5Z31NQSNF4l5wdOwqGn99wmwN/LImhfY3KJnmordBq/4+VDe2eKw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/type-utils@8.57.2': + resolution: {integrity: sha512-Co6ZCShm6kIbAM/s+oYVpKFfW7LBc6FXoPXjTRQ449PPNBY8U0KZXuevz5IFuuUj2H9ss40atTaf9dlGLzbWZg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 || ^10.0.0 + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/types@8.57.2': + resolution: {integrity: sha512-/iZM6FnM4tnx9csuTxspMW4BOSegshwX5oBDznJ7S4WggL7Vczz5d2W11ecc4vRrQMQHXRSxzrCsyG5EsPPTbA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@typescript-eslint/typescript-estree@8.57.2': + resolution: {integrity: sha512-2MKM+I6g8tJxfSmFKOnHv2t8Sk3T6rF20A1Puk0svLK+uVapDZB/4pfAeB7nE83uAZrU6OxW+HmOd5wHVdXwXA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/utils@8.57.2': + resolution: {integrity: sha512-krRIbvPK1ju1WBKIefiX+bngPs+odIQUtR7kymzPfo1POVw3jlF+nLkmexdSSd4UCbDcQn+wMBATOOmpBbqgKg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 || ^10.0.0 + typescript: '>=4.8.4 <6.0.0' + + '@typescript-eslint/visitor-keys@8.57.2': + resolution: {integrity: sha512-zhahknjobV2FiD6Ee9iLbS7OV9zi10rG26odsQdfBO/hjSzUQbkIYgda+iNKK1zNiW2ey+Lf8MU5btN17V3dUw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + '@vitejs/plugin-basic-ssl@2.3.0': + resolution: {integrity: sha512-bdyo8rB3NnQbikdMpHaML9Z1OZPBu6fFOBo+OtxsBlvMJtysWskmBcnbIDhUqgC8tcxNv/a+BcV5U+2nQMm1OQ==} + engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0} + peerDependencies: + vite: ^6.0.0 || ^7.0.0 || ^8.0.0 + + '@vitejs/plugin-react@5.2.0': + resolution: {integrity: sha512-YmKkfhOAi3wsB1PhJq5Scj3GXMn3WvtQ/JC0xoopuHoXSdmtdStOpFrYaT1kie2YgFBcIe64ROzMYRjCrYOdYw==} + engines: {node: ^20.19.0 || >=22.12.0} + peerDependencies: + vite: ^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 + + '@vitest/expect@3.2.4': + resolution: {integrity: sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==} + + '@vitest/mocker@3.2.4': + resolution: {integrity: sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==} + peerDependencies: + msw: ^2.4.9 + vite: ^5.0.0 || ^6.0.0 || ^7.0.0-0 + peerDependenciesMeta: + msw: + optional: true + vite: + optional: true + + '@vitest/pretty-format@3.2.4': + resolution: {integrity: sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==} + + '@vitest/runner@3.2.4': + resolution: {integrity: sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==} + + '@vitest/snapshot@3.2.4': + resolution: {integrity: sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==} + + '@vitest/spy@3.2.4': + resolution: {integrity: sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==} + + '@vitest/utils@3.2.4': + resolution: {integrity: sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==} + + acorn-jsx@5.3.2: + resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + + acorn@8.16.0: + resolution: {integrity: sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==} + engines: {node: '>=0.4.0'} + hasBin: true + + agent-base@7.1.4: + resolution: {integrity: sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==} + engines: {node: '>= 14'} + + ajv@6.14.0: + resolution: {integrity: sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==} + + ansi-regex@5.0.1: + resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} + engines: {node: '>=8'} + + ansi-styles@4.3.0: + resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} + engines: {node: '>=8'} + + ansi-styles@5.2.0: + resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} + engines: {node: '>=10'} + + argparse@2.0.1: + resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + + aria-query@5.3.0: + resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==} + + aria-query@5.3.2: + resolution: {integrity: sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==} + engines: {node: '>= 0.4'} + + assertion-error@2.0.1: + resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==} + engines: {node: '>=12'} + + balanced-match@1.0.2: + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + + balanced-match@4.0.4: + resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==} + engines: {node: 18 || 20 || >=22} + + base64-js@1.5.1: + resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} + + baseline-browser-mapping@2.10.12: + resolution: {integrity: sha512-qyq26DxfY4awP2gIRXhhLWfwzwI+N5Nxk6iQi8EFizIaWIjqicQTE4sLnZZVdeKPRcVNoJOkkpfzoIYuvCKaIQ==} + engines: {node: '>=6.0.0'} + hasBin: true + + brace-expansion@1.1.13: + resolution: {integrity: sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==} + + brace-expansion@5.0.5: + resolution: {integrity: sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==} + engines: {node: 18 || 20 || >=22} + + browserslist@4.28.1: + resolution: {integrity: sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==} + engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} + hasBin: true + + cac@6.7.14: + resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} + engines: {node: '>=8'} + + callsites@3.1.0: + resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} + engines: {node: '>=6'} + + caniuse-lite@1.0.30001781: + resolution: {integrity: sha512-RdwNCyMsNBftLjW6w01z8bKEvT6e/5tpPVEgtn22TiLGlstHOVecsX2KHFkD5e/vRnIE4EGzpuIODb3mtswtkw==} + + chai@5.3.3: + resolution: {integrity: sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==} + engines: {node: '>=18'} + + chalk@4.1.2: + resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} + engines: {node: '>=10'} + + check-error@2.1.3: + resolution: {integrity: sha512-PAJdDJusoxnwm1VwW07VWwUN1sl7smmC3OKggvndJFadxxDRyFJBX/ggnu/KE4kQAB7a3Dp8f/YXC1FlUprWmA==} + engines: {node: '>= 16'} + + color-convert@2.0.1: + resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} + engines: {node: '>=7.0.0'} + + color-name@1.1.4: + resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + + concat-map@0.0.1: + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + + convert-source-map@2.0.0: + resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + + cross-spawn@7.0.6: + resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} + engines: {node: '>= 8'} + + css.escape@1.5.1: + resolution: {integrity: sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==} + + cssstyle@4.6.0: + resolution: {integrity: sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==} + engines: {node: '>=18'} + + csstype@3.2.3: + resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==} + + data-urls@5.0.0: + resolution: {integrity: sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==} + engines: {node: '>=18'} + + debug@4.4.3: + resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + + decimal.js@10.6.0: + resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==} + + deep-eql@5.0.2: + resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==} + engines: {node: '>=6'} + + deep-is@0.1.4: + resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} + + dequal@2.0.3: + resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} + engines: {node: '>=6'} + + dom-accessibility-api@0.5.16: + resolution: {integrity: sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==} + + dom-accessibility-api@0.6.3: + resolution: {integrity: sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==} + + electron-to-chromium@1.5.328: + resolution: {integrity: sha512-QNQ5l45DzYytThO21403XN3FvK0hOkWDG8viNf6jqS42msJ8I4tGDSpBCgvDRRPnkffafiwAym2X2eHeGD2V0w==} + + entities@6.0.1: + resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==} + engines: {node: '>=0.12'} + + es-module-lexer@1.7.0: + resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==} + + esbuild@0.27.4: + resolution: {integrity: sha512-Rq4vbHnYkK5fws5NF7MYTU68FPRE1ajX7heQ/8QXXWqNgqqJ/GkmmyxIzUnf2Sr/bakf8l54716CcMGHYhMrrQ==} + engines: {node: '>=18'} + hasBin: true + + escalade@3.2.0: + resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} + engines: {node: '>=6'} + + escape-string-regexp@4.0.0: + resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} + engines: {node: '>=10'} + + eslint-plugin-react-hooks@5.2.0: + resolution: {integrity: sha512-+f15FfK64YQwZdJNELETdn5ibXEUQmW1DZL6KXhNnc2heoy/sg9VJJeT7n8TlMWouzWqSWavFkIhHyIbIAEapg==} + engines: {node: '>=10'} + peerDependencies: + eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0 + + eslint-plugin-react-refresh@0.4.26: + resolution: {integrity: sha512-1RETEylht2O6FM/MvgnyvT+8K21wLqDNg4qD51Zj3guhjt433XbnnkVttHMyaVyAFD03QSV4LPS5iE3VQmO7XQ==} + peerDependencies: + eslint: '>=8.40' + + eslint-scope@8.4.0: + resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + eslint-visitor-keys@3.4.3: + resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + eslint-visitor-keys@4.2.1: + resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + eslint-visitor-keys@5.0.1: + resolution: {integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==} + engines: {node: ^20.19.0 || ^22.13.0 || >=24} + + eslint@9.39.4: + resolution: {integrity: sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + hasBin: true + peerDependencies: + jiti: '*' + peerDependenciesMeta: + jiti: + optional: true + + espree@10.4.0: + resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + + esquery@1.7.0: + resolution: {integrity: sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==} + engines: {node: '>=0.10'} + + esrecurse@4.3.0: + resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} + engines: {node: '>=4.0'} + + estraverse@5.3.0: + resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} + engines: {node: '>=4.0'} + + estree-walker@3.0.3: + resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} + + esutils@2.0.3: + resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} + engines: {node: '>=0.10.0'} + + expect-type@1.3.0: + resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==} + engines: {node: '>=12.0.0'} + + fast-deep-equal@3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + + fast-json-stable-stringify@2.1.0: + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + + fast-levenshtein@2.0.6: + resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} + + fdir@6.5.0: + resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==} + engines: {node: '>=12.0.0'} + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true + + file-entry-cache@8.0.0: + resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==} + engines: {node: '>=16.0.0'} + + find-up@5.0.0: + resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} + engines: {node: '>=10'} + + flat-cache@4.0.1: + resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==} + engines: {node: '>=16'} + + flatted@3.4.2: + resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==} + + fsevents@2.3.3: + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + + gensync@1.0.0-beta.2: + resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} + engines: {node: '>=6.9.0'} + + glob-parent@6.0.2: + resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} + engines: {node: '>=10.13.0'} + + globals@14.0.0: + resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==} + engines: {node: '>=18'} + + globals@15.15.0: + resolution: {integrity: sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg==} + engines: {node: '>=18'} + + has-flag@4.0.0: + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} + + headers-polyfill@4.0.3: + resolution: {integrity: sha512-IScLbePpkvO846sIwOtOTDjutRMWdXdJmXdMvk6gCBHxFO8d+QKOQedyZSxFTTFYRSmlgSTDtXqqq4pcenBXLQ==} + + html-encoding-sniffer@4.0.0: + resolution: {integrity: sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==} + engines: {node: '>=18'} + + http-proxy-agent@7.0.2: + resolution: {integrity: sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==} + engines: {node: '>= 14'} + + https-proxy-agent@7.0.6: + resolution: {integrity: sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==} + engines: {node: '>= 14'} + + iconv-lite@0.6.3: + resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==} + engines: {node: '>=0.10.0'} + + ignore@5.3.2: + resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} + engines: {node: '>= 4'} + + ignore@7.0.5: + resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==} + engines: {node: '>= 4'} + + import-fresh@3.3.1: + resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==} + engines: {node: '>=6'} + + imurmurhash@0.1.4: + resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} + engines: {node: '>=0.8.19'} + + indent-string@4.0.0: + resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} + engines: {node: '>=8'} + + is-extglob@2.1.1: + resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} + engines: {node: '>=0.10.0'} + + is-glob@4.0.3: + resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} + engines: {node: '>=0.10.0'} + + is-potential-custom-element-name@1.0.1: + resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==} + + isexe@2.0.0: + resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + + js-tokens@4.0.0: + resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + + js-tokens@9.0.1: + resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==} + + js-yaml@4.1.1: + resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==} + hasBin: true + + jsdom@26.1.0: + resolution: {integrity: sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==} + engines: {node: '>=18'} + peerDependencies: + canvas: ^3.0.0 + peerDependenciesMeta: + canvas: + optional: true + + jsesc@3.1.0: + resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==} + engines: {node: '>=6'} + hasBin: true + + json-buffer@3.0.1: + resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} + + json-schema-traverse@0.4.1: + resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} + + json-stable-stringify-without-jsonify@1.0.1: + resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} + + json5@2.2.3: + resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} + engines: {node: '>=6'} + hasBin: true + + jwt-decode@4.0.0: + resolution: {integrity: sha512-+KJGIyHgkGuIq3IEBNftfhW/LfWhXUIY6OmyVWjliu5KH1y0fw7VQ8YndE2O4qZdMSd9SqbnC8GOcZEy0Om7sA==} + engines: {node: '>=18'} + + keyv@4.5.4: + resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} + + levn@0.4.1: + resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} + engines: {node: '>= 0.8.0'} + + locate-path@6.0.0: + resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} + engines: {node: '>=10'} + + lodash.merge@4.6.2: + resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + + loose-envify@1.4.0: + resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==} + hasBin: true + + loupe@3.2.1: + resolution: {integrity: sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==} + + lru-cache@10.4.3: + resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==} + + lru-cache@5.1.1: + resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} + + lz-string@1.5.0: + resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==} + hasBin: true + + magic-string@0.30.21: + resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==} + + min-indent@1.0.1: + resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==} + engines: {node: '>=4'} + + minimatch@10.2.4: + resolution: {integrity: sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==} + engines: {node: 18 || 20 || >=22} + + minimatch@3.1.5: + resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==} + + ms@2.1.3: + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + + nanoid@3.3.11: + resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==} + engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} + hasBin: true + + natural-compare@1.4.0: + resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} + + node-releases@2.0.36: + resolution: {integrity: sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==} + + nwsapi@2.2.23: + resolution: {integrity: sha512-7wfH4sLbt4M0gCDzGE6vzQBo0bfTKjU7Sfpqy/7gs1qBfYz2vEJH6vXcBKpO3+6Yu1telwd0t9HpyOoLEQQbIQ==} + + object-inspect@1.13.4: + resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==} + engines: {node: '>= 0.4'} + + oidc-client-ts@3.5.0: + resolution: {integrity: sha512-l2q8l9CTCTOlbX+AnK4p3M+4CEpKpyQhle6blQkdFhm0IsBqsxm15bYaSa11G7pWdsYr6epdsRZxJpCyCRbT8A==} + engines: {node: '>=18'} + + optionator@0.9.4: + resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} + engines: {node: '>= 0.8.0'} + + p-limit@3.1.0: + resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} + engines: {node: '>=10'} + + p-locate@5.0.0: + resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} + engines: {node: '>=10'} + + parent-module@1.0.1: + resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} + engines: {node: '>=6'} + + parse5@7.3.0: + resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==} + + path-exists@4.0.0: + resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} + engines: {node: '>=8'} + + path-key@3.1.1: + resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} + engines: {node: '>=8'} + + pathe@2.0.3: + resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==} + + pathval@2.0.1: + resolution: {integrity: sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==} + engines: {node: '>= 14.16'} + + picocolors@1.1.1: + resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} + + picomatch@4.0.4: + resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==} + engines: {node: '>=12'} + + postcss@8.5.8: + resolution: {integrity: sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==} + engines: {node: ^10 || ^12 || >=14} + + prelude-ls@1.2.1: + resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} + engines: {node: '>= 0.8.0'} + + prettier@3.8.1: + resolution: {integrity: sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==} + engines: {node: '>=14'} + hasBin: true + + pretty-format@27.5.1: + resolution: {integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==} + engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0} + + punycode@2.3.1: + resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} + engines: {node: '>=6'} + + pure-rand@7.0.1: + resolution: {integrity: sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ==} + + react-dom@18.3.1: + resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==} + peerDependencies: + react: ^18.3.1 + + react-is@17.0.2: + resolution: {integrity: sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==} + + react-oidc-context@3.3.1: + resolution: {integrity: sha512-/Azvm9W4DhhOtSDBE73kFInh1b6zZRRfILKbgmk2syExMF0PCYJOn/dGdOOi2BFX8x0rCeUe45NXHU+/+xDcrQ==} + engines: {node: '>=18'} + peerDependencies: + oidc-client-ts: ^3.1.0 + react: '>=16.14.0' + + react-refresh@0.18.0: + resolution: {integrity: sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==} + engines: {node: '>=0.10.0'} + + react@18.3.1: + resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==} + engines: {node: '>=0.10.0'} + + redent@3.0.0: + resolution: {integrity: sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==} + engines: {node: '>=8'} + + resolve-from@4.0.0: + resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} + engines: {node: '>=4'} + + rollup@4.60.0: + resolution: {integrity: sha512-yqjxruMGBQJ2gG4HtjZtAfXArHomazDHoFwFFmZZl0r7Pdo7qCIXKqKHZc8yeoMgzJJ+pO6pEEHa+V7uzWlrAQ==} + engines: {node: '>=18.0.0', npm: '>=8.0.0'} + hasBin: true + + rrweb-cssom@0.8.0: + resolution: {integrity: sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==} + + safe-stable-stringify@2.5.0: + resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==} + engines: {node: '>=10'} + + safer-buffer@2.1.2: + resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} + + saxes@6.0.0: + resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==} + engines: {node: '>=v12.22.7'} + + scheduler@0.23.2: + resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==} + + semver@6.3.1: + resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} + hasBin: true + + semver@7.7.4: + resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==} + engines: {node: '>=10'} + hasBin: true + + shebang-command@2.0.0: + resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} + engines: {node: '>=8'} + + shebang-regex@3.0.0: + resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} + engines: {node: '>=8'} + + siginfo@2.0.0: + resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==} + + source-map-js@1.2.1: + resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} + engines: {node: '>=0.10.0'} + + spacetimedb@2.1.0: + resolution: {integrity: sha512-Kzs+HXCRj15ryld03ztU4a2uQg0M8ivV/9Bk/gvMpb59lLc/A2/r7UkGCYBePsBL7Zwqgr8gE8FeufoZVXtPnA==} + peerDependencies: + '@angular/core': '>=17.0.0' + '@tanstack/react-query': ^5.0.0 + react: ^18.0.0 || ^19.0.0-0 || ^19.0.0 + svelte: ^4.0.0 || ^5.0.0 + undici: ^6.19.2 + vue: ^3.3.0 + peerDependenciesMeta: + '@angular/core': + optional: true + '@tanstack/react-query': + optional: true + react: + optional: true + svelte: + optional: true + undici: + optional: true + vue: + optional: true + + stackback@0.0.2: + resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==} + + statuses@2.0.2: + resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==} + engines: {node: '>= 0.8'} + + std-env@3.10.0: + resolution: {integrity: sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==} + + strip-indent@3.0.0: + resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==} + engines: {node: '>=8'} + + strip-json-comments@3.1.1: + resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} + engines: {node: '>=8'} + + strip-literal@3.1.0: + resolution: {integrity: sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==} + + supports-color@7.2.0: + resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} + engines: {node: '>=8'} + + symbol-tree@3.2.4: + resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==} + + tinybench@2.9.0: + resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==} + + tinyexec@0.3.2: + resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==} + + tinyglobby@0.2.15: + resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==} + engines: {node: '>=12.0.0'} + + tinypool@1.1.1: + resolution: {integrity: sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==} + engines: {node: ^18.0.0 || >=20.0.0} + + tinyrainbow@2.0.0: + resolution: {integrity: sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==} + engines: {node: '>=14.0.0'} + + tinyspy@4.0.4: + resolution: {integrity: sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==} + engines: {node: '>=14.0.0'} + + tldts-core@6.1.86: + resolution: {integrity: sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==} + + tldts@6.1.86: + resolution: {integrity: sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==} + hasBin: true + + tough-cookie@5.1.2: + resolution: {integrity: sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==} + engines: {node: '>=16'} + + tr46@5.1.1: + resolution: {integrity: sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==} + engines: {node: '>=18'} + + ts-api-utils@2.5.0: + resolution: {integrity: sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==} + engines: {node: '>=18.12'} + peerDependencies: + typescript: '>=4.8.4' + + type-check@0.4.0: + resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} + engines: {node: '>= 0.8.0'} + + typescript-eslint@8.57.2: + resolution: {integrity: sha512-VEPQ0iPgWO/sBaZOU1xo4nuNdODVOajPnTIbog2GKYr31nIlZ0fWPoCQgGfF3ETyBl1vn63F/p50Um9Z4J8O8A==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 || ^10.0.0 + typescript: '>=4.8.4 <6.0.0' + + typescript@5.6.3: + resolution: {integrity: sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==} + engines: {node: '>=14.17'} + hasBin: true + + update-browserslist-db@1.2.3: + resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==} + hasBin: true + peerDependencies: + browserslist: '>= 4.21.0' + + uri-js@4.4.1: + resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + + url-polyfill@1.1.14: + resolution: {integrity: sha512-p4f3TTAG6ADVF3mwbXw7hGw+QJyw5CnNGvYh5fCuQQZIiuKUswqcznyV3pGDP9j0TSmC4UvRKm8kl1QsX1diiQ==} + + vite-node@3.2.4: + resolution: {integrity: sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==} + engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0} + hasBin: true + + vite@7.3.1: + resolution: {integrity: sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==} + engines: {node: ^20.19.0 || >=22.12.0} + hasBin: true + peerDependencies: + '@types/node': ^20.19.0 || >=22.12.0 + jiti: '>=1.21.0' + less: ^4.0.0 + lightningcss: ^1.21.0 + sass: ^1.70.0 + sass-embedded: ^1.70.0 + stylus: '>=0.54.8' + sugarss: ^5.0.0 + terser: ^5.16.0 + tsx: ^4.8.1 + yaml: ^2.4.2 + peerDependenciesMeta: + '@types/node': + optional: true + jiti: + optional: true + less: + optional: true + lightningcss: + optional: true + sass: + optional: true + sass-embedded: + optional: true + stylus: + optional: true + sugarss: + optional: true + terser: + optional: true + tsx: + optional: true + yaml: + optional: true + + vitest@3.2.4: + resolution: {integrity: sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==} + engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0} + hasBin: true + peerDependencies: + '@edge-runtime/vm': '*' + '@types/debug': ^4.1.12 + '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0 + '@vitest/browser': 3.2.4 + '@vitest/ui': 3.2.4 + happy-dom: '*' + jsdom: '*' + peerDependenciesMeta: + '@edge-runtime/vm': + optional: true + '@types/debug': + optional: true + '@types/node': + optional: true + '@vitest/browser': + optional: true + '@vitest/ui': + optional: true + happy-dom: + optional: true + jsdom: + optional: true + + w3c-xmlserializer@5.0.0: + resolution: {integrity: sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==} + engines: {node: '>=18'} + + webidl-conversions@7.0.0: + resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==} + engines: {node: '>=12'} + + whatwg-encoding@3.1.1: + resolution: {integrity: sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==} + engines: {node: '>=18'} + deprecated: Use @exodus/bytes instead for a more spec-conformant and faster implementation + + whatwg-mimetype@4.0.0: + resolution: {integrity: sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==} + engines: {node: '>=18'} + + whatwg-url@14.2.0: + resolution: {integrity: sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==} + engines: {node: '>=18'} + + which@2.0.2: + resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} + engines: {node: '>= 8'} + hasBin: true + + why-is-node-running@2.3.0: + resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==} + engines: {node: '>=8'} + hasBin: true + + word-wrap@1.2.5: + resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==} + engines: {node: '>=0.10.0'} + + ws@8.20.0: + resolution: {integrity: sha512-sAt8BhgNbzCtgGbt2OxmpuryO63ZoDk/sqaB/znQm94T4fCEsy/yV+7CdC1kJhOU9lboAEU7R3kquuycDoibVA==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + xml-name-validator@5.0.0: + resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==} + engines: {node: '>=18'} + + xmlchars@2.2.0: + resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==} + + yallist@3.1.1: + resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} + + yocto-queue@0.1.0: + resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} + engines: {node: '>=10'} + +snapshots: + + '@adobe/css-tools@4.4.4': {} + + '@asamuzakjp/css-color@3.2.0': + dependencies: + '@csstools/css-calc': 2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4) + '@csstools/css-color-parser': 3.1.0(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4) + '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4) + '@csstools/css-tokenizer': 3.0.4 + lru-cache: 10.4.3 + + '@babel/code-frame@7.29.0': + dependencies: + '@babel/helper-validator-identifier': 7.28.5 + js-tokens: 4.0.0 + picocolors: 1.1.1 + + '@babel/compat-data@7.29.0': {} + + '@babel/core@7.29.0': + dependencies: + '@babel/code-frame': 7.29.0 + '@babel/generator': 7.29.1 + '@babel/helper-compilation-targets': 7.28.6 + '@babel/helper-module-transforms': 7.28.6(@babel/core@7.29.0) + '@babel/helpers': 7.29.2 + '@babel/parser': 7.29.2 + '@babel/template': 7.28.6 + '@babel/traverse': 7.29.0 + '@babel/types': 7.29.0 + '@jridgewell/remapping': 2.3.5 + convert-source-map: 2.0.0 + debug: 4.4.3 + gensync: 1.0.0-beta.2 + json5: 2.2.3 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + + '@babel/generator@7.29.1': + dependencies: + '@babel/parser': 7.29.2 + '@babel/types': 7.29.0 + '@jridgewell/gen-mapping': 0.3.13 + '@jridgewell/trace-mapping': 0.3.31 + jsesc: 3.1.0 + + '@babel/helper-compilation-targets@7.28.6': + dependencies: + '@babel/compat-data': 7.29.0 + '@babel/helper-validator-option': 7.27.1 + browserslist: 4.28.1 + lru-cache: 5.1.1 + semver: 6.3.1 + + '@babel/helper-globals@7.28.0': {} + + '@babel/helper-module-imports@7.28.6': + dependencies: + '@babel/traverse': 7.29.0 + '@babel/types': 7.29.0 + transitivePeerDependencies: + - supports-color + + '@babel/helper-module-transforms@7.28.6(@babel/core@7.29.0)': + dependencies: + '@babel/core': 7.29.0 + '@babel/helper-module-imports': 7.28.6 + '@babel/helper-validator-identifier': 7.28.5 + '@babel/traverse': 7.29.0 + transitivePeerDependencies: + - supports-color + + '@babel/helper-plugin-utils@7.28.6': {} + + '@babel/helper-string-parser@7.27.1': {} + + '@babel/helper-validator-identifier@7.28.5': {} + + '@babel/helper-validator-option@7.27.1': {} + + '@babel/helpers@7.29.2': + dependencies: + '@babel/template': 7.28.6 + '@babel/types': 7.29.0 + + '@babel/parser@7.29.2': + dependencies: + '@babel/types': 7.29.0 + + '@babel/plugin-transform-react-jsx-self@7.27.1(@babel/core@7.29.0)': + dependencies: + '@babel/core': 7.29.0 + '@babel/helper-plugin-utils': 7.28.6 + + '@babel/plugin-transform-react-jsx-source@7.27.1(@babel/core@7.29.0)': + dependencies: + '@babel/core': 7.29.0 + '@babel/helper-plugin-utils': 7.28.6 + + '@babel/runtime@7.29.2': {} + + '@babel/template@7.28.6': + dependencies: + '@babel/code-frame': 7.29.0 + '@babel/parser': 7.29.2 + '@babel/types': 7.29.0 + + '@babel/traverse@7.29.0': + dependencies: + '@babel/code-frame': 7.29.0 + '@babel/generator': 7.29.1 + '@babel/helper-globals': 7.28.0 + '@babel/parser': 7.29.2 + '@babel/template': 7.28.6 + '@babel/types': 7.29.0 + debug: 4.4.3 + transitivePeerDependencies: + - supports-color + + '@babel/types@7.29.0': + dependencies: + '@babel/helper-string-parser': 7.27.1 + '@babel/helper-validator-identifier': 7.28.5 + + '@csstools/color-helpers@5.1.0': {} + + '@csstools/css-calc@2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)': + dependencies: + '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4) + '@csstools/css-tokenizer': 3.0.4 + + '@csstools/css-color-parser@3.1.0(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4)': + dependencies: + '@csstools/color-helpers': 5.1.0 + '@csstools/css-calc': 2.1.4(@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4))(@csstools/css-tokenizer@3.0.4) + '@csstools/css-parser-algorithms': 3.0.5(@csstools/css-tokenizer@3.0.4) + '@csstools/css-tokenizer': 3.0.4 + + '@csstools/css-parser-algorithms@3.0.5(@csstools/css-tokenizer@3.0.4)': + dependencies: + '@csstools/css-tokenizer': 3.0.4 + + '@csstools/css-tokenizer@3.0.4': {} + + '@esbuild/aix-ppc64@0.27.4': + optional: true + + '@esbuild/android-arm64@0.27.4': + optional: true + + '@esbuild/android-arm@0.27.4': + optional: true + + '@esbuild/android-x64@0.27.4': + optional: true + + '@esbuild/darwin-arm64@0.27.4': + optional: true + + '@esbuild/darwin-x64@0.27.4': + optional: true + + '@esbuild/freebsd-arm64@0.27.4': + optional: true + + '@esbuild/freebsd-x64@0.27.4': + optional: true + + '@esbuild/linux-arm64@0.27.4': + optional: true + + '@esbuild/linux-arm@0.27.4': + optional: true + + '@esbuild/linux-ia32@0.27.4': + optional: true + + '@esbuild/linux-loong64@0.27.4': + optional: true + + '@esbuild/linux-mips64el@0.27.4': + optional: true + + '@esbuild/linux-ppc64@0.27.4': + optional: true + + '@esbuild/linux-riscv64@0.27.4': + optional: true + + '@esbuild/linux-s390x@0.27.4': + optional: true + + '@esbuild/linux-x64@0.27.4': + optional: true + + '@esbuild/netbsd-arm64@0.27.4': + optional: true + + '@esbuild/netbsd-x64@0.27.4': + optional: true + + '@esbuild/openbsd-arm64@0.27.4': + optional: true + + '@esbuild/openbsd-x64@0.27.4': + optional: true + + '@esbuild/openharmony-arm64@0.27.4': + optional: true + + '@esbuild/sunos-x64@0.27.4': + optional: true + + '@esbuild/win32-arm64@0.27.4': + optional: true + + '@esbuild/win32-ia32@0.27.4': + optional: true + + '@esbuild/win32-x64@0.27.4': + optional: true + + '@eslint-community/eslint-utils@4.9.1(eslint@9.39.4)': + dependencies: + eslint: 9.39.4 + eslint-visitor-keys: 3.4.3 + + '@eslint-community/regexpp@4.12.2': {} + + '@eslint/config-array@0.21.2': + dependencies: + '@eslint/object-schema': 2.1.7 + debug: 4.4.3 + minimatch: 3.1.5 + transitivePeerDependencies: + - supports-color + + '@eslint/config-helpers@0.4.2': + dependencies: + '@eslint/core': 0.17.0 + + '@eslint/core@0.17.0': + dependencies: + '@types/json-schema': 7.0.15 + + '@eslint/eslintrc@3.3.5': + dependencies: + ajv: 6.14.0 + debug: 4.4.3 + espree: 10.4.0 + globals: 14.0.0 + ignore: 5.3.2 + import-fresh: 3.3.1 + js-yaml: 4.1.1 + minimatch: 3.1.5 + strip-json-comments: 3.1.1 + transitivePeerDependencies: + - supports-color + + '@eslint/js@9.39.4': {} + + '@eslint/object-schema@2.1.7': {} + + '@eslint/plugin-kit@0.4.1': + dependencies: + '@eslint/core': 0.17.0 + levn: 0.4.1 + + '@humanfs/core@0.19.1': {} + + '@humanfs/node@0.16.7': + dependencies: + '@humanfs/core': 0.19.1 + '@humanwhocodes/retry': 0.4.3 + + '@humanwhocodes/module-importer@1.0.1': {} + + '@humanwhocodes/retry@0.4.3': {} + + '@jridgewell/gen-mapping@0.3.13': + dependencies: + '@jridgewell/sourcemap-codec': 1.5.5 + '@jridgewell/trace-mapping': 0.3.31 + + '@jridgewell/remapping@2.3.5': + dependencies: + '@jridgewell/gen-mapping': 0.3.13 + '@jridgewell/trace-mapping': 0.3.31 + + '@jridgewell/resolve-uri@3.1.2': {} + + '@jridgewell/sourcemap-codec@1.5.5': {} + + '@jridgewell/trace-mapping@0.3.31': + dependencies: + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.5.5 + + '@rolldown/pluginutils@1.0.0-rc.3': {} + + '@rollup/rollup-android-arm-eabi@4.60.0': + optional: true + + '@rollup/rollup-android-arm64@4.60.0': + optional: true + + '@rollup/rollup-darwin-arm64@4.60.0': + optional: true + + '@rollup/rollup-darwin-x64@4.60.0': + optional: true + + '@rollup/rollup-freebsd-arm64@4.60.0': + optional: true + + '@rollup/rollup-freebsd-x64@4.60.0': + optional: true + + '@rollup/rollup-linux-arm-gnueabihf@4.60.0': + optional: true + + '@rollup/rollup-linux-arm-musleabihf@4.60.0': + optional: true + + '@rollup/rollup-linux-arm64-gnu@4.60.0': + optional: true + + '@rollup/rollup-linux-arm64-musl@4.60.0': + optional: true + + '@rollup/rollup-linux-loong64-gnu@4.60.0': + optional: true + + '@rollup/rollup-linux-loong64-musl@4.60.0': + optional: true + + '@rollup/rollup-linux-ppc64-gnu@4.60.0': + optional: true + + '@rollup/rollup-linux-ppc64-musl@4.60.0': + optional: true + + '@rollup/rollup-linux-riscv64-gnu@4.60.0': + optional: true + + '@rollup/rollup-linux-riscv64-musl@4.60.0': + optional: true + + '@rollup/rollup-linux-s390x-gnu@4.60.0': + optional: true + + '@rollup/rollup-linux-x64-gnu@4.60.0': + optional: true + + '@rollup/rollup-linux-x64-musl@4.60.0': + optional: true + + '@rollup/rollup-openbsd-x64@4.60.0': + optional: true + + '@rollup/rollup-openharmony-arm64@4.60.0': + optional: true + + '@rollup/rollup-win32-arm64-msvc@4.60.0': + optional: true + + '@rollup/rollup-win32-ia32-msvc@4.60.0': + optional: true + + '@rollup/rollup-win32-x64-gnu@4.60.0': + optional: true + + '@rollup/rollup-win32-x64-msvc@4.60.0': + optional: true + + '@testing-library/dom@10.4.1': + dependencies: + '@babel/code-frame': 7.29.0 + '@babel/runtime': 7.29.2 + '@types/aria-query': 5.0.4 + aria-query: 5.3.0 + dom-accessibility-api: 0.5.16 + lz-string: 1.5.0 + picocolors: 1.1.1 + pretty-format: 27.5.1 + + '@testing-library/jest-dom@6.9.1': + dependencies: + '@adobe/css-tools': 4.4.4 + aria-query: 5.3.2 + css.escape: 1.5.1 + dom-accessibility-api: 0.6.3 + picocolors: 1.1.1 + redent: 3.0.0 + + '@testing-library/react@16.3.2(@testing-library/dom@10.4.1)(@types/react-dom@18.3.7(@types/react@18.3.28))(@types/react@18.3.28)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)': + dependencies: + '@babel/runtime': 7.29.2 + '@testing-library/dom': 10.4.1 + react: 18.3.1 + react-dom: 18.3.1(react@18.3.1) + optionalDependencies: + '@types/react': 18.3.28 + '@types/react-dom': 18.3.7(@types/react@18.3.28) + + '@testing-library/user-event@14.6.1(@testing-library/dom@10.4.1)': + dependencies: + '@testing-library/dom': 10.4.1 + + '@types/aria-query@5.0.4': {} + + '@types/babel__core@7.20.5': + dependencies: + '@babel/parser': 7.29.2 + '@babel/types': 7.29.0 + '@types/babel__generator': 7.27.0 + '@types/babel__template': 7.4.4 + '@types/babel__traverse': 7.28.0 + + '@types/babel__generator@7.27.0': + dependencies: + '@babel/types': 7.29.0 + + '@types/babel__template@7.4.4': + dependencies: + '@babel/parser': 7.29.2 + '@babel/types': 7.29.0 + + '@types/babel__traverse@7.28.0': + dependencies: + '@babel/types': 7.29.0 + + '@types/chai@5.2.3': + dependencies: + '@types/deep-eql': 4.0.2 + assertion-error: 2.0.1 + + '@types/deep-eql@4.0.2': {} + + '@types/estree@1.0.8': {} + + '@types/json-schema@7.0.15': {} + + '@types/prop-types@15.7.15': {} + + '@types/react-dom@18.3.7(@types/react@18.3.28)': + dependencies: + '@types/react': 18.3.28 + + '@types/react@18.3.28': + dependencies: + '@types/prop-types': 15.7.15 + csstype: 3.2.3 + + '@typescript-eslint/eslint-plugin@8.57.2(@typescript-eslint/parser@8.57.2(eslint@9.39.4)(typescript@5.6.3))(eslint@9.39.4)(typescript@5.6.3)': + dependencies: + '@eslint-community/regexpp': 4.12.2 + '@typescript-eslint/parser': 8.57.2(eslint@9.39.4)(typescript@5.6.3) + '@typescript-eslint/scope-manager': 8.57.2 + '@typescript-eslint/type-utils': 8.57.2(eslint@9.39.4)(typescript@5.6.3) + '@typescript-eslint/utils': 8.57.2(eslint@9.39.4)(typescript@5.6.3) + '@typescript-eslint/visitor-keys': 8.57.2 + eslint: 9.39.4 + ignore: 7.0.5 + natural-compare: 1.4.0 + ts-api-utils: 2.5.0(typescript@5.6.3) + typescript: 5.6.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/parser@8.57.2(eslint@9.39.4)(typescript@5.6.3)': + dependencies: + '@typescript-eslint/scope-manager': 8.57.2 + '@typescript-eslint/types': 8.57.2 + '@typescript-eslint/typescript-estree': 8.57.2(typescript@5.6.3) + '@typescript-eslint/visitor-keys': 8.57.2 + debug: 4.4.3 + eslint: 9.39.4 + typescript: 5.6.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/project-service@8.57.2(typescript@5.6.3)': + dependencies: + '@typescript-eslint/tsconfig-utils': 8.57.2(typescript@5.6.3) + '@typescript-eslint/types': 8.57.2 + debug: 4.4.3 + typescript: 5.6.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/scope-manager@8.57.2': + dependencies: + '@typescript-eslint/types': 8.57.2 + '@typescript-eslint/visitor-keys': 8.57.2 + + '@typescript-eslint/tsconfig-utils@8.57.2(typescript@5.6.3)': + dependencies: + typescript: 5.6.3 + + '@typescript-eslint/type-utils@8.57.2(eslint@9.39.4)(typescript@5.6.3)': + dependencies: + '@typescript-eslint/types': 8.57.2 + '@typescript-eslint/typescript-estree': 8.57.2(typescript@5.6.3) + '@typescript-eslint/utils': 8.57.2(eslint@9.39.4)(typescript@5.6.3) + debug: 4.4.3 + eslint: 9.39.4 + ts-api-utils: 2.5.0(typescript@5.6.3) + typescript: 5.6.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/types@8.57.2': {} + + '@typescript-eslint/typescript-estree@8.57.2(typescript@5.6.3)': + dependencies: + '@typescript-eslint/project-service': 8.57.2(typescript@5.6.3) + '@typescript-eslint/tsconfig-utils': 8.57.2(typescript@5.6.3) + '@typescript-eslint/types': 8.57.2 + '@typescript-eslint/visitor-keys': 8.57.2 + debug: 4.4.3 + minimatch: 10.2.4 + semver: 7.7.4 + tinyglobby: 0.2.15 + ts-api-utils: 2.5.0(typescript@5.6.3) + typescript: 5.6.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/utils@8.57.2(eslint@9.39.4)(typescript@5.6.3)': + dependencies: + '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4) + '@typescript-eslint/scope-manager': 8.57.2 + '@typescript-eslint/types': 8.57.2 + '@typescript-eslint/typescript-estree': 8.57.2(typescript@5.6.3) + eslint: 9.39.4 + typescript: 5.6.3 + transitivePeerDependencies: + - supports-color + + '@typescript-eslint/visitor-keys@8.57.2': + dependencies: + '@typescript-eslint/types': 8.57.2 + eslint-visitor-keys: 5.0.1 + + '@vitejs/plugin-basic-ssl@2.3.0(vite@7.3.1)': + dependencies: + vite: 7.3.1 + + '@vitejs/plugin-react@5.2.0(vite@7.3.1)': + dependencies: + '@babel/core': 7.29.0 + '@babel/plugin-transform-react-jsx-self': 7.27.1(@babel/core@7.29.0) + '@babel/plugin-transform-react-jsx-source': 7.27.1(@babel/core@7.29.0) + '@rolldown/pluginutils': 1.0.0-rc.3 + '@types/babel__core': 7.20.5 + react-refresh: 0.18.0 + vite: 7.3.1 + transitivePeerDependencies: + - supports-color + + '@vitest/expect@3.2.4': + dependencies: + '@types/chai': 5.2.3 + '@vitest/spy': 3.2.4 + '@vitest/utils': 3.2.4 + chai: 5.3.3 + tinyrainbow: 2.0.0 + + '@vitest/mocker@3.2.4(vite@7.3.1)': + dependencies: + '@vitest/spy': 3.2.4 + estree-walker: 3.0.3 + magic-string: 0.30.21 + optionalDependencies: + vite: 7.3.1 + + '@vitest/pretty-format@3.2.4': + dependencies: + tinyrainbow: 2.0.0 + + '@vitest/runner@3.2.4': + dependencies: + '@vitest/utils': 3.2.4 + pathe: 2.0.3 + strip-literal: 3.1.0 + + '@vitest/snapshot@3.2.4': + dependencies: + '@vitest/pretty-format': 3.2.4 + magic-string: 0.30.21 + pathe: 2.0.3 + + '@vitest/spy@3.2.4': + dependencies: + tinyspy: 4.0.4 + + '@vitest/utils@3.2.4': + dependencies: + '@vitest/pretty-format': 3.2.4 + loupe: 3.2.1 + tinyrainbow: 2.0.0 + + acorn-jsx@5.3.2(acorn@8.16.0): + dependencies: + acorn: 8.16.0 + + acorn@8.16.0: {} + + agent-base@7.1.4: {} + + ajv@6.14.0: + dependencies: + fast-deep-equal: 3.1.3 + fast-json-stable-stringify: 2.1.0 + json-schema-traverse: 0.4.1 + uri-js: 4.4.1 + + ansi-regex@5.0.1: {} + + ansi-styles@4.3.0: + dependencies: + color-convert: 2.0.1 + + ansi-styles@5.2.0: {} + + argparse@2.0.1: {} + + aria-query@5.3.0: + dependencies: + dequal: 2.0.3 + + aria-query@5.3.2: {} + + assertion-error@2.0.1: {} + + balanced-match@1.0.2: {} + + balanced-match@4.0.4: {} + + base64-js@1.5.1: {} + + baseline-browser-mapping@2.10.12: {} + + brace-expansion@1.1.13: + dependencies: + balanced-match: 1.0.2 + concat-map: 0.0.1 + + brace-expansion@5.0.5: + dependencies: + balanced-match: 4.0.4 + + browserslist@4.28.1: + dependencies: + baseline-browser-mapping: 2.10.12 + caniuse-lite: 1.0.30001781 + electron-to-chromium: 1.5.328 + node-releases: 2.0.36 + update-browserslist-db: 1.2.3(browserslist@4.28.1) + + cac@6.7.14: {} + + callsites@3.1.0: {} + + caniuse-lite@1.0.30001781: {} + + chai@5.3.3: + dependencies: + assertion-error: 2.0.1 + check-error: 2.1.3 + deep-eql: 5.0.2 + loupe: 3.2.1 + pathval: 2.0.1 + + chalk@4.1.2: + dependencies: + ansi-styles: 4.3.0 + supports-color: 7.2.0 + + check-error@2.1.3: {} + + color-convert@2.0.1: + dependencies: + color-name: 1.1.4 + + color-name@1.1.4: {} + + concat-map@0.0.1: {} + + convert-source-map@2.0.0: {} + + cross-spawn@7.0.6: + dependencies: + path-key: 3.1.1 + shebang-command: 2.0.0 + which: 2.0.2 + + css.escape@1.5.1: {} + + cssstyle@4.6.0: + dependencies: + '@asamuzakjp/css-color': 3.2.0 + rrweb-cssom: 0.8.0 + + csstype@3.2.3: {} + + data-urls@5.0.0: + dependencies: + whatwg-mimetype: 4.0.0 + whatwg-url: 14.2.0 + + debug@4.4.3: + dependencies: + ms: 2.1.3 + + decimal.js@10.6.0: {} + + deep-eql@5.0.2: {} + + deep-is@0.1.4: {} + + dequal@2.0.3: {} + + dom-accessibility-api@0.5.16: {} + + dom-accessibility-api@0.6.3: {} + + electron-to-chromium@1.5.328: {} + + entities@6.0.1: {} + + es-module-lexer@1.7.0: {} + + esbuild@0.27.4: + optionalDependencies: + '@esbuild/aix-ppc64': 0.27.4 + '@esbuild/android-arm': 0.27.4 + '@esbuild/android-arm64': 0.27.4 + '@esbuild/android-x64': 0.27.4 + '@esbuild/darwin-arm64': 0.27.4 + '@esbuild/darwin-x64': 0.27.4 + '@esbuild/freebsd-arm64': 0.27.4 + '@esbuild/freebsd-x64': 0.27.4 + '@esbuild/linux-arm': 0.27.4 + '@esbuild/linux-arm64': 0.27.4 + '@esbuild/linux-ia32': 0.27.4 + '@esbuild/linux-loong64': 0.27.4 + '@esbuild/linux-mips64el': 0.27.4 + '@esbuild/linux-ppc64': 0.27.4 + '@esbuild/linux-riscv64': 0.27.4 + '@esbuild/linux-s390x': 0.27.4 + '@esbuild/linux-x64': 0.27.4 + '@esbuild/netbsd-arm64': 0.27.4 + '@esbuild/netbsd-x64': 0.27.4 + '@esbuild/openbsd-arm64': 0.27.4 + '@esbuild/openbsd-x64': 0.27.4 + '@esbuild/openharmony-arm64': 0.27.4 + '@esbuild/sunos-x64': 0.27.4 + '@esbuild/win32-arm64': 0.27.4 + '@esbuild/win32-ia32': 0.27.4 + '@esbuild/win32-x64': 0.27.4 + + escalade@3.2.0: {} + + escape-string-regexp@4.0.0: {} + + eslint-plugin-react-hooks@5.2.0(eslint@9.39.4): + dependencies: + eslint: 9.39.4 + + eslint-plugin-react-refresh@0.4.26(eslint@9.39.4): + dependencies: + eslint: 9.39.4 + + eslint-scope@8.4.0: + dependencies: + esrecurse: 4.3.0 + estraverse: 5.3.0 + + eslint-visitor-keys@3.4.3: {} + + eslint-visitor-keys@4.2.1: {} + + eslint-visitor-keys@5.0.1: {} + + eslint@9.39.4: + dependencies: + '@eslint-community/eslint-utils': 4.9.1(eslint@9.39.4) + '@eslint-community/regexpp': 4.12.2 + '@eslint/config-array': 0.21.2 + '@eslint/config-helpers': 0.4.2 + '@eslint/core': 0.17.0 + '@eslint/eslintrc': 3.3.5 + '@eslint/js': 9.39.4 + '@eslint/plugin-kit': 0.4.1 + '@humanfs/node': 0.16.7 + '@humanwhocodes/module-importer': 1.0.1 + '@humanwhocodes/retry': 0.4.3 + '@types/estree': 1.0.8 + ajv: 6.14.0 + chalk: 4.1.2 + cross-spawn: 7.0.6 + debug: 4.4.3 + escape-string-regexp: 4.0.0 + eslint-scope: 8.4.0 + eslint-visitor-keys: 4.2.1 + espree: 10.4.0 + esquery: 1.7.0 + esutils: 2.0.3 + fast-deep-equal: 3.1.3 + file-entry-cache: 8.0.0 + find-up: 5.0.0 + glob-parent: 6.0.2 + ignore: 5.3.2 + imurmurhash: 0.1.4 + is-glob: 4.0.3 + json-stable-stringify-without-jsonify: 1.0.1 + lodash.merge: 4.6.2 + minimatch: 3.1.5 + natural-compare: 1.4.0 + optionator: 0.9.4 + transitivePeerDependencies: + - supports-color + + espree@10.4.0: + dependencies: + acorn: 8.16.0 + acorn-jsx: 5.3.2(acorn@8.16.0) + eslint-visitor-keys: 4.2.1 + + esquery@1.7.0: + dependencies: + estraverse: 5.3.0 + + esrecurse@4.3.0: + dependencies: + estraverse: 5.3.0 + + estraverse@5.3.0: {} + + estree-walker@3.0.3: + dependencies: + '@types/estree': 1.0.8 + + esutils@2.0.3: {} + + expect-type@1.3.0: {} + + fast-deep-equal@3.1.3: {} + + fast-json-stable-stringify@2.1.0: {} + + fast-levenshtein@2.0.6: {} + + fdir@6.5.0(picomatch@4.0.4): + optionalDependencies: + picomatch: 4.0.4 + + file-entry-cache@8.0.0: + dependencies: + flat-cache: 4.0.1 + + find-up@5.0.0: + dependencies: + locate-path: 6.0.0 + path-exists: 4.0.0 + + flat-cache@4.0.1: + dependencies: + flatted: 3.4.2 + keyv: 4.5.4 + + flatted@3.4.2: {} + + fsevents@2.3.3: + optional: true + + gensync@1.0.0-beta.2: {} + + glob-parent@6.0.2: + dependencies: + is-glob: 4.0.3 + + globals@14.0.0: {} + + globals@15.15.0: {} + + has-flag@4.0.0: {} + + headers-polyfill@4.0.3: {} + + html-encoding-sniffer@4.0.0: + dependencies: + whatwg-encoding: 3.1.1 + + http-proxy-agent@7.0.2: + dependencies: + agent-base: 7.1.4 + debug: 4.4.3 + transitivePeerDependencies: + - supports-color + + https-proxy-agent@7.0.6: + dependencies: + agent-base: 7.1.4 + debug: 4.4.3 + transitivePeerDependencies: + - supports-color + + iconv-lite@0.6.3: + dependencies: + safer-buffer: 2.1.2 + + ignore@5.3.2: {} + + ignore@7.0.5: {} + + import-fresh@3.3.1: + dependencies: + parent-module: 1.0.1 + resolve-from: 4.0.0 + + imurmurhash@0.1.4: {} + + indent-string@4.0.0: {} + + is-extglob@2.1.1: {} + + is-glob@4.0.3: + dependencies: + is-extglob: 2.1.1 + + is-potential-custom-element-name@1.0.1: {} + + isexe@2.0.0: {} + + js-tokens@4.0.0: {} + + js-tokens@9.0.1: {} + + js-yaml@4.1.1: + dependencies: + argparse: 2.0.1 + + jsdom@26.1.0: + dependencies: + cssstyle: 4.6.0 + data-urls: 5.0.0 + decimal.js: 10.6.0 + html-encoding-sniffer: 4.0.0 + http-proxy-agent: 7.0.2 + https-proxy-agent: 7.0.6 + is-potential-custom-element-name: 1.0.1 + nwsapi: 2.2.23 + parse5: 7.3.0 + rrweb-cssom: 0.8.0 + saxes: 6.0.0 + symbol-tree: 3.2.4 + tough-cookie: 5.1.2 + w3c-xmlserializer: 5.0.0 + webidl-conversions: 7.0.0 + whatwg-encoding: 3.1.1 + whatwg-mimetype: 4.0.0 + whatwg-url: 14.2.0 + ws: 8.20.0 + xml-name-validator: 5.0.0 + transitivePeerDependencies: + - bufferutil + - supports-color + - utf-8-validate + + jsesc@3.1.0: {} + + json-buffer@3.0.1: {} + + json-schema-traverse@0.4.1: {} + + json-stable-stringify-without-jsonify@1.0.1: {} + + json5@2.2.3: {} + + jwt-decode@4.0.0: {} + + keyv@4.5.4: + dependencies: + json-buffer: 3.0.1 + + levn@0.4.1: + dependencies: + prelude-ls: 1.2.1 + type-check: 0.4.0 + + locate-path@6.0.0: + dependencies: + p-locate: 5.0.0 + + lodash.merge@4.6.2: {} + + loose-envify@1.4.0: + dependencies: + js-tokens: 4.0.0 + + loupe@3.2.1: {} + + lru-cache@10.4.3: {} + + lru-cache@5.1.1: + dependencies: + yallist: 3.1.1 + + lz-string@1.5.0: {} + + magic-string@0.30.21: + dependencies: + '@jridgewell/sourcemap-codec': 1.5.5 + + min-indent@1.0.1: {} + + minimatch@10.2.4: + dependencies: + brace-expansion: 5.0.5 + + minimatch@3.1.5: + dependencies: + brace-expansion: 1.1.13 + + ms@2.1.3: {} + + nanoid@3.3.11: {} + + natural-compare@1.4.0: {} + + node-releases@2.0.36: {} + + nwsapi@2.2.23: {} + + object-inspect@1.13.4: {} + + oidc-client-ts@3.5.0: + dependencies: + jwt-decode: 4.0.0 + + optionator@0.9.4: + dependencies: + deep-is: 0.1.4 + fast-levenshtein: 2.0.6 + levn: 0.4.1 + prelude-ls: 1.2.1 + type-check: 0.4.0 + word-wrap: 1.2.5 + + p-limit@3.1.0: + dependencies: + yocto-queue: 0.1.0 + + p-locate@5.0.0: + dependencies: + p-limit: 3.1.0 + + parent-module@1.0.1: + dependencies: + callsites: 3.1.0 + + parse5@7.3.0: + dependencies: + entities: 6.0.1 + + path-exists@4.0.0: {} + + path-key@3.1.1: {} + + pathe@2.0.3: {} + + pathval@2.0.1: {} + + picocolors@1.1.1: {} + + picomatch@4.0.4: {} + + postcss@8.5.8: + dependencies: + nanoid: 3.3.11 + picocolors: 1.1.1 + source-map-js: 1.2.1 + + prelude-ls@1.2.1: {} + + prettier@3.8.1: {} + + pretty-format@27.5.1: + dependencies: + ansi-regex: 5.0.1 + ansi-styles: 5.2.0 + react-is: 17.0.2 + + punycode@2.3.1: {} + + pure-rand@7.0.1: {} + + react-dom@18.3.1(react@18.3.1): + dependencies: + loose-envify: 1.4.0 + react: 18.3.1 + scheduler: 0.23.2 + + react-is@17.0.2: {} + + react-oidc-context@3.3.1(oidc-client-ts@3.5.0)(react@18.3.1): + dependencies: + oidc-client-ts: 3.5.0 + react: 18.3.1 + + react-refresh@0.18.0: {} + + react@18.3.1: + dependencies: + loose-envify: 1.4.0 + + redent@3.0.0: + dependencies: + indent-string: 4.0.0 + strip-indent: 3.0.0 + + resolve-from@4.0.0: {} + + rollup@4.60.0: + dependencies: + '@types/estree': 1.0.8 + optionalDependencies: + '@rollup/rollup-android-arm-eabi': 4.60.0 + '@rollup/rollup-android-arm64': 4.60.0 + '@rollup/rollup-darwin-arm64': 4.60.0 + '@rollup/rollup-darwin-x64': 4.60.0 + '@rollup/rollup-freebsd-arm64': 4.60.0 + '@rollup/rollup-freebsd-x64': 4.60.0 + '@rollup/rollup-linux-arm-gnueabihf': 4.60.0 + '@rollup/rollup-linux-arm-musleabihf': 4.60.0 + '@rollup/rollup-linux-arm64-gnu': 4.60.0 + '@rollup/rollup-linux-arm64-musl': 4.60.0 + '@rollup/rollup-linux-loong64-gnu': 4.60.0 + '@rollup/rollup-linux-loong64-musl': 4.60.0 + '@rollup/rollup-linux-ppc64-gnu': 4.60.0 + '@rollup/rollup-linux-ppc64-musl': 4.60.0 + '@rollup/rollup-linux-riscv64-gnu': 4.60.0 + '@rollup/rollup-linux-riscv64-musl': 4.60.0 + '@rollup/rollup-linux-s390x-gnu': 4.60.0 + '@rollup/rollup-linux-x64-gnu': 4.60.0 + '@rollup/rollup-linux-x64-musl': 4.60.0 + '@rollup/rollup-openbsd-x64': 4.60.0 + '@rollup/rollup-openharmony-arm64': 4.60.0 + '@rollup/rollup-win32-arm64-msvc': 4.60.0 + '@rollup/rollup-win32-ia32-msvc': 4.60.0 + '@rollup/rollup-win32-x64-gnu': 4.60.0 + '@rollup/rollup-win32-x64-msvc': 4.60.0 + fsevents: 2.3.3 + + rrweb-cssom@0.8.0: {} + + safe-stable-stringify@2.5.0: {} + + safer-buffer@2.1.2: {} + + saxes@6.0.0: + dependencies: + xmlchars: 2.2.0 + + scheduler@0.23.2: + dependencies: + loose-envify: 1.4.0 + + semver@6.3.1: {} + + semver@7.7.4: {} + + shebang-command@2.0.0: + dependencies: + shebang-regex: 3.0.0 + + shebang-regex@3.0.0: {} + + siginfo@2.0.0: {} + + source-map-js@1.2.1: {} + + spacetimedb@2.1.0(react@18.3.1): + dependencies: + base64-js: 1.5.1 + headers-polyfill: 4.0.3 + object-inspect: 1.13.4 + prettier: 3.8.1 + pure-rand: 7.0.1 + safe-stable-stringify: 2.5.0 + statuses: 2.0.2 + url-polyfill: 1.1.14 + optionalDependencies: + react: 18.3.1 + + stackback@0.0.2: {} + + statuses@2.0.2: {} + + std-env@3.10.0: {} + + strip-indent@3.0.0: + dependencies: + min-indent: 1.0.1 + + strip-json-comments@3.1.1: {} + + strip-literal@3.1.0: + dependencies: + js-tokens: 9.0.1 + + supports-color@7.2.0: + dependencies: + has-flag: 4.0.0 + + symbol-tree@3.2.4: {} + + tinybench@2.9.0: {} + + tinyexec@0.3.2: {} + + tinyglobby@0.2.15: + dependencies: + fdir: 6.5.0(picomatch@4.0.4) + picomatch: 4.0.4 + + tinypool@1.1.1: {} + + tinyrainbow@2.0.0: {} + + tinyspy@4.0.4: {} + + tldts-core@6.1.86: {} + + tldts@6.1.86: + dependencies: + tldts-core: 6.1.86 + + tough-cookie@5.1.2: + dependencies: + tldts: 6.1.86 + + tr46@5.1.1: + dependencies: + punycode: 2.3.1 + + ts-api-utils@2.5.0(typescript@5.6.3): + dependencies: + typescript: 5.6.3 + + type-check@0.4.0: + dependencies: + prelude-ls: 1.2.1 + + typescript-eslint@8.57.2(eslint@9.39.4)(typescript@5.6.3): + dependencies: + '@typescript-eslint/eslint-plugin': 8.57.2(@typescript-eslint/parser@8.57.2(eslint@9.39.4)(typescript@5.6.3))(eslint@9.39.4)(typescript@5.6.3) + '@typescript-eslint/parser': 8.57.2(eslint@9.39.4)(typescript@5.6.3) + '@typescript-eslint/typescript-estree': 8.57.2(typescript@5.6.3) + '@typescript-eslint/utils': 8.57.2(eslint@9.39.4)(typescript@5.6.3) + eslint: 9.39.4 + typescript: 5.6.3 + transitivePeerDependencies: + - supports-color + + typescript@5.6.3: {} + + update-browserslist-db@1.2.3(browserslist@4.28.1): + dependencies: + browserslist: 4.28.1 + escalade: 3.2.0 + picocolors: 1.1.1 + + uri-js@4.4.1: + dependencies: + punycode: 2.3.1 + + url-polyfill@1.1.14: {} + + vite-node@3.2.4: + dependencies: + cac: 6.7.14 + debug: 4.4.3 + es-module-lexer: 1.7.0 + pathe: 2.0.3 + vite: 7.3.1 + transitivePeerDependencies: + - '@types/node' + - jiti + - less + - lightningcss + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + - tsx + - yaml + + vite@7.3.1: + dependencies: + esbuild: 0.27.4 + fdir: 6.5.0(picomatch@4.0.4) + picomatch: 4.0.4 + postcss: 8.5.8 + rollup: 4.60.0 + tinyglobby: 0.2.15 + optionalDependencies: + fsevents: 2.3.3 + + vitest@3.2.4(jsdom@26.1.0): + dependencies: + '@types/chai': 5.2.3 + '@vitest/expect': 3.2.4 + '@vitest/mocker': 3.2.4(vite@7.3.1) + '@vitest/pretty-format': 3.2.4 + '@vitest/runner': 3.2.4 + '@vitest/snapshot': 3.2.4 + '@vitest/spy': 3.2.4 + '@vitest/utils': 3.2.4 + chai: 5.3.3 + debug: 4.4.3 + expect-type: 1.3.0 + magic-string: 0.30.21 + pathe: 2.0.3 + picomatch: 4.0.4 + std-env: 3.10.0 + tinybench: 2.9.0 + tinyexec: 0.3.2 + tinyglobby: 0.2.15 + tinypool: 1.1.1 + tinyrainbow: 2.0.0 + vite: 7.3.1 + vite-node: 3.2.4 + why-is-node-running: 2.3.0 + optionalDependencies: + jsdom: 26.1.0 + transitivePeerDependencies: + - jiti + - less + - lightningcss + - msw + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + - tsx + - yaml + + w3c-xmlserializer@5.0.0: + dependencies: + xml-name-validator: 5.0.0 + + webidl-conversions@7.0.0: {} + + whatwg-encoding@3.1.1: + dependencies: + iconv-lite: 0.6.3 + + whatwg-mimetype@4.0.0: {} + + whatwg-url@14.2.0: + dependencies: + tr46: 5.1.1 + webidl-conversions: 7.0.0 + + which@2.0.2: + dependencies: + isexe: 2.0.0 + + why-is-node-running@2.3.0: + dependencies: + siginfo: 2.0.0 + stackback: 0.0.2 + + word-wrap@1.2.5: {} + + ws@8.20.0: {} + + xml-name-validator@5.0.0: {} + + xmlchars@2.2.0: {} + + yallist@3.1.1: {} + + yocto-queue@0.1.0: {} diff --git a/public/vite.svg b/public/vite.svg new file mode 100644 index 0000000..e7b8dfb --- /dev/null +++ b/public/vite.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/spacetime.json b/spacetime.json new file mode 100644 index 0000000..e5af965 --- /dev/null +++ b/spacetime.json @@ -0,0 +1,8 @@ +{ + "dev": { + "run": "pnpm run dev" + }, + "server": "maincloud", + "database": "my-spacetime-app-jdhdg", + "module-path": "./spacetimedb" +} \ No newline at end of file diff --git a/spacetime.local.json b/spacetime.local.json new file mode 100644 index 0000000..c174128 --- /dev/null +++ b/spacetime.local.json @@ -0,0 +1,3 @@ +{ + "database": "my-spacetime-app-jdhdg" +} \ No newline at end of file diff --git a/spacetimedb/dist/bundle.js b/spacetimedb/dist/bundle.js new file mode 100644 index 0000000..96a2849 --- /dev/null +++ b/spacetimedb/dist/bundle.js @@ -0,0 +1,6385 @@ +import * as _syscalls2_0 from "spacetime:sys@2.0"; +import { moduleHooks } from "spacetime:sys@2.0"; + +//#region node_modules/.pnpm/headers-polyfill@4.0.3/node_modules/headers-polyfill/lib/index.mjs +var __create$1 = Object.create; +var __defProp$1 = Object.defineProperty; +var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor; +var __getOwnPropNames$1 = Object.getOwnPropertyNames; +var __getProtoOf$1 = Object.getPrototypeOf; +var __hasOwnProp$1 = Object.prototype.hasOwnProperty; +var __commonJS$1 = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames$1(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __copyProps$1 = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames$1(from)) if (!__hasOwnProp$1.call(to, key) && key !== except) __defProp$1(to, key, { + get: () => from[key], + enumerable: !(desc = __getOwnPropDesc$1(from, key)) || desc.enumerable + }); + } + return to; +}; +var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(__getProtoOf$1(mod)) : {}, __copyProps$1(isNodeMode || !mod || !mod.__esModule ? __defProp$1(target, "default", { + value: mod, + enumerable: true +}) : target, mod)); +var import_set_cookie_parser = __toESM$1(__commonJS$1({ "node_modules/set-cookie-parser/lib/set-cookie.js"(exports, module) { + "use strict"; + var defaultParseOptions = { + decodeValues: true, + map: false, + silent: false + }; + function isNonEmptyString(str) { + return typeof str === "string" && !!str.trim(); + } + function parseString(setCookieValue, options) { + var parts = setCookieValue.split(";").filter(isNonEmptyString); + var parsed = parseNameValuePair(parts.shift()); + var name = parsed.name; + var value = parsed.value; + options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions; + try { + value = options.decodeValues ? decodeURIComponent(value) : value; + } catch (e) { + console.error("set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.", e); + } + var cookie = { + name, + value + }; + parts.forEach(function(part) { + var sides = part.split("="); + var key = sides.shift().trimLeft().toLowerCase(); + var value2 = sides.join("="); + if (key === "expires") cookie.expires = new Date(value2); + else if (key === "max-age") cookie.maxAge = parseInt(value2, 10); + else if (key === "secure") cookie.secure = true; + else if (key === "httponly") cookie.httpOnly = true; + else if (key === "samesite") cookie.sameSite = value2; + else cookie[key] = value2; + }); + return cookie; + } + function parseNameValuePair(nameValuePairStr) { + var name = ""; + var value = ""; + var nameValueArr = nameValuePairStr.split("="); + if (nameValueArr.length > 1) { + name = nameValueArr.shift(); + value = nameValueArr.join("="); + } else value = nameValuePairStr; + return { + name, + value + }; + } + function parse(input, options) { + options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions; + if (!input) if (!options.map) return []; + else return {}; + if (input.headers) if (typeof input.headers.getSetCookie === "function") input = input.headers.getSetCookie(); + else if (input.headers["set-cookie"]) input = input.headers["set-cookie"]; + else { + var sch = input.headers[Object.keys(input.headers).find(function(key) { + return key.toLowerCase() === "set-cookie"; + })]; + if (!sch && input.headers.cookie && !options.silent) console.warn("Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."); + input = sch; + } + if (!Array.isArray(input)) input = [input]; + options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions; + if (!options.map) return input.filter(isNonEmptyString).map(function(str) { + return parseString(str, options); + }); + else return input.filter(isNonEmptyString).reduce(function(cookies2, str) { + var cookie = parseString(str, options); + cookies2[cookie.name] = cookie; + return cookies2; + }, {}); + } + function splitCookiesString2(cookiesString) { + if (Array.isArray(cookiesString)) return cookiesString; + if (typeof cookiesString !== "string") return []; + var cookiesStrings = []; + var pos = 0; + var start; + var ch; + var lastComma; + var nextStart; + var cookiesSeparatorFound; + function skipWhitespace() { + while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1; + return pos < cookiesString.length; + } + function notSpecialChar() { + ch = cookiesString.charAt(pos); + return ch !== "=" && ch !== ";" && ch !== ","; + } + while (pos < cookiesString.length) { + start = pos; + cookiesSeparatorFound = false; + while (skipWhitespace()) { + ch = cookiesString.charAt(pos); + if (ch === ",") { + lastComma = pos; + pos += 1; + skipWhitespace(); + nextStart = pos; + while (pos < cookiesString.length && notSpecialChar()) pos += 1; + if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") { + cookiesSeparatorFound = true; + pos = nextStart; + cookiesStrings.push(cookiesString.substring(start, lastComma)); + start = pos; + } else pos = lastComma + 1; + } else pos += 1; + } + if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.substring(start, cookiesString.length)); + } + return cookiesStrings; + } + module.exports = parse; + module.exports.parse = parse; + module.exports.parseString = parseString; + module.exports.splitCookiesString = splitCookiesString2; +} })()); +var HEADERS_INVALID_CHARACTERS = /[^a-z0-9\-#$%&'*+.^_`|~]/i; +function normalizeHeaderName(name) { + if (HEADERS_INVALID_CHARACTERS.test(name) || name.trim() === "") throw new TypeError("Invalid character in header field name"); + return name.trim().toLowerCase(); +} +var charCodesToRemove = [ + String.fromCharCode(10), + String.fromCharCode(13), + String.fromCharCode(9), + String.fromCharCode(32) +]; +var HEADER_VALUE_REMOVE_REGEXP = new RegExp(`(^[${charCodesToRemove.join("")}]|$[${charCodesToRemove.join("")}])`, "g"); +function normalizeHeaderValue(value) { + return value.replace(HEADER_VALUE_REMOVE_REGEXP, ""); +} +function isValidHeaderName(value) { + if (typeof value !== "string") return false; + if (value.length === 0) return false; + for (let i = 0; i < value.length; i++) { + const character = value.charCodeAt(i); + if (character > 127 || !isToken(character)) return false; + } + return true; +} +function isToken(value) { + return ![ + 127, + 32, + "(", + ")", + "<", + ">", + "@", + ",", + ";", + ":", + "\\", + "\"", + "/", + "[", + "]", + "?", + "=", + "{", + "}" + ].includes(value); +} +function isValidHeaderValue(value) { + if (typeof value !== "string") return false; + if (value.trim() !== value) return false; + for (let i = 0; i < value.length; i++) { + const character = value.charCodeAt(i); + if (character === 0 || character === 10 || character === 13) return false; + } + return true; +} +var NORMALIZED_HEADERS = Symbol("normalizedHeaders"); +var RAW_HEADER_NAMES = Symbol("rawHeaderNames"); +var HEADER_VALUE_DELIMITER = ", "; +var _a, _b, _c; +var Headers = class _Headers { + constructor(init) { + this[_a] = {}; + this[_b] = /* @__PURE__ */ new Map(); + this[_c] = "Headers"; + if (["Headers", "HeadersPolyfill"].includes(init?.constructor.name) || init instanceof _Headers || typeof globalThis.Headers !== "undefined" && init instanceof globalThis.Headers) init.forEach((value, name) => { + this.append(name, value); + }, this); + else if (Array.isArray(init)) init.forEach(([name, value]) => { + this.append(name, Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value); + }); + else if (init) Object.getOwnPropertyNames(init).forEach((name) => { + const value = init[name]; + this.append(name, Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value); + }); + } + [(_a = NORMALIZED_HEADERS, _b = RAW_HEADER_NAMES, _c = Symbol.toStringTag, Symbol.iterator)]() { + return this.entries(); + } + *keys() { + for (const [name] of this.entries()) yield name; + } + *values() { + for (const [, value] of this.entries()) yield value; + } + *entries() { + let sortedKeys = Object.keys(this[NORMALIZED_HEADERS]).sort((a, b) => a.localeCompare(b)); + for (const name of sortedKeys) if (name === "set-cookie") for (const value of this.getSetCookie()) yield [name, value]; + else yield [name, this.get(name)]; + } + /** + * Returns a boolean stating whether a `Headers` object contains a certain header. + */ + has(name) { + if (!isValidHeaderName(name)) throw new TypeError(`Invalid header name "${name}"`); + return this[NORMALIZED_HEADERS].hasOwnProperty(normalizeHeaderName(name)); + } + /** + * Returns a `ByteString` sequence of all the values of a header with a given name. + */ + get(name) { + if (!isValidHeaderName(name)) throw TypeError(`Invalid header name "${name}"`); + return this[NORMALIZED_HEADERS][normalizeHeaderName(name)] ?? null; + } + /** + * Sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist. + */ + set(name, value) { + if (!isValidHeaderName(name) || !isValidHeaderValue(value)) return; + const normalizedName = normalizeHeaderName(name); + const normalizedValue = normalizeHeaderValue(value); + this[NORMALIZED_HEADERS][normalizedName] = normalizeHeaderValue(normalizedValue); + this[RAW_HEADER_NAMES].set(normalizedName, name); + } + /** + * Appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist. + */ + append(name, value) { + if (!isValidHeaderName(name) || !isValidHeaderValue(value)) return; + const normalizedName = normalizeHeaderName(name); + const normalizedValue = normalizeHeaderValue(value); + let resolvedValue = this.has(normalizedName) ? `${this.get(normalizedName)}, ${normalizedValue}` : normalizedValue; + this.set(name, resolvedValue); + } + /** + * Deletes a header from the `Headers` object. + */ + delete(name) { + if (!isValidHeaderName(name)) return; + if (!this.has(name)) return; + const normalizedName = normalizeHeaderName(name); + delete this[NORMALIZED_HEADERS][normalizedName]; + this[RAW_HEADER_NAMES].delete(normalizedName); + } + /** + * Traverses the `Headers` object, + * calling the given callback for each header. + */ + forEach(callback, thisArg) { + for (const [name, value] of this.entries()) callback.call(thisArg, value, name, this); + } + /** + * Returns an array containing the values + * of all Set-Cookie headers associated + * with a response + */ + getSetCookie() { + const setCookieHeader = this.get("set-cookie"); + if (setCookieHeader === null) return []; + if (setCookieHeader === "") return [""]; + return (0, import_set_cookie_parser.splitCookiesString)(setCookieHeader); + } +}; +function headersToList(headers) { + const headersList = []; + headers.forEach((value, name) => { + const resolvedValue = value.includes(",") ? value.split(",").map((value2) => value2.trim()) : value; + headersList.push([name, resolvedValue]); + }); + return headersList; +} + +//#endregion +//#region node_modules/.pnpm/spacetimedb@2.1.0/node_modules/spacetimedb/dist/server/index.mjs +typeof globalThis !== "undefined" && (globalThis.global = globalThis.global || globalThis, globalThis.window = globalThis.window || globalThis); +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 __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; +}; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) __defProp(target, name, { + get: all[name], + enumerable: true + }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, { + get: () => from[key], + enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable + }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(__defProp(target, "default", { + value: mod, + enumerable: true +}), mod)); +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); +var require_base64_js = __commonJS({ "../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports) { + exports.byteLength = byteLength; + exports.toByteArray = toByteArray; + exports.fromByteArray = fromByteArray2; + var lookup = []; + var revLookup = []; + var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array; + var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + for (i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i]; + revLookup[code.charCodeAt(i)] = i; + } + var i; + var len; + revLookup["-".charCodeAt(0)] = 62; + revLookup["_".charCodeAt(0)] = 63; + function getLens(b64) { + var len2 = b64.length; + if (len2 % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4"); + var validLen = b64.indexOf("="); + if (validLen === -1) validLen = len2; + var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4; + return [validLen, placeHoldersLen]; + } + function byteLength(b64) { + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; + } + function _byteLength(b64, validLen, placeHoldersLen) { + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; + } + function toByteArray(b64) { + var tmp; + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)); + var curByte = 0; + var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen; + var i2; + for (i2 = 0; i2 < len2; i2 += 4) { + tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)]; + arr[curByte++] = tmp >> 16 & 255; + arr[curByte++] = tmp >> 8 & 255; + arr[curByte++] = tmp & 255; + } + if (placeHoldersLen === 2) { + tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4; + arr[curByte++] = tmp & 255; + } + if (placeHoldersLen === 1) { + tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2; + arr[curByte++] = tmp >> 8 & 255; + arr[curByte++] = tmp & 255; + } + return arr; + } + function tripletToBase64(num) { + return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63]; + } + function encodeChunk(uint8, start, end) { + var tmp; + var output = []; + for (var i2 = start; i2 < end; i2 += 3) { + tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255); + output.push(tripletToBase64(tmp)); + } + return output.join(""); + } + function fromByteArray2(uint8) { + var tmp; + var len2 = uint8.length; + var extraBytes = len2 % 3; + var parts = []; + var maxChunkLength = 16383; + for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength)); + if (extraBytes === 1) { + tmp = uint8[len2 - 1]; + parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="); + } else if (extraBytes === 2) { + tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1]; + parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="); + } + return parts.join(""); + } +} }); +var require_codes = __commonJS({ "../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json"(exports, module) { + module.exports = { + "100": "Continue", + "101": "Switching Protocols", + "102": "Processing", + "103": "Early Hints", + "200": "OK", + "201": "Created", + "202": "Accepted", + "203": "Non-Authoritative Information", + "204": "No Content", + "205": "Reset Content", + "206": "Partial Content", + "207": "Multi-Status", + "208": "Already Reported", + "226": "IM Used", + "300": "Multiple Choices", + "301": "Moved Permanently", + "302": "Found", + "303": "See Other", + "304": "Not Modified", + "305": "Use Proxy", + "307": "Temporary Redirect", + "308": "Permanent Redirect", + "400": "Bad Request", + "401": "Unauthorized", + "402": "Payment Required", + "403": "Forbidden", + "404": "Not Found", + "405": "Method Not Allowed", + "406": "Not Acceptable", + "407": "Proxy Authentication Required", + "408": "Request Timeout", + "409": "Conflict", + "410": "Gone", + "411": "Length Required", + "412": "Precondition Failed", + "413": "Payload Too Large", + "414": "URI Too Long", + "415": "Unsupported Media Type", + "416": "Range Not Satisfiable", + "417": "Expectation Failed", + "418": "I'm a Teapot", + "421": "Misdirected Request", + "422": "Unprocessable Entity", + "423": "Locked", + "424": "Failed Dependency", + "425": "Too Early", + "426": "Upgrade Required", + "428": "Precondition Required", + "429": "Too Many Requests", + "431": "Request Header Fields Too Large", + "451": "Unavailable For Legal Reasons", + "500": "Internal Server Error", + "501": "Not Implemented", + "502": "Bad Gateway", + "503": "Service Unavailable", + "504": "Gateway Timeout", + "505": "HTTP Version Not Supported", + "506": "Variant Also Negotiates", + "507": "Insufficient Storage", + "508": "Loop Detected", + "509": "Bandwidth Limit Exceeded", + "510": "Not Extended", + "511": "Network Authentication Required" + }; +} }); +var require_statuses = __commonJS({ "../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/index.js"(exports, module) { + var codes = require_codes(); + module.exports = status2; + status2.message = codes; + status2.code = createMessageToStatusCodeMap(codes); + status2.codes = createStatusCodeList(codes); + status2.redirect = { + 300: true, + 301: true, + 302: true, + 303: true, + 305: true, + 307: true, + 308: true + }; + status2.empty = { + 204: true, + 205: true, + 304: true + }; + status2.retry = { + 502: true, + 503: true, + 504: true + }; + function createMessageToStatusCodeMap(codes2) { + var map = {}; + Object.keys(codes2).forEach(function forEachCode(code) { + var message = codes2[code]; + var status3 = Number(code); + map[message.toLowerCase()] = status3; + }); + return map; + } + function createStatusCodeList(codes2) { + return Object.keys(codes2).map(function mapCode(code) { + return Number(code); + }); + } + function getStatusCode(message) { + var msg = message.toLowerCase(); + if (!Object.prototype.hasOwnProperty.call(status2.code, msg)) throw new Error("invalid status message: \"" + message + "\""); + return status2.code[msg]; + } + function getStatusMessage(code) { + if (!Object.prototype.hasOwnProperty.call(status2.message, code)) throw new Error("invalid status code: " + code); + return status2.message[code]; + } + function status2(code) { + if (typeof code === "number") return getStatusMessage(code); + if (typeof code !== "string") throw new TypeError("code must be a number or string"); + var n = parseInt(code, 10); + if (!isNaN(n)) return getStatusMessage(n); + return getStatusCode(code); + } +} }); +var util_stub_exports = {}; +__export(util_stub_exports, { inspect: () => inspect }); +var inspect; +var init_util_stub = __esm({ "src/util-stub.ts"() { + inspect = {}; +} }); +var require_util_inspect = __commonJS({ "../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/util.inspect.js"(exports, module) { + module.exports = (init_util_stub(), __toCommonJS(util_stub_exports)).inspect; +} }); +var require_object_inspect = __commonJS({ "../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/index.js"(exports, module) { + var hasMap = typeof Map === "function" && Map.prototype; + var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null; + var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null; + var mapForEach = hasMap && Map.prototype.forEach; + var hasSet = typeof Set === "function" && Set.prototype; + var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null; + var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null; + var setForEach = hasSet && Set.prototype.forEach; + var weakMapHas = typeof WeakMap === "function" && WeakMap.prototype ? WeakMap.prototype.has : null; + var weakSetHas = typeof WeakSet === "function" && WeakSet.prototype ? WeakSet.prototype.has : null; + var weakRefDeref = typeof WeakRef === "function" && WeakRef.prototype ? WeakRef.prototype.deref : null; + var booleanValueOf = Boolean.prototype.valueOf; + var objectToString = Object.prototype.toString; + var functionToString = Function.prototype.toString; + var $match = String.prototype.match; + var $slice = String.prototype.slice; + var $replace = String.prototype.replace; + var $toUpperCase = String.prototype.toUpperCase; + var $toLowerCase = String.prototype.toLowerCase; + var $test = RegExp.prototype.test; + var $concat = Array.prototype.concat; + var $join = Array.prototype.join; + var $arrSlice = Array.prototype.slice; + var $floor = Math.floor; + var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null; + var gOPS = Object.getOwnPropertySymbols; + var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null; + var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object"; + var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null; + var isEnumerable = Object.prototype.propertyIsEnumerable; + var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) { + return O.__proto__; + } : null); + function addNumericSeparator(num, str) { + if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) return str; + var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g; + if (typeof num === "number") { + var int = num < 0 ? -$floor(-num) : $floor(num); + if (int !== num) { + var intStr = String(int); + var dec = $slice.call(str, intStr.length + 1); + return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, ""); + } + } + return $replace.call(str, sepRegex, "$&_"); + } + var utilInspect = require_util_inspect(); + var inspectCustom = utilInspect.custom; + var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null; + var quotes = { + __proto__: null, + "double": "\"", + single: "'" + }; + var quoteREs = { + __proto__: null, + "double": /(["\\])/g, + single: /(['\\])/g + }; + module.exports = function inspect_(obj, options, depth, seen) { + var opts = options || {}; + if (has(opts, "quoteStyle") && !has(quotes, opts.quoteStyle)) throw new TypeError("option \"quoteStyle\" must be \"single\" or \"double\""); + if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) throw new TypeError("option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`"); + var customInspect = has(opts, "customInspect") ? opts.customInspect : true; + if (typeof customInspect !== "boolean" && customInspect !== "symbol") throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`"); + if (has(opts, "indent") && opts.indent !== null && opts.indent !== " " && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) throw new TypeError("option \"indent\" must be \"\\t\", an integer > 0, or `null`"); + if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") throw new TypeError("option \"numericSeparator\", if provided, must be `true` or `false`"); + var numericSeparator = opts.numericSeparator; + if (typeof obj === "undefined") return "undefined"; + if (obj === null) return "null"; + if (typeof obj === "boolean") return obj ? "true" : "false"; + if (typeof obj === "string") return inspectString(obj, opts); + if (typeof obj === "number") { + if (obj === 0) return Infinity / obj > 0 ? "0" : "-0"; + var str = String(obj); + return numericSeparator ? addNumericSeparator(obj, str) : str; + } + if (typeof obj === "bigint") { + var bigIntStr = String(obj) + "n"; + return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr; + } + var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth; + if (typeof depth === "undefined") depth = 0; + if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") return isArray(obj) ? "[Array]" : "[Object]"; + var indent = getIndent(opts, depth); + if (typeof seen === "undefined") seen = []; + else if (indexOf(seen, obj) >= 0) return "[Circular]"; + function inspect3(value, from, noIndent) { + if (from) { + seen = $arrSlice.call(seen); + seen.push(from); + } + if (noIndent) { + var newOpts = { depth: opts.depth }; + if (has(opts, "quoteStyle")) newOpts.quoteStyle = opts.quoteStyle; + return inspect_(value, newOpts, depth + 1, seen); + } + return inspect_(value, opts, depth + 1, seen); + } + if (typeof obj === "function" && !isRegExp(obj)) { + var name = nameOf(obj); + var keys = arrObjKeys(obj, inspect3); + return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : ""); + } + if (isSymbol(obj)) { + var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj); + return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString; + } + if (isElement(obj)) { + var s = "<" + $toLowerCase.call(String(obj.nodeName)); + var attrs = obj.attributes || []; + for (var i = 0; i < attrs.length; i++) s += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts); + s += ">"; + if (obj.childNodes && obj.childNodes.length) s += "..."; + s += ""; + return s; + } + if (isArray(obj)) { + if (obj.length === 0) return "[]"; + var xs = arrObjKeys(obj, inspect3); + if (indent && !singleLineValues(xs)) return "[" + indentedJoin(xs, indent) + "]"; + return "[ " + $join.call(xs, ", ") + " ]"; + } + if (isError(obj)) { + var parts = arrObjKeys(obj, inspect3); + if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect3(obj.cause), parts), ", ") + " }"; + if (parts.length === 0) return "[" + String(obj) + "]"; + return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }"; + } + if (typeof obj === "object" && customInspect) { + if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) return utilInspect(obj, { depth: maxDepth - depth }); + else if (customInspect !== "symbol" && typeof obj.inspect === "function") return obj.inspect(); + } + if (isMap(obj)) { + var mapParts = []; + if (mapForEach) mapForEach.call(obj, function(value, key) { + mapParts.push(inspect3(key, obj, true) + " => " + inspect3(value, obj)); + }); + return collectionOf("Map", mapSize.call(obj), mapParts, indent); + } + if (isSet(obj)) { + var setParts = []; + if (setForEach) setForEach.call(obj, function(value) { + setParts.push(inspect3(value, obj)); + }); + return collectionOf("Set", setSize.call(obj), setParts, indent); + } + if (isWeakMap(obj)) return weakCollectionOf("WeakMap"); + if (isWeakSet(obj)) return weakCollectionOf("WeakSet"); + if (isWeakRef(obj)) return weakCollectionOf("WeakRef"); + if (isNumber(obj)) return markBoxed(inspect3(Number(obj))); + if (isBigInt(obj)) return markBoxed(inspect3(bigIntValueOf.call(obj))); + if (isBoolean(obj)) return markBoxed(booleanValueOf.call(obj)); + if (isString(obj)) return markBoxed(inspect3(String(obj))); + if (typeof window !== "undefined" && obj === window) return "{ [object Window] }"; + if (typeof globalThis !== "undefined" && obj === globalThis || typeof global !== "undefined" && obj === global) return "{ [object globalThis] }"; + if (!isDate(obj) && !isRegExp(obj)) { + var ys = arrObjKeys(obj, inspect3); + var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object; + var protoTag = obj instanceof Object ? "" : "null prototype"; + var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : ""; + var tag = (isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "") + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : ""); + if (ys.length === 0) return tag + "{}"; + if (indent) return tag + "{" + indentedJoin(ys, indent) + "}"; + return tag + "{ " + $join.call(ys, ", ") + " }"; + } + return String(obj); + }; + function wrapQuotes(s, defaultStyle, opts) { + var quoteChar = quotes[opts.quoteStyle || defaultStyle]; + return quoteChar + s + quoteChar; + } + function quote(s) { + return $replace.call(String(s), /"/g, """); + } + function canTrustToString(obj) { + return !toStringTag || !(typeof obj === "object" && (toStringTag in obj || typeof obj[toStringTag] !== "undefined")); + } + function isArray(obj) { + return toStr(obj) === "[object Array]" && canTrustToString(obj); + } + function isDate(obj) { + return toStr(obj) === "[object Date]" && canTrustToString(obj); + } + function isRegExp(obj) { + return toStr(obj) === "[object RegExp]" && canTrustToString(obj); + } + function isError(obj) { + return toStr(obj) === "[object Error]" && canTrustToString(obj); + } + function isString(obj) { + return toStr(obj) === "[object String]" && canTrustToString(obj); + } + function isNumber(obj) { + return toStr(obj) === "[object Number]" && canTrustToString(obj); + } + function isBoolean(obj) { + return toStr(obj) === "[object Boolean]" && canTrustToString(obj); + } + function isSymbol(obj) { + if (hasShammedSymbols) return obj && typeof obj === "object" && obj instanceof Symbol; + if (typeof obj === "symbol") return true; + if (!obj || typeof obj !== "object" || !symToString) return false; + try { + symToString.call(obj); + return true; + } catch (e) {} + return false; + } + function isBigInt(obj) { + if (!obj || typeof obj !== "object" || !bigIntValueOf) return false; + try { + bigIntValueOf.call(obj); + return true; + } catch (e) {} + return false; + } + var hasOwn2 = Object.prototype.hasOwnProperty || function(key) { + return key in this; + }; + function has(obj, key) { + return hasOwn2.call(obj, key); + } + function toStr(obj) { + return objectToString.call(obj); + } + function nameOf(f) { + if (f.name) return f.name; + var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/); + if (m) return m[1]; + return null; + } + function indexOf(xs, x) { + if (xs.indexOf) return xs.indexOf(x); + for (var i = 0, l = xs.length; i < l; i++) if (xs[i] === x) return i; + return -1; + } + function isMap(x) { + if (!mapSize || !x || typeof x !== "object") return false; + try { + mapSize.call(x); + try { + setSize.call(x); + } catch (s) { + return true; + } + return x instanceof Map; + } catch (e) {} + return false; + } + function isWeakMap(x) { + if (!weakMapHas || !x || typeof x !== "object") return false; + try { + weakMapHas.call(x, weakMapHas); + try { + weakSetHas.call(x, weakSetHas); + } catch (s) { + return true; + } + return x instanceof WeakMap; + } catch (e) {} + return false; + } + function isWeakRef(x) { + if (!weakRefDeref || !x || typeof x !== "object") return false; + try { + weakRefDeref.call(x); + return true; + } catch (e) {} + return false; + } + function isSet(x) { + if (!setSize || !x || typeof x !== "object") return false; + try { + setSize.call(x); + try { + mapSize.call(x); + } catch (m) { + return true; + } + return x instanceof Set; + } catch (e) {} + return false; + } + function isWeakSet(x) { + if (!weakSetHas || !x || typeof x !== "object") return false; + try { + weakSetHas.call(x, weakSetHas); + try { + weakMapHas.call(x, weakMapHas); + } catch (s) { + return true; + } + return x instanceof WeakSet; + } catch (e) {} + return false; + } + function isElement(x) { + if (!x || typeof x !== "object") return false; + if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) return true; + return typeof x.nodeName === "string" && typeof x.getAttribute === "function"; + } + function inspectString(str, opts) { + if (str.length > opts.maxStringLength) { + var remaining = str.length - opts.maxStringLength; + var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : ""); + return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer; + } + var quoteRE = quoteREs[opts.quoteStyle || "single"]; + quoteRE.lastIndex = 0; + return wrapQuotes($replace.call($replace.call(str, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte), "single", opts); + } + function lowbyte(c) { + var n = c.charCodeAt(0); + var x = { + 8: "b", + 9: "t", + 10: "n", + 12: "f", + 13: "r" + }[n]; + if (x) return "\\" + x; + return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16)); + } + function markBoxed(str) { + return "Object(" + str + ")"; + } + function weakCollectionOf(type) { + return type + " { ? }"; + } + function collectionOf(type, size, entries, indent) { + var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", "); + return type + " (" + size + ") {" + joinedEntries + "}"; + } + function singleLineValues(xs) { + for (var i = 0; i < xs.length; i++) if (indexOf(xs[i], "\n") >= 0) return false; + return true; + } + function getIndent(opts, depth) { + var baseIndent; + if (opts.indent === " ") baseIndent = " "; + else if (typeof opts.indent === "number" && opts.indent > 0) baseIndent = $join.call(Array(opts.indent + 1), " "); + else return null; + return { + base: baseIndent, + prev: $join.call(Array(depth + 1), baseIndent) + }; + } + function indentedJoin(xs, indent) { + if (xs.length === 0) return ""; + var lineJoiner = "\n" + indent.prev + indent.base; + return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev; + } + function arrObjKeys(obj, inspect3) { + var isArr = isArray(obj); + var xs = []; + if (isArr) { + xs.length = obj.length; + for (var i = 0; i < obj.length; i++) xs[i] = has(obj, i) ? inspect3(obj[i], obj) : ""; + } + var syms = typeof gOPS === "function" ? gOPS(obj) : []; + var symMap; + if (hasShammedSymbols) { + symMap = {}; + for (var k = 0; k < syms.length; k++) symMap["$" + syms[k]] = syms[k]; + } + for (var key in obj) { + if (!has(obj, key)) continue; + if (isArr && String(Number(key)) === key && key < obj.length) continue; + if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) continue; + else if ($test.call(/[^\w$]/, key)) xs.push(inspect3(key, obj) + ": " + inspect3(obj[key], obj)); + else xs.push(key + ": " + inspect3(obj[key], obj)); + } + if (typeof gOPS === "function") { + for (var j = 0; j < syms.length; j++) if (isEnumerable.call(obj, syms[j])) xs.push("[" + inspect3(syms[j]) + "]: " + inspect3(obj[syms[j]], obj)); + } + return xs; + } +} }); +var TimeDuration = class _TimeDuration { + __time_duration_micros__; + static MICROS_PER_MILLIS = 1000n; + /** + * Get the algebraic type representation of the {@link TimeDuration} type. + * @returns The algebraic type representation of the type. + */ + static getAlgebraicType() { + return AlgebraicType.Product({ elements: [{ + name: "__time_duration_micros__", + algebraicType: AlgebraicType.I64 + }] }); + } + static isTimeDuration(algebraicType) { + if (algebraicType.tag !== "Product") return false; + const elements = algebraicType.value.elements; + if (elements.length !== 1) return false; + const microsElement = elements[0]; + return microsElement.name === "__time_duration_micros__" && microsElement.algebraicType.tag === "I64"; + } + get micros() { + return this.__time_duration_micros__; + } + get millis() { + return Number(this.micros / _TimeDuration.MICROS_PER_MILLIS); + } + constructor(micros) { + this.__time_duration_micros__ = micros; + } + static fromMillis(millis) { + return new _TimeDuration(BigInt(millis) * _TimeDuration.MICROS_PER_MILLIS); + } + /** This outputs the same string format that we use in the host and in Rust modules */ + toString() { + const micros = this.micros; + const sign = micros < 0 ? "-" : "+"; + const pos = micros < 0 ? -micros : micros; + const secs = pos / 1000000n; + const micros_remaining = pos % 1000000n; + return `${sign}${secs}.${String(micros_remaining).padStart(6, "0")}`; + } +}; +var Timestamp = class _Timestamp { + __timestamp_micros_since_unix_epoch__; + static MICROS_PER_MILLIS = 1000n; + get microsSinceUnixEpoch() { + return this.__timestamp_micros_since_unix_epoch__; + } + constructor(micros) { + this.__timestamp_micros_since_unix_epoch__ = micros; + } + /** + * Get the algebraic type representation of the {@link Timestamp} type. + * @returns The algebraic type representation of the type. + */ + static getAlgebraicType() { + return AlgebraicType.Product({ elements: [{ + name: "__timestamp_micros_since_unix_epoch__", + algebraicType: AlgebraicType.I64 + }] }); + } + static isTimestamp(algebraicType) { + if (algebraicType.tag !== "Product") return false; + const elements = algebraicType.value.elements; + if (elements.length !== 1) return false; + const microsElement = elements[0]; + return microsElement.name === "__timestamp_micros_since_unix_epoch__" && microsElement.algebraicType.tag === "I64"; + } + /** + * The Unix epoch, the midnight at the beginning of January 1, 1970, UTC. + */ + static UNIX_EPOCH = new _Timestamp(0n); + /** + * Get a `Timestamp` representing the execution environment's belief of the current moment in time. + */ + static now() { + return _Timestamp.fromDate(/* @__PURE__ */ new Date()); + } + /** Convert to milliseconds since Unix epoch. */ + toMillis() { + return this.microsSinceUnixEpoch / 1000n; + } + /** + * Get a `Timestamp` representing the same point in time as `date`. + */ + static fromDate(date) { + const millis = date.getTime(); + return new _Timestamp(BigInt(millis) * _Timestamp.MICROS_PER_MILLIS); + } + /** + * Get a `Date` representing approximately the same point in time as `this`. + * + * This method truncates to millisecond precision, + * and throws `RangeError` if the `Timestamp` is outside the range representable as a `Date`. + */ + toDate() { + const millis = this.__timestamp_micros_since_unix_epoch__ / _Timestamp.MICROS_PER_MILLIS; + if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) throw new RangeError("Timestamp is outside of the representable range of JS's Date"); + return new Date(Number(millis)); + } + /** + * Get an ISO 8601 / RFC 3339 formatted string representation of this timestamp with microsecond precision. + * + * This method preserves the full microsecond precision of the timestamp, + * and throws `RangeError` if the `Timestamp` is outside the range representable in ISO format. + * + * @returns ISO 8601 formatted string with microsecond precision (e.g., '2025-02-17T10:30:45.123456Z') + */ + toISOString() { + const micros = this.__timestamp_micros_since_unix_epoch__; + const millis = micros / _Timestamp.MICROS_PER_MILLIS; + if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) throw new RangeError("Timestamp is outside of the representable range for ISO string formatting"); + const isoBase = new Date(Number(millis)).toISOString(); + const microsRemainder = Math.abs(Number(micros % 1000000n)); + const fractionalPart = String(microsRemainder).padStart(6, "0"); + return isoBase.replace(/\.\d{3}Z$/, `.${fractionalPart}Z`); + } + since(other) { + return new TimeDuration(this.__timestamp_micros_since_unix_epoch__ - other.__timestamp_micros_since_unix_epoch__); + } +}; +var Uuid = class _Uuid { + __uuid__; + /** + * The nil UUID (all zeros). + * + * @example + * ```ts + * const uuid = Uuid.NIL; + * console.assert( + * uuid.toString() === "00000000-0000-0000-0000-000000000000" + * ); + * ``` + */ + static NIL = new _Uuid(0n); + static MAX_UUID_BIGINT = 340282366920938463463374607431768211455n; + /** + * The max UUID (all ones). + * + * @example + * ```ts + * const uuid = Uuid.MAX; + * console.assert( + * uuid.toString() === "ffffffff-ffff-ffff-ffff-ffffffffffff" + * ); + * ``` + */ + static MAX = new _Uuid(_Uuid.MAX_UUID_BIGINT); + /** + * Create a UUID from a raw 128-bit value. + * + * @param u - Unsigned 128-bit integer + * @throws {Error} If the value is outside the valid UUID range + */ + constructor(u) { + if (u < 0n || u > _Uuid.MAX_UUID_BIGINT) throw new Error("Invalid UUID: must be between 0 and `MAX_UUID_BIGINT`"); + this.__uuid__ = u; + } + /** + * Create a UUID `v4` from explicit random bytes. + * + * This method assumes the bytes are already sufficiently random. + * It only sets the appropriate bits for the UUID version and variant. + * + * @param bytes - Exactly 16 random bytes + * @returns A UUID `v4` + * @throws {Error} If `bytes.length !== 16` + * + * @example + * ```ts + * const randomBytes = new Uint8Array(16); + * const uuid = Uuid.fromRandomBytesV4(randomBytes); + * + * console.assert( + * uuid.toString() === "00000000-0000-4000-8000-000000000000" + * ); + * ``` + */ + static fromRandomBytesV4(bytes) { + if (bytes.length !== 16) throw new Error("UUID v4 requires 16 bytes"); + const arr = new Uint8Array(bytes); + arr[6] = arr[6] & 15 | 64; + arr[8] = arr[8] & 63 | 128; + return new _Uuid(_Uuid.bytesToBigInt(arr)); + } + /** + * Generate a UUID `v7` using a monotonic counter from `0` to `2^31 - 1`, + * a timestamp, and 4 random bytes. + * + * The counter wraps around on overflow. + * + * The UUID `v7` is structured as follows: + * + * ```ascii + * ┌───────────────────────────────────────────────┬───────────────────┐ + * | B0 | B1 | B2 | B3 | B4 | B5 | B6 | + * ├───────────────────────────────────────────────┼───────────────────┤ + * | unix_ts_ms | version 7 | + * └───────────────────────────────────────────────┴───────────────────┘ + * ┌──────────────┬─────────┬──────────────────┬───────────────────────┐ + * | B7 | B8 | B9 | B10 | B11 | B12 | B13 | B14 | B15 | + * ├──────────────┼─────────┼──────────────────┼───────────────────────┤ + * | counter_high | variant | counter_low | random | + * └──────────────┴─────────┴──────────────────┴───────────────────────┘ + * ``` + * + * @param counter - Mutable monotonic counter (31-bit) + * @param now - Timestamp since the Unix epoch + * @param randomBytes - Exactly 4 random bytes + * @returns A UUID `v7` + * + * @throws {Error} If the `counter` is negative + * @throws {Error} If the `timestamp` is before the Unix epoch + * @throws {Error} If `randomBytes.length !== 4` + * + * @example + * ```ts + * const now = Timestamp.fromMillis(1_686_000_000_000n); + * const counter = { value: 1 }; + * const randomBytes = new Uint8Array(4); + * + * const uuid = Uuid.fromCounterV7(counter, now, randomBytes); + * + * console.assert( + * uuid.toString() === "0000647e-5180-7000-8000-000200000000" + * ); + * ``` + */ + static fromCounterV7(counter, now, randomBytes) { + if (randomBytes.length !== 4) throw new Error("`fromCounterV7` requires `randomBytes.length == 4`"); + if (counter.value < 0) throw new Error("`fromCounterV7` uuid `counter` must be non-negative"); + if (now.__timestamp_micros_since_unix_epoch__ < 0) throw new Error("`fromCounterV7` `timestamp` before unix epoch"); + const counterVal = counter.value; + counter.value = counterVal + 1 & 2147483647; + const tsMs = now.toMillis() & 281474976710655n; + const bytes = new Uint8Array(16); + bytes[0] = Number(tsMs >> 40n & 255n); + bytes[1] = Number(tsMs >> 32n & 255n); + bytes[2] = Number(tsMs >> 24n & 255n); + bytes[3] = Number(tsMs >> 16n & 255n); + bytes[4] = Number(tsMs >> 8n & 255n); + bytes[5] = Number(tsMs & 255n); + bytes[7] = counterVal >>> 23 & 255; + bytes[9] = counterVal >>> 15 & 255; + bytes[10] = counterVal >>> 7 & 255; + bytes[11] = (counterVal & 127) << 1 & 255; + bytes[12] |= randomBytes[0] & 127; + bytes[13] = randomBytes[1]; + bytes[14] = randomBytes[2]; + bytes[15] = randomBytes[3]; + bytes[6] = bytes[6] & 15 | 112; + bytes[8] = bytes[8] & 63 | 128; + return new _Uuid(_Uuid.bytesToBigInt(bytes)); + } + /** + * Parse a UUID from a string representation. + * + * @param s - UUID string + * @returns Parsed UUID + * @throws {Error} If the string is not a valid UUID + * + * @example + * ```ts + * const s = "01888d6e-5c00-7000-8000-000000000000"; + * const uuid = Uuid.parse(s); + * + * console.assert(uuid.toString() === s); + * ``` + */ + static parse(s) { + const hex = s.replace(/-/g, ""); + if (hex.length !== 32) throw new Error("Invalid hex UUID"); + let v = 0n; + for (let i = 0; i < 32; i += 2) v = v << 8n | BigInt(parseInt(hex.slice(i, i + 2), 16)); + return new _Uuid(v); + } + /** Convert to string (hyphenated form). */ + toString() { + const hex = [..._Uuid.bigIntToBytes(this.__uuid__)].map((b) => b.toString(16).padStart(2, "0")).join(""); + return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20); + } + /** Convert to bigint (u128). */ + asBigInt() { + return this.__uuid__; + } + /** Return a `Uint8Array` of 16 bytes. */ + toBytes() { + return _Uuid.bigIntToBytes(this.__uuid__); + } + static bytesToBigInt(bytes) { + let result = 0n; + for (const b of bytes) result = result << 8n | BigInt(b); + return result; + } + static bigIntToBytes(value) { + const bytes = new Uint8Array(16); + for (let i = 15; i >= 0; i--) { + bytes[i] = Number(value & 255n); + value >>= 8n; + } + return bytes; + } + /** + * Returns the version of this UUID. + * + * This represents the algorithm used to generate the value. + * + * @returns A `UuidVersion` + * @throws {Error} If the version field is not recognized + */ + getVersion() { + const version = this.toBytes()[6] >> 4 & 15; + switch (version) { + case 4: return "V4"; + case 7: return "V7"; + default: + if (this == _Uuid.NIL) return "Nil"; + if (this == _Uuid.MAX) return "Max"; + throw new Error(`Unsupported UUID version: ${version}`); + } + } + /** + * Extract the monotonic counter from a UUIDv7. + * + * Intended for testing and diagnostics. + * Behavior is undefined if called on a non-V7 UUID. + * + * @returns 31-bit counter value + */ + getCounter() { + const bytes = this.toBytes(); + const high = bytes[7]; + const mid1 = bytes[9]; + const mid2 = bytes[10]; + const low = bytes[11] >>> 1; + return high << 23 | mid1 << 15 | mid2 << 7 | low | 0; + } + compareTo(other) { + if (this.__uuid__ < other.__uuid__) return -1; + if (this.__uuid__ > other.__uuid__) return 1; + return 0; + } + static getAlgebraicType() { + return AlgebraicType.Product({ elements: [{ + name: "__uuid__", + algebraicType: AlgebraicType.U128 + }] }); + } +}; +var BinaryReader = class { + /** + * The DataView used to read values from the binary data. + * + * Note: The DataView's `byteOffset` is relative to the beginning of the + * underlying ArrayBuffer, not the start of the provided Uint8Array input. + * This `BinaryReader`'s `#offset` field is used to track the current read position + * relative to the start of the provided Uint8Array input. + */ + view; + /** + * Represents the offset (in bytes) relative to the start of the DataView + * and provided Uint8Array input. + * + * Note: This is *not* the absolute byte offset within the underlying ArrayBuffer. + */ + offset = 0; + constructor(input) { + this.view = input instanceof DataView ? input : new DataView(input.buffer, input.byteOffset, input.byteLength); + this.offset = 0; + } + reset(view) { + this.view = view; + this.offset = 0; + } + get remaining() { + return this.view.byteLength - this.offset; + } + /** Ensure we have at least `n` bytes left to read */ + #ensure(n) { + if (this.offset + n > this.view.byteLength) throw new RangeError(`Tried to read ${n} byte(s) at relative offset ${this.offset}, but only ${this.remaining} byte(s) remain`); + } + readUInt8Array() { + const length = this.readU32(); + this.#ensure(length); + return this.readBytes(length); + } + readBool() { + const value = this.view.getUint8(this.offset); + this.offset += 1; + return value !== 0; + } + readByte() { + const value = this.view.getUint8(this.offset); + this.offset += 1; + return value; + } + readBytes(length) { + const array = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, length); + this.offset += length; + return array; + } + readI8() { + const value = this.view.getInt8(this.offset); + this.offset += 1; + return value; + } + readU8() { + return this.readByte(); + } + readI16() { + const value = this.view.getInt16(this.offset, true); + this.offset += 2; + return value; + } + readU16() { + const value = this.view.getUint16(this.offset, true); + this.offset += 2; + return value; + } + readI32() { + const value = this.view.getInt32(this.offset, true); + this.offset += 4; + return value; + } + readU32() { + const value = this.view.getUint32(this.offset, true); + this.offset += 4; + return value; + } + readI64() { + const value = this.view.getBigInt64(this.offset, true); + this.offset += 8; + return value; + } + readU64() { + const value = this.view.getBigUint64(this.offset, true); + this.offset += 8; + return value; + } + readU128() { + const lowerPart = this.view.getBigUint64(this.offset, true); + const upperPart = this.view.getBigUint64(this.offset + 8, true); + this.offset += 16; + return (upperPart << BigInt(64)) + lowerPart; + } + readI128() { + const lowerPart = this.view.getBigUint64(this.offset, true); + const upperPart = this.view.getBigInt64(this.offset + 8, true); + this.offset += 16; + return (upperPart << BigInt(64)) + lowerPart; + } + readU256() { + const p0 = this.view.getBigUint64(this.offset, true); + const p1 = this.view.getBigUint64(this.offset + 8, true); + const p2 = this.view.getBigUint64(this.offset + 16, true); + const p3 = this.view.getBigUint64(this.offset + 24, true); + this.offset += 32; + return (p3 << BigInt(192)) + (p2 << BigInt(128)) + (p1 << BigInt(64)) + p0; + } + readI256() { + const p0 = this.view.getBigUint64(this.offset, true); + const p1 = this.view.getBigUint64(this.offset + 8, true); + const p2 = this.view.getBigUint64(this.offset + 16, true); + const p3 = this.view.getBigInt64(this.offset + 24, true); + this.offset += 32; + return (p3 << BigInt(192)) + (p2 << BigInt(128)) + (p1 << BigInt(64)) + p0; + } + readF32() { + const value = this.view.getFloat32(this.offset, true); + this.offset += 4; + return value; + } + readF64() { + const value = this.view.getFloat64(this.offset, true); + this.offset += 8; + return value; + } + readString() { + const uint8Array = this.readUInt8Array(); + return new TextDecoder("utf-8").decode(uint8Array); + } +}; +var import_base64_js = __toESM(require_base64_js()); +var ArrayBufferPrototypeTransfer = ArrayBuffer.prototype.transfer ?? function(newByteLength) { + if (newByteLength === void 0) return this.slice(); + else if (newByteLength <= this.byteLength) return this.slice(0, newByteLength); + else { + const copy = new Uint8Array(newByteLength); + copy.set(new Uint8Array(this)); + return copy.buffer; + } +}; +var ResizableBuffer = class { + buffer; + view; + constructor(init) { + this.buffer = typeof init === "number" ? new ArrayBuffer(init) : init; + this.view = new DataView(this.buffer); + } + get capacity() { + return this.buffer.byteLength; + } + grow(newSize) { + if (newSize <= this.buffer.byteLength) return; + this.buffer = ArrayBufferPrototypeTransfer.call(this.buffer, newSize); + this.view = new DataView(this.buffer); + } +}; +var BinaryWriter = class { + buffer; + offset = 0; + constructor(init) { + this.buffer = typeof init === "number" ? new ResizableBuffer(init) : init; + } + clear() { + this.offset = 0; + } + reset(buffer) { + this.buffer = buffer; + this.offset = 0; + } + expandBuffer(additionalCapacity) { + const minCapacity = this.offset + additionalCapacity + 1; + if (minCapacity <= this.buffer.capacity) return; + let newCapacity = this.buffer.capacity * 2; + if (newCapacity < minCapacity) newCapacity = minCapacity; + this.buffer.grow(newCapacity); + } + toBase64() { + return (0, import_base64_js.fromByteArray)(this.getBuffer()); + } + getBuffer() { + return new Uint8Array(this.buffer.buffer, 0, this.offset); + } + get view() { + return this.buffer.view; + } + writeUInt8Array(value) { + const length = value.length; + this.expandBuffer(4 + length); + this.writeU32(length); + new Uint8Array(this.buffer.buffer, this.offset).set(value); + this.offset += length; + } + writeBool(value) { + this.expandBuffer(1); + this.view.setUint8(this.offset, value ? 1 : 0); + this.offset += 1; + } + writeByte(value) { + this.expandBuffer(1); + this.view.setUint8(this.offset, value); + this.offset += 1; + } + writeI8(value) { + this.expandBuffer(1); + this.view.setInt8(this.offset, value); + this.offset += 1; + } + writeU8(value) { + this.expandBuffer(1); + this.view.setUint8(this.offset, value); + this.offset += 1; + } + writeI16(value) { + this.expandBuffer(2); + this.view.setInt16(this.offset, value, true); + this.offset += 2; + } + writeU16(value) { + this.expandBuffer(2); + this.view.setUint16(this.offset, value, true); + this.offset += 2; + } + writeI32(value) { + this.expandBuffer(4); + this.view.setInt32(this.offset, value, true); + this.offset += 4; + } + writeU32(value) { + this.expandBuffer(4); + this.view.setUint32(this.offset, value, true); + this.offset += 4; + } + writeI64(value) { + this.expandBuffer(8); + this.view.setBigInt64(this.offset, value, true); + this.offset += 8; + } + writeU64(value) { + this.expandBuffer(8); + this.view.setBigUint64(this.offset, value, true); + this.offset += 8; + } + writeU128(value) { + this.expandBuffer(16); + const lowerPart = value & BigInt("0xFFFFFFFFFFFFFFFF"); + const upperPart = value >> BigInt(64); + this.view.setBigUint64(this.offset, lowerPart, true); + this.view.setBigUint64(this.offset + 8, upperPart, true); + this.offset += 16; + } + writeI128(value) { + this.expandBuffer(16); + const lowerPart = value & BigInt("0xFFFFFFFFFFFFFFFF"); + const upperPart = value >> BigInt(64); + this.view.setBigInt64(this.offset, lowerPart, true); + this.view.setBigInt64(this.offset + 8, upperPart, true); + this.offset += 16; + } + writeU256(value) { + this.expandBuffer(32); + const low_64_mask = BigInt("0xFFFFFFFFFFFFFFFF"); + const p0 = value & low_64_mask; + const p1 = value >> BigInt(64) & low_64_mask; + const p2 = value >> BigInt(128) & low_64_mask; + const p3 = value >> BigInt(192); + this.view.setBigUint64(this.offset + 0, p0, true); + this.view.setBigUint64(this.offset + 8, p1, true); + this.view.setBigUint64(this.offset + 16, p2, true); + this.view.setBigUint64(this.offset + 24, p3, true); + this.offset += 32; + } + writeI256(value) { + this.expandBuffer(32); + const low_64_mask = BigInt("0xFFFFFFFFFFFFFFFF"); + const p0 = value & low_64_mask; + const p1 = value >> BigInt(64) & low_64_mask; + const p2 = value >> BigInt(128) & low_64_mask; + const p3 = value >> BigInt(192); + this.view.setBigUint64(this.offset + 0, p0, true); + this.view.setBigUint64(this.offset + 8, p1, true); + this.view.setBigUint64(this.offset + 16, p2, true); + this.view.setBigInt64(this.offset + 24, p3, true); + this.offset += 32; + } + writeF32(value) { + this.expandBuffer(4); + this.view.setFloat32(this.offset, value, true); + this.offset += 4; + } + writeF64(value) { + this.expandBuffer(8); + this.view.setFloat64(this.offset, value, true); + this.offset += 8; + } + writeString(value) { + const encodedString = new TextEncoder().encode(value); + this.writeUInt8Array(encodedString); + } +}; +function uint8ArrayToHexString(array) { + return Array.prototype.map.call(array.reverse(), (x) => ("00" + x.toString(16)).slice(-2)).join(""); +} +function uint8ArrayToU128(array) { + if (array.length != 16) throw new Error(`Uint8Array is not 16 bytes long: ${array}`); + return new BinaryReader(array).readU128(); +} +function uint8ArrayToU256(array) { + if (array.length != 32) throw new Error(`Uint8Array is not 32 bytes long: [${array}]`); + return new BinaryReader(array).readU256(); +} +function hexStringToUint8Array(str) { + if (str.startsWith("0x")) str = str.slice(2); + const matches = str.match(/.{1,2}/g) || []; + return Uint8Array.from(matches.map((byte) => parseInt(byte, 16))).reverse(); +} +function hexStringToU128(str) { + return uint8ArrayToU128(hexStringToUint8Array(str)); +} +function hexStringToU256(str) { + return uint8ArrayToU256(hexStringToUint8Array(str)); +} +function u128ToUint8Array(data) { + const writer = new BinaryWriter(16); + writer.writeU128(data); + return writer.getBuffer(); +} +function u128ToHexString(data) { + return uint8ArrayToHexString(u128ToUint8Array(data)); +} +function u256ToUint8Array(data) { + const writer = new BinaryWriter(32); + writer.writeU256(data); + return writer.getBuffer(); +} +function u256ToHexString(data) { + return uint8ArrayToHexString(u256ToUint8Array(data)); +} +function toPascalCase(s) { + const str = toCamelCase(s); + return str.charAt(0).toUpperCase() + str.slice(1); +} +function toCamelCase(s) { + const str = s.replace(/[-_]+/g, "_").replace(/_([a-zA-Z0-9])/g, (_, c) => c.toUpperCase()); + return str.charAt(0).toLowerCase() + str.slice(1); +} +function bsatnBaseSize(typespace, ty) { + const assumedArrayLength = 4; + while (ty.tag === "Ref") ty = typespace.types[ty.value]; + if (ty.tag === "Product") { + let sum = 0; + for (const { algebraicType: elem } of ty.value.elements) sum += bsatnBaseSize(typespace, elem); + return sum; + } else if (ty.tag === "Sum") { + let min = Infinity; + for (const { algebraicType: vari } of ty.value.variants) { + const vSize = bsatnBaseSize(typespace, vari); + if (vSize < min) min = vSize; + } + if (min === Infinity) min = 0; + return 4 + min; + } else if (ty.tag == "Array") return 4 + assumedArrayLength * bsatnBaseSize(typespace, ty.value); + return { + String: 4 + assumedArrayLength, + Sum: 1, + Bool: 1, + I8: 1, + U8: 1, + I16: 2, + U16: 2, + I32: 4, + U32: 4, + F32: 4, + I64: 8, + U64: 8, + F64: 8, + I128: 16, + U128: 16, + I256: 32, + U256: 32 + }[ty.tag]; +} +var hasOwn = Object.hasOwn; +var ConnectionId = class _ConnectionId { + __connection_id__; + /** + * Creates a new `ConnectionId`. + */ + constructor(data) { + this.__connection_id__ = data; + } + /** + * Get the algebraic type representation of the {@link ConnectionId} type. + * @returns The algebraic type representation of the type. + */ + static getAlgebraicType() { + return AlgebraicType.Product({ elements: [{ + name: "__connection_id__", + algebraicType: AlgebraicType.U128 + }] }); + } + isZero() { + return this.__connection_id__ === BigInt(0); + } + static nullIfZero(addr) { + if (addr.isZero()) return null; + else return addr; + } + static random() { + function randomU8() { + return Math.floor(Math.random() * 255); + } + let result = BigInt(0); + for (let i = 0; i < 16; i++) result = result << BigInt(8) | BigInt(randomU8()); + return new _ConnectionId(result); + } + /** + * Compare two connection IDs for equality. + */ + isEqual(other) { + return this.__connection_id__ == other.__connection_id__; + } + /** + * Check if two connection IDs are equal. + */ + equals(other) { + return this.isEqual(other); + } + /** + * Print the connection ID as a hexadecimal string. + */ + toHexString() { + return u128ToHexString(this.__connection_id__); + } + /** + * Convert the connection ID to a Uint8Array. + */ + toUint8Array() { + return u128ToUint8Array(this.__connection_id__); + } + /** + * Parse a connection ID from a hexadecimal string. + */ + static fromString(str) { + return new _ConnectionId(hexStringToU128(str)); + } + static fromStringOrNull(str) { + const addr = _ConnectionId.fromString(str); + if (addr.isZero()) return null; + else return addr; + } +}; +var Identity = class _Identity { + __identity__; + /** + * Creates a new `Identity`. + * + * `data` can be a hexadecimal string or a `bigint`. + */ + constructor(data) { + this.__identity__ = typeof data === "string" ? hexStringToU256(data) : data; + } + /** + * Get the algebraic type representation of the {@link Identity} type. + * @returns The algebraic type representation of the type. + */ + static getAlgebraicType() { + return AlgebraicType.Product({ elements: [{ + name: "__identity__", + algebraicType: AlgebraicType.U256 + }] }); + } + /** + * Check if two identities are equal. + */ + isEqual(other) { + return this.toHexString() === other.toHexString(); + } + /** + * Check if two identities are equal. + */ + equals(other) { + return this.isEqual(other); + } + /** + * Print the identity as a hexadecimal string. + */ + toHexString() { + return u256ToHexString(this.__identity__); + } + /** + * Convert the address to a Uint8Array. + */ + toUint8Array() { + return u256ToUint8Array(this.__identity__); + } + /** + * Parse an Identity from a hexadecimal string. + */ + static fromString(str) { + return new _Identity(str); + } + /** + * Zero identity (0x0000000000000000000000000000000000000000000000000000000000000000) + */ + static zero() { + return new _Identity(0n); + } + toString() { + return this.toHexString(); + } +}; +var SERIALIZERS = /* @__PURE__ */ new Map(); +var DESERIALIZERS = /* @__PURE__ */ new Map(); +var AlgebraicType = { + Ref: (value) => ({ + tag: "Ref", + value + }), + Sum: (value) => ({ + tag: "Sum", + value + }), + Product: (value) => ({ + tag: "Product", + value + }), + Array: (value) => ({ + tag: "Array", + value + }), + String: { tag: "String" }, + Bool: { tag: "Bool" }, + I8: { tag: "I8" }, + U8: { tag: "U8" }, + I16: { tag: "I16" }, + U16: { tag: "U16" }, + I32: { tag: "I32" }, + U32: { tag: "U32" }, + I64: { tag: "I64" }, + U64: { tag: "U64" }, + I128: { tag: "I128" }, + U128: { tag: "U128" }, + I256: { tag: "I256" }, + U256: { tag: "U256" }, + F32: { tag: "F32" }, + F64: { tag: "F64" }, + makeSerializer(ty, typespace) { + if (ty.tag === "Ref") { + if (!typespace) throw new Error("cannot serialize refs without a typespace"); + while (ty.tag === "Ref") ty = typespace.types[ty.value]; + } + switch (ty.tag) { + case "Product": return ProductType.makeSerializer(ty.value, typespace); + case "Sum": return SumType.makeSerializer(ty.value, typespace); + case "Array": if (ty.value.tag === "U8") return serializeUint8Array; + else { + const serialize = AlgebraicType.makeSerializer(ty.value, typespace); + return (writer, value) => { + writer.writeU32(value.length); + for (const elem of value) serialize(writer, elem); + }; + } + default: return primitiveSerializers[ty.tag]; + } + }, + serializeValue(writer, ty, value, typespace) { + AlgebraicType.makeSerializer(ty, typespace)(writer, value); + }, + makeDeserializer(ty, typespace) { + if (ty.tag === "Ref") { + if (!typespace) throw new Error("cannot deserialize refs without a typespace"); + while (ty.tag === "Ref") ty = typespace.types[ty.value]; + } + switch (ty.tag) { + case "Product": return ProductType.makeDeserializer(ty.value, typespace); + case "Sum": return SumType.makeDeserializer(ty.value, typespace); + case "Array": if (ty.value.tag === "U8") return deserializeUint8Array; + else { + const deserialize = AlgebraicType.makeDeserializer(ty.value, typespace); + return (reader) => { + const length = reader.readU32(); + const result = Array(length); + for (let i = 0; i < length; i++) result[i] = deserialize(reader); + return result; + }; + } + default: return primitiveDeserializers[ty.tag]; + } + }, + deserializeValue(reader, ty, typespace) { + return AlgebraicType.makeDeserializer(ty, typespace)(reader); + }, + intoMapKey: function(ty, value) { + switch (ty.tag) { + case "U8": + case "U16": + case "U32": + case "U64": + case "U128": + case "U256": + case "I8": + case "I16": + case "I32": + case "I64": + case "I128": + case "I256": + case "F32": + case "F64": + case "String": + case "Bool": return value; + case "Product": return ProductType.intoMapKey(ty.value, value); + default: { + const writer = new BinaryWriter(10); + AlgebraicType.serializeValue(writer, ty, value); + return writer.toBase64(); + } + } + } +}; +function bindCall(f) { + return Function.prototype.call.bind(f); +} +var primitiveSerializers = { + Bool: bindCall(BinaryWriter.prototype.writeBool), + I8: bindCall(BinaryWriter.prototype.writeI8), + U8: bindCall(BinaryWriter.prototype.writeU8), + I16: bindCall(BinaryWriter.prototype.writeI16), + U16: bindCall(BinaryWriter.prototype.writeU16), + I32: bindCall(BinaryWriter.prototype.writeI32), + U32: bindCall(BinaryWriter.prototype.writeU32), + I64: bindCall(BinaryWriter.prototype.writeI64), + U64: bindCall(BinaryWriter.prototype.writeU64), + I128: bindCall(BinaryWriter.prototype.writeI128), + U128: bindCall(BinaryWriter.prototype.writeU128), + I256: bindCall(BinaryWriter.prototype.writeI256), + U256: bindCall(BinaryWriter.prototype.writeU256), + F32: bindCall(BinaryWriter.prototype.writeF32), + F64: bindCall(BinaryWriter.prototype.writeF64), + String: bindCall(BinaryWriter.prototype.writeString) +}; +Object.freeze(primitiveSerializers); +var serializeUint8Array = bindCall(BinaryWriter.prototype.writeUInt8Array); +var primitiveDeserializers = { + Bool: bindCall(BinaryReader.prototype.readBool), + I8: bindCall(BinaryReader.prototype.readI8), + U8: bindCall(BinaryReader.prototype.readU8), + I16: bindCall(BinaryReader.prototype.readI16), + U16: bindCall(BinaryReader.prototype.readU16), + I32: bindCall(BinaryReader.prototype.readI32), + U32: bindCall(BinaryReader.prototype.readU32), + I64: bindCall(BinaryReader.prototype.readI64), + U64: bindCall(BinaryReader.prototype.readU64), + I128: bindCall(BinaryReader.prototype.readI128), + U128: bindCall(BinaryReader.prototype.readU128), + I256: bindCall(BinaryReader.prototype.readI256), + U256: bindCall(BinaryReader.prototype.readU256), + F32: bindCall(BinaryReader.prototype.readF32), + F64: bindCall(BinaryReader.prototype.readF64), + String: bindCall(BinaryReader.prototype.readString) +}; +Object.freeze(primitiveDeserializers); +var deserializeUint8Array = bindCall(BinaryReader.prototype.readUInt8Array); +var primitiveSizes = { + Bool: 1, + I8: 1, + U8: 1, + I16: 2, + U16: 2, + I32: 4, + U32: 4, + I64: 8, + U64: 8, + I128: 16, + U128: 16, + I256: 32, + U256: 32, + F32: 4, + F64: 8 +}; +var fixedSizePrimitives = new Set(Object.keys(primitiveSizes)); +var isFixedSizeProduct = (ty) => ty.elements.every(({ algebraicType }) => fixedSizePrimitives.has(algebraicType.tag)); +var productSize = (ty) => ty.elements.reduce((acc, { algebraicType }) => acc + primitiveSizes[algebraicType.tag], 0); +var primitiveJSName = { + Bool: "Uint8", + I8: "Int8", + U8: "Uint8", + I16: "Int16", + U16: "Uint16", + I32: "Int32", + U32: "Uint32", + I64: "BigInt64", + U64: "BigUint64", + F32: "Float32", + F64: "Float64" +}; +var specialProductDeserializers = { + __time_duration_micros__: (reader) => new TimeDuration(reader.readI64()), + __timestamp_micros_since_unix_epoch__: (reader) => new Timestamp(reader.readI64()), + __identity__: (reader) => new Identity(reader.readU256()), + __connection_id__: (reader) => new ConnectionId(reader.readU128()), + __uuid__: (reader) => new Uuid(reader.readU128()) +}; +Object.freeze(specialProductDeserializers); +var unitDeserializer = () => ({}); +var getElementInitializer = (element) => { + let init; + switch (element.algebraicType.tag) { + case "String": + init = "''"; + break; + case "Bool": + init = "false"; + break; + case "I8": + case "U8": + case "I16": + case "U16": + case "I32": + case "U32": + init = "0"; + break; + case "I64": + case "U64": + case "I128": + case "U128": + case "I256": + case "U256": + init = "0n"; + break; + case "F32": + case "F64": + init = "0.0"; + break; + default: init = "undefined"; + } + return `${element.name}: ${init}`; +}; +var ProductType = { + makeSerializer(ty, typespace) { + let serializer = SERIALIZERS.get(ty); + if (serializer != null) return serializer; + if (isFixedSizeProduct(ty)) { + const body2 = `"use strict"; +writer.expandBuffer(${productSize(ty)}); +const view = writer.view; +${ty.elements.map(({ name, algebraicType: { tag } }) => tag in primitiveJSName ? `view.set${primitiveJSName[tag]}(writer.offset, value.${name}, ${primitiveSizes[tag] > 1 ? "true" : ""}); +writer.offset += ${primitiveSizes[tag]};` : `writer.write${tag}(value.${name});`).join("\n")}`; + serializer = Function("writer", "value", body2); + SERIALIZERS.set(ty, serializer); + return serializer; + } + const serializers = {}; + const body = "\"use strict\";\n" + ty.elements.map((element) => `this.${element.name}(writer, value.${element.name});`).join("\n"); + serializer = Function("writer", "value", body).bind(serializers); + SERIALIZERS.set(ty, serializer); + for (const { name, algebraicType } of ty.elements) serializers[name] = AlgebraicType.makeSerializer(algebraicType, typespace); + Object.freeze(serializers); + return serializer; + }, + serializeValue(writer, ty, value, typespace) { + ProductType.makeSerializer(ty, typespace)(writer, value); + }, + makeDeserializer(ty, typespace) { + switch (ty.elements.length) { + case 0: return unitDeserializer; + case 1: { + const fieldName = ty.elements[0].name; + if (hasOwn(specialProductDeserializers, fieldName)) return specialProductDeserializers[fieldName]; + } + } + let deserializer = DESERIALIZERS.get(ty); + if (deserializer != null) return deserializer; + if (isFixedSizeProduct(ty)) { + const body = `"use strict"; +const result = { ${ty.elements.map(getElementInitializer).join(", ")} }; +const view = reader.view; +${ty.elements.map(({ name, algebraicType: { tag } }) => tag in primitiveJSName ? tag === "Bool" ? `result.${name} = view.getUint8(reader.offset) !== 0; +reader.offset += 1;` : `result.${name} = view.get${primitiveJSName[tag]}(reader.offset, ${primitiveSizes[tag] > 1 ? "true" : ""}); +reader.offset += ${primitiveSizes[tag]};` : `result.${name} = reader.read${tag}();`).join("\n")} +return result;`; + deserializer = Function("reader", body); + DESERIALIZERS.set(ty, deserializer); + return deserializer; + } + const deserializers = {}; + deserializer = Function("reader", `"use strict"; +const result = { ${ty.elements.map(getElementInitializer).join(", ")} }; +${ty.elements.map(({ name }) => `result.${name} = this.${name}(reader);`).join("\n")} +return result;`).bind(deserializers); + DESERIALIZERS.set(ty, deserializer); + for (const { name, algebraicType } of ty.elements) deserializers[name] = AlgebraicType.makeDeserializer(algebraicType, typespace); + Object.freeze(deserializers); + return deserializer; + }, + deserializeValue(reader, ty, typespace) { + return ProductType.makeDeserializer(ty, typespace)(reader); + }, + intoMapKey(ty, value) { + if (ty.elements.length === 1) { + const fieldName = ty.elements[0].name; + if (hasOwn(specialProductDeserializers, fieldName)) return value[fieldName]; + } + const writer = new BinaryWriter(10); + AlgebraicType.serializeValue(writer, AlgebraicType.Product(ty), value); + return writer.toBase64(); + } +}; +var SumType = { + makeSerializer(ty, typespace) { + if (ty.variants.length == 2 && ty.variants[0].name === "some" && ty.variants[1].name === "none") { + const serialize = AlgebraicType.makeSerializer(ty.variants[0].algebraicType, typespace); + return (writer, value) => { + if (value !== null && value !== void 0) { + writer.writeByte(0); + serialize(writer, value); + } else writer.writeByte(1); + }; + } else if (ty.variants.length == 2 && ty.variants[0].name === "ok" && ty.variants[1].name === "err") { + const serializeOk = AlgebraicType.makeSerializer(ty.variants[0].algebraicType, typespace); + const serializeErr = AlgebraicType.makeSerializer(ty.variants[0].algebraicType, typespace); + return (writer, value) => { + if ("ok" in value) { + writer.writeU8(0); + serializeOk(writer, value.ok); + } else if ("err" in value) { + writer.writeU8(1); + serializeErr(writer, value.err); + } else throw new TypeError("could not serialize result: object had neither a `ok` nor an `err` field"); + }; + } else { + let serializer = SERIALIZERS.get(ty); + if (serializer != null) return serializer; + const serializers = {}; + const body = `switch (value.tag) { +${ty.variants.map(({ name }, i) => ` case ${JSON.stringify(name)}: + writer.writeByte(${i}); + return this.${name}(writer, value.value);`).join("\n")} + default: + throw new TypeError( + \`Could not serialize sum type; unknown tag \${value.tag}\` + ) +} +`; + serializer = Function("writer", "value", body).bind(serializers); + SERIALIZERS.set(ty, serializer); + for (const { name, algebraicType } of ty.variants) serializers[name] = AlgebraicType.makeSerializer(algebraicType, typespace); + Object.freeze(serializers); + return serializer; + } + }, + serializeValue(writer, ty, value, typespace) { + SumType.makeSerializer(ty, typespace)(writer, value); + }, + makeDeserializer(ty, typespace) { + if (ty.variants.length == 2 && ty.variants[0].name === "some" && ty.variants[1].name === "none") { + const deserialize = AlgebraicType.makeDeserializer(ty.variants[0].algebraicType, typespace); + return (reader) => { + const tag = reader.readU8(); + if (tag === 0) return deserialize(reader); + else if (tag === 1) return; + else throw `Can't deserialize an option type, couldn't find ${tag} tag`; + }; + } else if (ty.variants.length == 2 && ty.variants[0].name === "ok" && ty.variants[1].name === "err") { + const deserializeOk = AlgebraicType.makeDeserializer(ty.variants[0].algebraicType, typespace); + const deserializeErr = AlgebraicType.makeDeserializer(ty.variants[1].algebraicType, typespace); + return (reader) => { + const tag = reader.readByte(); + if (tag === 0) return { ok: deserializeOk(reader) }; + else if (tag === 1) return { err: deserializeErr(reader) }; + else throw `Can't deserialize a result type, couldn't find ${tag} tag`; + }; + } else { + let deserializer = DESERIALIZERS.get(ty); + if (deserializer != null) return deserializer; + const deserializers = {}; + deserializer = Function("reader", `switch (reader.readU8()) { +${ty.variants.map(({ name }, i) => `case ${i}: return { tag: ${JSON.stringify(name)}, value: this.${name}(reader) };`).join("\n")} }`).bind(deserializers); + DESERIALIZERS.set(ty, deserializer); + for (const { name, algebraicType } of ty.variants) deserializers[name] = AlgebraicType.makeDeserializer(algebraicType, typespace); + Object.freeze(deserializers); + return deserializer; + } + }, + deserializeValue(reader, ty, typespace) { + return SumType.makeDeserializer(ty, typespace)(reader); + } +}; +var Option = { getAlgebraicType(innerType) { + return AlgebraicType.Sum({ variants: [{ + name: "some", + algebraicType: innerType + }, { + name: "none", + algebraicType: AlgebraicType.Product({ elements: [] }) + }] }); +} }; +var Result = { getAlgebraicType(okType, errType) { + return AlgebraicType.Sum({ variants: [{ + name: "ok", + algebraicType: okType + }, { + name: "err", + algebraicType: errType + }] }); +} }; +var ScheduleAt = { + interval(value) { + return Interval(value); + }, + time(value) { + return Time(value); + }, + getAlgebraicType() { + return AlgebraicType.Sum({ variants: [{ + name: "Interval", + algebraicType: TimeDuration.getAlgebraicType() + }, { + name: "Time", + algebraicType: Timestamp.getAlgebraicType() + }] }); + }, + isScheduleAt(algebraicType) { + if (algebraicType.tag !== "Sum") return false; + const variants = algebraicType.value.variants; + if (variants.length !== 2) return false; + const intervalVariant = variants.find((v) => v.name === "Interval"); + const timeVariant = variants.find((v) => v.name === "Time"); + if (!intervalVariant || !timeVariant) return false; + return TimeDuration.isTimeDuration(intervalVariant.algebraicType) && Timestamp.isTimestamp(timeVariant.algebraicType); + } +}; +var Interval = (micros) => ({ + tag: "Interval", + value: new TimeDuration(micros) +}); +var Time = (microsSinceUnixEpoch) => ({ + tag: "Time", + value: new Timestamp(microsSinceUnixEpoch) +}); +var schedule_at_default = ScheduleAt; +function set(x, t2) { + return { + ...x, + ...t2 + }; +} +var TypeBuilder = class { + /** + * The TypeScript phantom type. This is not stored at runtime, + * but is visible to the compiler + */ + type; + /** + * The SpacetimeDB algebraic type (run‑time value). In addition to storing + * the runtime representation of the `AlgebraicType`, it also captures + * the TypeScript type information of the `AlgebraicType`. That is to say + * the value is not merely an `AlgebraicType`, but is constructed to be + * the corresponding concrete `AlgebraicType` for the TypeScript type `Type`. + * + * e.g. `string` corresponds to `AlgebraicType.String` + */ + algebraicType; + constructor(algebraicType) { + this.algebraicType = algebraicType; + } + optional() { + return new OptionBuilder(this); + } + serialize(writer, value) { + (this.serialize = AlgebraicType.makeSerializer(this.algebraicType))(writer, value); + } + deserialize(reader) { + return (this.deserialize = AlgebraicType.makeDeserializer(this.algebraicType))(reader); + } +}; +var U8Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.U8); + } + index(algorithm = "btree") { + return new U8ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new U8ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new U8ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new U8ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new U8ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new U8ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var U16Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.U16); + } + index(algorithm = "btree") { + return new U16ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new U16ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new U16ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new U16ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new U16ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new U16ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var U32Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.U32); + } + index(algorithm = "btree") { + return new U32ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new U32ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new U32ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new U32ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new U32ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new U32ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var U64Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.U64); + } + index(algorithm = "btree") { + return new U64ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new U64ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new U64ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new U64ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new U64ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new U64ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var U128Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.U128); + } + index(algorithm = "btree") { + return new U128ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new U128ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new U128ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new U128ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new U128ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new U128ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var U256Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.U256); + } + index(algorithm = "btree") { + return new U256ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new U256ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new U256ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new U256ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new U256ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new U256ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var I8Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.I8); + } + index(algorithm = "btree") { + return new I8ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new I8ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new I8ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new I8ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new I8ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new I8ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var I16Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.I16); + } + index(algorithm = "btree") { + return new I16ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new I16ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new I16ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new I16ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new I16ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new I16ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var I32Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.I32); + } + index(algorithm = "btree") { + return new I32ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new I32ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new I32ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new I32ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new I32ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new I32ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var I64Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.I64); + } + index(algorithm = "btree") { + return new I64ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new I64ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new I64ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new I64ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new I64ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new I64ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var I128Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.I128); + } + index(algorithm = "btree") { + return new I128ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new I128ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new I128ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new I128ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new I128ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new I128ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var I256Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.I256); + } + index(algorithm = "btree") { + return new I256ColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new I256ColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new I256ColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new I256ColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new I256ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new I256ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var F32Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.F32); + } + default(value) { + return new F32ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new F32ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var F64Builder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.F64); + } + default(value) { + return new F64ColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new F64ColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var BoolBuilder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.Bool); + } + index(algorithm = "btree") { + return new BoolColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new BoolColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new BoolColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + default(value) { + return new BoolColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new BoolColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var StringBuilder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.String); + } + index(algorithm = "btree") { + return new StringColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new StringColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new StringColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + default(value) { + return new StringColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new StringColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var ArrayBuilder = class extends TypeBuilder { + element; + constructor(element) { + super(AlgebraicType.Array(element.algebraicType)); + this.element = element; + } + default(value) { + return new ArrayColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new ArrayColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var ByteArrayBuilder = class extends TypeBuilder { + constructor() { + super(AlgebraicType.Array(AlgebraicType.U8)); + } + default(value) { + return new ByteArrayColumnBuilder(set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new ByteArrayColumnBuilder(set(defaultMetadata, { name })); + } +}; +var OptionBuilder = class extends TypeBuilder { + value; + constructor(value) { + super(Option.getAlgebraicType(value.algebraicType)); + this.value = value; + } + default(value) { + return new OptionColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new OptionColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var ProductBuilder = class extends TypeBuilder { + typeName; + elements; + constructor(elements, name) { + function elementsArrayFromElementsObj(obj) { + return Object.keys(obj).map((key) => ({ + name: key, + get algebraicType() { + return obj[key].algebraicType; + } + })); + } + super(AlgebraicType.Product({ elements: elementsArrayFromElementsObj(elements) })); + this.typeName = name; + this.elements = elements; + } + default(value) { + return new ProductColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new ProductColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var ResultBuilder = class extends TypeBuilder { + ok; + err; + constructor(ok, err) { + super(Result.getAlgebraicType(ok.algebraicType, err.algebraicType)); + this.ok = ok; + this.err = err; + } + default(value) { + return new ResultColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } +}; +var UnitBuilder = class extends TypeBuilder { + constructor() { + super({ + tag: "Product", + value: { elements: [] } + }); + } +}; +var RowBuilder = class extends TypeBuilder { + row; + typeName; + constructor(row, name) { + const mappedRow = Object.fromEntries(Object.entries(row).map(([colName, builder]) => [colName, builder instanceof ColumnBuilder ? builder : new ColumnBuilder(builder, {})])); + const elements = Object.keys(mappedRow).map((name2) => ({ + name: name2, + get algebraicType() { + return mappedRow[name2].typeBuilder.algebraicType; + } + })); + super(AlgebraicType.Product({ elements })); + this.row = mappedRow; + this.typeName = name; + } +}; +var SumBuilderImpl = class extends TypeBuilder { + variants; + typeName; + constructor(variants, name) { + function variantsArrayFromVariantsObj(variants2) { + return Object.keys(variants2).map((key) => ({ + name: key, + get algebraicType() { + return variants2[key].algebraicType; + } + })); + } + super(AlgebraicType.Sum({ variants: variantsArrayFromVariantsObj(variants) })); + this.variants = variants; + this.typeName = name; + for (const key of Object.keys(variants)) { + const desc = Object.getOwnPropertyDescriptor(variants, key); + const isAccessor = !!desc && (typeof desc.get === "function" || typeof desc.set === "function"); + let isUnit2 = false; + if (!isAccessor) isUnit2 = variants[key] instanceof UnitBuilder; + if (isUnit2) { + const constant = this.create(key); + Object.defineProperty(this, key, { + value: constant, + writable: false, + enumerable: true, + configurable: false + }); + } else { + const fn = ((value) => this.create(key, value)); + Object.defineProperty(this, key, { + value: fn, + writable: false, + enumerable: true, + configurable: false + }); + } + } + } + create(tag, value) { + return value === void 0 ? { tag } : { + tag, + value + }; + } + default(value) { + return new SumColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new SumColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var SumBuilder = SumBuilderImpl; +var SimpleSumBuilderImpl = class extends SumBuilderImpl { + index(algorithm = "btree") { + return new SimpleSumColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + primaryKey() { + return new SimpleSumColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } +}; +var ScheduleAtBuilder = class extends TypeBuilder { + constructor() { + super(schedule_at_default.getAlgebraicType()); + } + default(value) { + return new ScheduleAtColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new ScheduleAtColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var IdentityBuilder = class extends TypeBuilder { + constructor() { + super(Identity.getAlgebraicType()); + } + index(algorithm = "btree") { + return new IdentityColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new IdentityColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new IdentityColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new IdentityColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new IdentityColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new IdentityColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var ConnectionIdBuilder = class extends TypeBuilder { + constructor() { + super(ConnectionId.getAlgebraicType()); + } + index(algorithm = "btree") { + return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var TimestampBuilder = class extends TypeBuilder { + constructor() { + super(Timestamp.getAlgebraicType()); + } + index(algorithm = "btree") { + return new TimestampColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new TimestampColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new TimestampColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new TimestampColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new TimestampColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new TimestampColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var TimeDurationBuilder = class extends TypeBuilder { + constructor() { + super(TimeDuration.getAlgebraicType()); + } + index(algorithm = "btree") { + return new TimeDurationColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new TimeDurationColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new TimeDurationColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new TimeDurationColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new TimeDurationColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new TimeDurationColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var UuidBuilder = class extends TypeBuilder { + constructor() { + super(Uuid.getAlgebraicType()); + } + index(algorithm = "btree") { + return new UuidColumnBuilder(this, set(defaultMetadata, { indexType: algorithm })); + } + unique() { + return new UuidColumnBuilder(this, set(defaultMetadata, { isUnique: true })); + } + primaryKey() { + return new UuidColumnBuilder(this, set(defaultMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new UuidColumnBuilder(this, set(defaultMetadata, { isAutoIncrement: true })); + } + default(value) { + return new UuidColumnBuilder(this, set(defaultMetadata, { defaultValue: value })); + } + name(name) { + return new UuidColumnBuilder(this, set(defaultMetadata, { name })); + } +}; +var defaultMetadata = {}; +var ColumnBuilder = class { + typeBuilder; + columnMetadata; + constructor(typeBuilder, metadata) { + this.typeBuilder = typeBuilder; + this.columnMetadata = metadata; + } + serialize(writer, value) { + this.typeBuilder.serialize(writer, value); + } + deserialize(reader) { + return this.typeBuilder.deserialize(reader); + } +}; +var U8ColumnBuilder = class _U8ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _U8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var U16ColumnBuilder = class _U16ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _U16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var U32ColumnBuilder = class _U32ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _U32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var U64ColumnBuilder = class _U64ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _U64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var U128ColumnBuilder = class _U128ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _U128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var U256ColumnBuilder = class _U256ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _U256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var I8ColumnBuilder = class _I8ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _I8ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var I16ColumnBuilder = class _I16ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _I16ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var I32ColumnBuilder = class _I32ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _I32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var I64ColumnBuilder = class _I64ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _I64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var I128ColumnBuilder = class _I128ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _I128ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var I256ColumnBuilder = class _I256ColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + autoInc() { + return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isAutoIncrement: true })); + } + default(value) { + return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _I256ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var F32ColumnBuilder = class _F32ColumnBuilder extends ColumnBuilder { + default(value) { + return new _F32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _F32ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var F64ColumnBuilder = class _F64ColumnBuilder extends ColumnBuilder { + default(value) { + return new _F64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _F64ColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var BoolColumnBuilder = class _BoolColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + default(value) { + return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _BoolColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var StringColumnBuilder = class _StringColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + default(value) { + return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _StringColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var ArrayColumnBuilder = class _ArrayColumnBuilder extends ColumnBuilder { + default(value) { + return new _ArrayColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _ArrayColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var ByteArrayColumnBuilder = class _ByteArrayColumnBuilder extends ColumnBuilder { + constructor(metadata) { + super(new TypeBuilder(AlgebraicType.Array(AlgebraicType.U8)), metadata); + } + default(value) { + return new _ByteArrayColumnBuilder(set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _ByteArrayColumnBuilder(set(this.columnMetadata, { name })); + } +}; +var OptionColumnBuilder = class _OptionColumnBuilder extends ColumnBuilder { + default(value) { + return new _OptionColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _OptionColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var ResultColumnBuilder = class _ResultColumnBuilder extends ColumnBuilder { + constructor(typeBuilder, metadata) { + super(typeBuilder, metadata); + } + default(value) { + return new _ResultColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } +}; +var ProductColumnBuilder = class _ProductColumnBuilder extends ColumnBuilder { + default(value) { + return new _ProductColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _ProductColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var SumColumnBuilder = class _SumColumnBuilder extends ColumnBuilder { + default(value) { + return new _SumColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _SumColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var SimpleSumColumnBuilder = class _SimpleSumColumnBuilder extends SumColumnBuilder { + index(algorithm = "btree") { + return new _SimpleSumColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + primaryKey() { + return new _SimpleSumColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } +}; +var ScheduleAtColumnBuilder = class _ScheduleAtColumnBuilder extends ColumnBuilder { + default(value) { + return new _ScheduleAtColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _ScheduleAtColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var IdentityColumnBuilder = class _IdentityColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + default(value) { + return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _IdentityColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var ConnectionIdColumnBuilder = class _ConnectionIdColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + default(value) { + return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _ConnectionIdColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var TimestampColumnBuilder = class _TimestampColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + default(value) { + return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _TimestampColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var TimeDurationColumnBuilder = class _TimeDurationColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + default(value) { + return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _TimeDurationColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var UuidColumnBuilder = class _UuidColumnBuilder extends ColumnBuilder { + index(algorithm = "btree") { + return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { indexType: algorithm })); + } + unique() { + return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isUnique: true })); + } + primaryKey() { + return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { isPrimaryKey: true })); + } + default(value) { + return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { defaultValue: value })); + } + name(name) { + return new _UuidColumnBuilder(this.typeBuilder, set(this.columnMetadata, { name })); + } +}; +var RefBuilder = class extends TypeBuilder { + ref; + /** The phantom type of the pointee of this ref. */ + __spacetimeType; + constructor(ref) { + super(AlgebraicType.Ref(ref)); + this.ref = ref; + } +}; +var enumImpl = ((nameOrObj, maybeObj) => { + let obj = nameOrObj; + let name = void 0; + if (typeof nameOrObj === "string") { + if (!maybeObj) throw new TypeError("When providing a name, you must also provide the variants object or array."); + obj = maybeObj; + name = nameOrObj; + } + if (Array.isArray(obj)) { + const simpleVariantsObj = {}; + for (const variant of obj) simpleVariantsObj[variant] = new UnitBuilder(); + return new SimpleSumBuilderImpl(simpleVariantsObj, name); + } + return new SumBuilder(obj, name); +}); +var t = { + bool: () => new BoolBuilder(), + string: () => new StringBuilder(), + number: () => new F64Builder(), + i8: () => new I8Builder(), + u8: () => new U8Builder(), + i16: () => new I16Builder(), + u16: () => new U16Builder(), + i32: () => new I32Builder(), + u32: () => new U32Builder(), + i64: () => new I64Builder(), + u64: () => new U64Builder(), + i128: () => new I128Builder(), + u128: () => new U128Builder(), + i256: () => new I256Builder(), + u256: () => new U256Builder(), + f32: () => new F32Builder(), + f64: () => new F64Builder(), + object: ((nameOrObj, maybeObj) => { + if (typeof nameOrObj === "string") { + if (!maybeObj) throw new TypeError("When providing a name, you must also provide the object."); + return new ProductBuilder(maybeObj, nameOrObj); + } + return new ProductBuilder(nameOrObj, void 0); + }), + row: ((nameOrObj, maybeObj) => { + const [obj, name] = typeof nameOrObj === "string" ? [maybeObj, nameOrObj] : [nameOrObj, void 0]; + return new RowBuilder(obj, name); + }), + array(e) { + return new ArrayBuilder(e); + }, + enum: enumImpl, + unit() { + return new UnitBuilder(); + }, + lazy(thunk) { + let cached = null; + const get = () => cached ??= thunk(); + return new Proxy({}, { + get(_t, prop, recv) { + const target = get(); + const val = Reflect.get(target, prop, recv); + return typeof val === "function" ? val.bind(target) : val; + }, + set(_t, prop, value, recv) { + return Reflect.set(get(), prop, value, recv); + }, + has(_t, prop) { + return prop in get(); + }, + ownKeys() { + return Reflect.ownKeys(get()); + }, + getOwnPropertyDescriptor(_t, prop) { + return Object.getOwnPropertyDescriptor(get(), prop); + }, + getPrototypeOf() { + return Object.getPrototypeOf(get()); + } + }); + }, + scheduleAt: () => { + return new ScheduleAtBuilder(); + }, + option(value) { + return new OptionBuilder(value); + }, + result(ok, err) { + return new ResultBuilder(ok, err); + }, + identity: () => { + return new IdentityBuilder(); + }, + connectionId: () => { + return new ConnectionIdBuilder(); + }, + timestamp: () => { + return new TimestampBuilder(); + }, + timeDuration: () => { + return new TimeDurationBuilder(); + }, + uuid: () => { + return new UuidBuilder(); + }, + byteArray: () => { + return new ByteArrayBuilder(); + } +}; +var AlgebraicType2 = t.enum("AlgebraicType", { + Ref: t.u32(), + get Sum() { + return SumType2; + }, + get Product() { + return ProductType2; + }, + get Array() { + return AlgebraicType2; + }, + String: t.unit(), + Bool: t.unit(), + I8: t.unit(), + U8: t.unit(), + I16: t.unit(), + U16: t.unit(), + I32: t.unit(), + U32: t.unit(), + I64: t.unit(), + U64: t.unit(), + I128: t.unit(), + U128: t.unit(), + I256: t.unit(), + U256: t.unit(), + F32: t.unit(), + F64: t.unit() +}); +var CaseConversionPolicy = t.enum("CaseConversionPolicy", { + None: t.unit(), + SnakeCase: t.unit() +}); +var ExplicitNameEntry = t.enum("ExplicitNameEntry", { + get Table() { + return NameMapping; + }, + get Function() { + return NameMapping; + }, + get Index() { + return NameMapping; + } +}); +var ExplicitNames = t.object("ExplicitNames", { get entries() { + return t.array(ExplicitNameEntry); +} }); +var FunctionVisibility = t.enum("FunctionVisibility", { + Private: t.unit(), + ClientCallable: t.unit() +}); +var HttpHeaderPair = t.object("HttpHeaderPair", { + name: t.string(), + value: t.byteArray() +}); +var HttpHeaders = t.object("HttpHeaders", { get entries() { + return t.array(HttpHeaderPair); +} }); +var HttpMethod = t.enum("HttpMethod", { + Get: t.unit(), + Head: t.unit(), + Post: t.unit(), + Put: t.unit(), + Delete: t.unit(), + Connect: t.unit(), + Options: t.unit(), + Trace: t.unit(), + Patch: t.unit(), + Extension: t.string() +}); +var HttpRequest = t.object("HttpRequest", { + get method() { + return HttpMethod; + }, + get headers() { + return HttpHeaders; + }, + timeout: t.option(t.timeDuration()), + uri: t.string(), + get version() { + return HttpVersion; + } +}); +var HttpResponse = t.object("HttpResponse", { + get headers() { + return HttpHeaders; + }, + get version() { + return HttpVersion; + }, + code: t.u16() +}); +var HttpVersion = t.enum("HttpVersion", { + Http09: t.unit(), + Http10: t.unit(), + Http11: t.unit(), + Http2: t.unit(), + Http3: t.unit() +}); +var IndexType = t.enum("IndexType", { + BTree: t.unit(), + Hash: t.unit() +}); +var Lifecycle = t.enum("Lifecycle", { + Init: t.unit(), + OnConnect: t.unit(), + OnDisconnect: t.unit() +}); +var MiscModuleExport = t.enum("MiscModuleExport", { get TypeAlias() { + return TypeAlias; +} }); +var NameMapping = t.object("NameMapping", { + sourceName: t.string(), + canonicalName: t.string() +}); +var ProductType2 = t.object("ProductType", { get elements() { + return t.array(ProductTypeElement); +} }); +var ProductTypeElement = t.object("ProductTypeElement", { + name: t.option(t.string()), + get algebraicType() { + return AlgebraicType2; + } +}); +var RawColumnDefV8 = t.object("RawColumnDefV8", { + colName: t.string(), + get colType() { + return AlgebraicType2; + } +}); +var RawColumnDefaultValueV10 = t.object("RawColumnDefaultValueV10", { + colId: t.u16(), + value: t.byteArray() +}); +var RawColumnDefaultValueV9 = t.object("RawColumnDefaultValueV9", { + table: t.string(), + colId: t.u16(), + value: t.byteArray() +}); +var RawConstraintDataV9 = t.enum("RawConstraintDataV9", { get Unique() { + return RawUniqueConstraintDataV9; +} }); +var RawConstraintDefV10 = t.object("RawConstraintDefV10", { + sourceName: t.option(t.string()), + get data() { + return RawConstraintDataV9; + } +}); +var RawConstraintDefV8 = t.object("RawConstraintDefV8", { + constraintName: t.string(), + constraints: t.u8(), + columns: t.array(t.u16()) +}); +var RawConstraintDefV9 = t.object("RawConstraintDefV9", { + name: t.option(t.string()), + get data() { + return RawConstraintDataV9; + } +}); +var RawIndexAlgorithm = t.enum("RawIndexAlgorithm", { + BTree: t.array(t.u16()), + Hash: t.array(t.u16()), + Direct: t.u16() +}); +var RawIndexDefV10 = t.object("RawIndexDefV10", { + sourceName: t.option(t.string()), + accessorName: t.option(t.string()), + get algorithm() { + return RawIndexAlgorithm; + } +}); +var RawIndexDefV8 = t.object("RawIndexDefV8", { + indexName: t.string(), + isUnique: t.bool(), + get indexType() { + return IndexType; + }, + columns: t.array(t.u16()) +}); +var RawIndexDefV9 = t.object("RawIndexDefV9", { + name: t.option(t.string()), + accessorName: t.option(t.string()), + get algorithm() { + return RawIndexAlgorithm; + } +}); +var RawLifeCycleReducerDefV10 = t.object("RawLifeCycleReducerDefV10", { + get lifecycleSpec() { + return Lifecycle; + }, + functionName: t.string() +}); +var RawMiscModuleExportV9 = t.enum("RawMiscModuleExportV9", { + get ColumnDefaultValue() { + return RawColumnDefaultValueV9; + }, + get Procedure() { + return RawProcedureDefV9; + }, + get View() { + return RawViewDefV9; + } +}); +var RawModuleDef = t.enum("RawModuleDef", { + get V8BackCompat() { + return RawModuleDefV8; + }, + get V9() { + return RawModuleDefV9; + }, + get V10() { + return RawModuleDefV10; + } +}); +var RawModuleDefV10 = t.object("RawModuleDefV10", { get sections() { + return t.array(RawModuleDefV10Section); +} }); +var RawModuleDefV10Section = t.enum("RawModuleDefV10Section", { + get Typespace() { + return Typespace; + }, + get Types() { + return t.array(RawTypeDefV10); + }, + get Tables() { + return t.array(RawTableDefV10); + }, + get Reducers() { + return t.array(RawReducerDefV10); + }, + get Procedures() { + return t.array(RawProcedureDefV10); + }, + get Views() { + return t.array(RawViewDefV10); + }, + get Schedules() { + return t.array(RawScheduleDefV10); + }, + get LifeCycleReducers() { + return t.array(RawLifeCycleReducerDefV10); + }, + get RowLevelSecurity() { + return t.array(RawRowLevelSecurityDefV9); + }, + get CaseConversionPolicy() { + return CaseConversionPolicy; + }, + get ExplicitNames() { + return ExplicitNames; + } +}); +var RawModuleDefV8 = t.object("RawModuleDefV8", { + get typespace() { + return Typespace; + }, + get tables() { + return t.array(TableDesc); + }, + get reducers() { + return t.array(ReducerDef); + }, + get miscExports() { + return t.array(MiscModuleExport); + } +}); +var RawModuleDefV9 = t.object("RawModuleDefV9", { + get typespace() { + return Typespace; + }, + get tables() { + return t.array(RawTableDefV9); + }, + get reducers() { + return t.array(RawReducerDefV9); + }, + get types() { + return t.array(RawTypeDefV9); + }, + get miscExports() { + return t.array(RawMiscModuleExportV9); + }, + get rowLevelSecurity() { + return t.array(RawRowLevelSecurityDefV9); + } +}); +var RawProcedureDefV10 = t.object("RawProcedureDefV10", { + sourceName: t.string(), + get params() { + return ProductType2; + }, + get returnType() { + return AlgebraicType2; + }, + get visibility() { + return FunctionVisibility; + } +}); +var RawProcedureDefV9 = t.object("RawProcedureDefV9", { + name: t.string(), + get params() { + return ProductType2; + }, + get returnType() { + return AlgebraicType2; + } +}); +var RawReducerDefV10 = t.object("RawReducerDefV10", { + sourceName: t.string(), + get params() { + return ProductType2; + }, + get visibility() { + return FunctionVisibility; + }, + get okReturnType() { + return AlgebraicType2; + }, + get errReturnType() { + return AlgebraicType2; + } +}); +var RawReducerDefV9 = t.object("RawReducerDefV9", { + name: t.string(), + get params() { + return ProductType2; + }, + get lifecycle() { + return t.option(Lifecycle); + } +}); +var RawRowLevelSecurityDefV9 = t.object("RawRowLevelSecurityDefV9", { sql: t.string() }); +var RawScheduleDefV10 = t.object("RawScheduleDefV10", { + sourceName: t.option(t.string()), + tableName: t.string(), + scheduleAtCol: t.u16(), + functionName: t.string() +}); +var RawScheduleDefV9 = t.object("RawScheduleDefV9", { + name: t.option(t.string()), + reducerName: t.string(), + scheduledAtColumn: t.u16() +}); +var RawScopedTypeNameV10 = t.object("RawScopedTypeNameV10", { + scope: t.array(t.string()), + sourceName: t.string() +}); +var RawScopedTypeNameV9 = t.object("RawScopedTypeNameV9", { + scope: t.array(t.string()), + name: t.string() +}); +var RawSequenceDefV10 = t.object("RawSequenceDefV10", { + sourceName: t.option(t.string()), + column: t.u16(), + start: t.option(t.i128()), + minValue: t.option(t.i128()), + maxValue: t.option(t.i128()), + increment: t.i128() +}); +var RawSequenceDefV8 = t.object("RawSequenceDefV8", { + sequenceName: t.string(), + colPos: t.u16(), + increment: t.i128(), + start: t.option(t.i128()), + minValue: t.option(t.i128()), + maxValue: t.option(t.i128()), + allocated: t.i128() +}); +var RawSequenceDefV9 = t.object("RawSequenceDefV9", { + name: t.option(t.string()), + column: t.u16(), + start: t.option(t.i128()), + minValue: t.option(t.i128()), + maxValue: t.option(t.i128()), + increment: t.i128() +}); +var RawTableDefV10 = t.object("RawTableDefV10", { + sourceName: t.string(), + productTypeRef: t.u32(), + primaryKey: t.array(t.u16()), + get indexes() { + return t.array(RawIndexDefV10); + }, + get constraints() { + return t.array(RawConstraintDefV10); + }, + get sequences() { + return t.array(RawSequenceDefV10); + }, + get tableType() { + return TableType; + }, + get tableAccess() { + return TableAccess; + }, + get defaultValues() { + return t.array(RawColumnDefaultValueV10); + }, + isEvent: t.bool() +}); +var RawTableDefV8 = t.object("RawTableDefV8", { + tableName: t.string(), + get columns() { + return t.array(RawColumnDefV8); + }, + get indexes() { + return t.array(RawIndexDefV8); + }, + get constraints() { + return t.array(RawConstraintDefV8); + }, + get sequences() { + return t.array(RawSequenceDefV8); + }, + tableType: t.string(), + tableAccess: t.string(), + scheduled: t.option(t.string()) +}); +var RawTableDefV9 = t.object("RawTableDefV9", { + name: t.string(), + productTypeRef: t.u32(), + primaryKey: t.array(t.u16()), + get indexes() { + return t.array(RawIndexDefV9); + }, + get constraints() { + return t.array(RawConstraintDefV9); + }, + get sequences() { + return t.array(RawSequenceDefV9); + }, + get schedule() { + return t.option(RawScheduleDefV9); + }, + get tableType() { + return TableType; + }, + get tableAccess() { + return TableAccess; + } +}); +var RawTypeDefV10 = t.object("RawTypeDefV10", { + get sourceName() { + return RawScopedTypeNameV10; + }, + ty: t.u32(), + customOrdering: t.bool() +}); +var RawTypeDefV9 = t.object("RawTypeDefV9", { + get name() { + return RawScopedTypeNameV9; + }, + ty: t.u32(), + customOrdering: t.bool() +}); +var RawUniqueConstraintDataV9 = t.object("RawUniqueConstraintDataV9", { columns: t.array(t.u16()) }); +var RawViewDefV10 = t.object("RawViewDefV10", { + sourceName: t.string(), + index: t.u32(), + isPublic: t.bool(), + isAnonymous: t.bool(), + get params() { + return ProductType2; + }, + get returnType() { + return AlgebraicType2; + } +}); +var RawViewDefV9 = t.object("RawViewDefV9", { + name: t.string(), + index: t.u32(), + isPublic: t.bool(), + isAnonymous: t.bool(), + get params() { + return ProductType2; + }, + get returnType() { + return AlgebraicType2; + } +}); +var ReducerDef = t.object("ReducerDef", { + name: t.string(), + get args() { + return t.array(ProductTypeElement); + } +}); +var SumType2 = t.object("SumType", { get variants() { + return t.array(SumTypeVariant); +} }); +var SumTypeVariant = t.object("SumTypeVariant", { + name: t.option(t.string()), + get algebraicType() { + return AlgebraicType2; + } +}); +var TableAccess = t.enum("TableAccess", { + Public: t.unit(), + Private: t.unit() +}); +var TableDesc = t.object("TableDesc", { + get schema() { + return RawTableDefV8; + }, + data: t.u32() +}); +var TableType = t.enum("TableType", { + System: t.unit(), + User: t.unit() +}); +var TypeAlias = t.object("TypeAlias", { + name: t.string(), + ty: t.u32() +}); +var Typespace = t.object("Typespace", { get types() { + return t.array(AlgebraicType2); +} }); +var ViewResultHeader = t.enum("ViewResultHeader", { + RowData: t.unit(), + RawSql: t.string() +}); +function tableToSchema(accName, schema2, tableDef) { + const getColName = (i) => schema2.rowType.algebraicType.value.elements[i].name; + const resolvedIndexes = tableDef.indexes.map((idx) => { + const accessorName = idx.accessorName; + if (typeof accessorName !== "string" || accessorName.length === 0) throw new TypeError(`Index '${idx.sourceName ?? ""}' on table '${tableDef.sourceName}' is missing accessor name`); + const columnIds = idx.algorithm.tag === "Direct" ? [idx.algorithm.value] : idx.algorithm.value; + return { + name: accessorName, + unique: tableDef.constraints.some((c) => c.data.tag === "Unique" && c.data.value.columns.every((col) => columnIds.includes(col))), + algorithm: { + BTree: "btree", + Hash: "hash", + Direct: "direct" + }[idx.algorithm.tag], + columns: columnIds.map(getColName) + }; + }); + return { + sourceName: schema2.tableName || accName, + accessorName: accName, + columns: schema2.rowType.row, + rowType: schema2.rowSpacetimeType, + indexes: schema2.idxs, + constraints: tableDef.constraints.map((c) => ({ + name: c.sourceName, + constraint: "unique", + columns: c.data.value.columns.map(getColName) + })), + resolvedIndexes, + tableDef, + ...tableDef.isEvent ? { isEvent: true } : {} + }; +} +var ModuleContext = class { + #compoundTypes = /* @__PURE__ */ new Map(); + /** + * The global module definition that gets populated by calls to `reducer()` and lifecycle hooks. + */ + #moduleDef = { + typespace: { types: [] }, + tables: [], + reducers: [], + types: [], + rowLevelSecurity: [], + schedules: [], + procedures: [], + views: [], + lifeCycleReducers: [], + caseConversionPolicy: { tag: "SnakeCase" }, + explicitNames: { entries: [] } + }; + get moduleDef() { + return this.#moduleDef; + } + rawModuleDefV10() { + const sections = []; + const push = (s) => { + if (s) sections.push(s); + }; + const module = this.#moduleDef; + push(module.typespace && { + tag: "Typespace", + value: module.typespace + }); + push(module.types && { + tag: "Types", + value: module.types + }); + push(module.tables && { + tag: "Tables", + value: module.tables + }); + push(module.reducers && { + tag: "Reducers", + value: module.reducers + }); + push(module.procedures && { + tag: "Procedures", + value: module.procedures + }); + push(module.views && { + tag: "Views", + value: module.views + }); + push(module.schedules && { + tag: "Schedules", + value: module.schedules + }); + push(module.lifeCycleReducers && { + tag: "LifeCycleReducers", + value: module.lifeCycleReducers + }); + push(module.rowLevelSecurity && { + tag: "RowLevelSecurity", + value: module.rowLevelSecurity + }); + push(module.explicitNames && { + tag: "ExplicitNames", + value: module.explicitNames + }); + push(module.caseConversionPolicy && { + tag: "CaseConversionPolicy", + value: module.caseConversionPolicy + }); + return { sections }; + } + /** + * Set the case conversion policy for this module. + * Called by the settings mechanism. + */ + setCaseConversionPolicy(policy) { + this.#moduleDef.caseConversionPolicy = policy; + } + get typespace() { + return this.#moduleDef.typespace; + } + /** + * Resolves the actual type of a TypeBuilder by following its references until it reaches a non-ref type. + * @param typespace The typespace to resolve types against. + * @param typeBuilder The TypeBuilder to resolve. + * @returns The resolved algebraic type. + */ + resolveType(typeBuilder) { + let ty = typeBuilder.algebraicType; + while (ty.tag === "Ref") ty = this.typespace.types[ty.value]; + return ty; + } + /** + * Adds a type to the module definition's typespace as a `Ref` if it is a named compound type (Product or Sum). + * Otherwise, returns the type as is. + * @param name + * @param ty + * @returns + */ + registerTypesRecursively(typeBuilder) { + if (typeBuilder instanceof ProductBuilder && !isUnit(typeBuilder) || typeBuilder instanceof SumBuilder || typeBuilder instanceof RowBuilder) return this.#registerCompoundTypeRecursively(typeBuilder); + else if (typeBuilder instanceof OptionBuilder) return new OptionBuilder(this.registerTypesRecursively(typeBuilder.value)); + else if (typeBuilder instanceof ResultBuilder) return new ResultBuilder(this.registerTypesRecursively(typeBuilder.ok), this.registerTypesRecursively(typeBuilder.err)); + else if (typeBuilder instanceof ArrayBuilder) return new ArrayBuilder(this.registerTypesRecursively(typeBuilder.element)); + else return typeBuilder; + } + #registerCompoundTypeRecursively(typeBuilder) { + const ty = typeBuilder.algebraicType; + const name = typeBuilder.typeName; + if (name === void 0) throw new Error(`Missing type name for ${typeBuilder.constructor.name ?? "TypeBuilder"} ${JSON.stringify(typeBuilder)}`); + let r = this.#compoundTypes.get(ty); + if (r != null) return r; + const newTy = typeBuilder instanceof RowBuilder || typeBuilder instanceof ProductBuilder ? { + tag: "Product", + value: { elements: [] } + } : { + tag: "Sum", + value: { variants: [] } + }; + r = new RefBuilder(this.#moduleDef.typespace.types.length); + this.#moduleDef.typespace.types.push(newTy); + this.#compoundTypes.set(ty, r); + if (typeBuilder instanceof RowBuilder) for (const [name2, elem] of Object.entries(typeBuilder.row)) newTy.value.elements.push({ + name: name2, + algebraicType: this.registerTypesRecursively(elem.typeBuilder).algebraicType + }); + else if (typeBuilder instanceof ProductBuilder) for (const [name2, elem] of Object.entries(typeBuilder.elements)) newTy.value.elements.push({ + name: name2, + algebraicType: this.registerTypesRecursively(elem).algebraicType + }); + else if (typeBuilder instanceof SumBuilder) for (const [name2, variant] of Object.entries(typeBuilder.variants)) newTy.value.variants.push({ + name: name2, + algebraicType: this.registerTypesRecursively(variant).algebraicType + }); + this.#moduleDef.types.push({ + sourceName: splitName(name), + ty: r.ref, + customOrdering: true + }); + return r; + } +}; +function isUnit(typeBuilder) { + return typeBuilder.typeName == null && typeBuilder.algebraicType.value.elements.length === 0; +} +function splitName(name) { + const scope = name.split("."); + return { + sourceName: scope.pop(), + scope + }; +} +var import_statuses = __toESM(require_statuses()); +var Range = class { + #from; + #to; + constructor(from, to) { + this.#from = from ?? { tag: "unbounded" }; + this.#to = to ?? { tag: "unbounded" }; + } + get from() { + return this.#from; + } + get to() { + return this.#to; + } +}; +function table(opts, row, ..._) { + const { name, public: isPublic = false, indexes: userIndexes = [], scheduled, event: isEvent = false } = opts; + const colIds = /* @__PURE__ */ new Map(); + const colNameList = []; + if (!(row instanceof RowBuilder)) row = new RowBuilder(row); + row.algebraicType.value.elements.forEach((elem, i) => { + colIds.set(elem.name, i); + colNameList.push(elem.name); + }); + const pk = []; + const indexes = []; + const constraints = []; + const sequences = []; + let scheduleAtCol; + const defaultValues = []; + for (const [name2, builder] of Object.entries(row.row)) { + const meta = builder.columnMetadata; + if (meta.isPrimaryKey) pk.push(colIds.get(name2)); + const isUnique = meta.isUnique || meta.isPrimaryKey; + if (meta.indexType || isUnique) { + const algo = meta.indexType ?? "btree"; + const id = colIds.get(name2); + let algorithm; + switch (algo) { + case "btree": + algorithm = RawIndexAlgorithm.BTree([id]); + break; + case "hash": + algorithm = RawIndexAlgorithm.Hash([id]); + break; + case "direct": + algorithm = RawIndexAlgorithm.Direct(id); + break; + } + indexes.push({ + sourceName: void 0, + accessorName: name2, + algorithm + }); + } + if (isUnique) constraints.push({ + sourceName: void 0, + data: { + tag: "Unique", + value: { columns: [colIds.get(name2)] } + } + }); + if (meta.isAutoIncrement) sequences.push({ + sourceName: void 0, + start: void 0, + minValue: void 0, + maxValue: void 0, + column: colIds.get(name2), + increment: 1n + }); + if (meta.defaultValue) { + const writer = new BinaryWriter(16); + builder.serialize(writer, meta.defaultValue); + defaultValues.push({ + colId: colIds.get(name2), + value: writer.getBuffer() + }); + } + if (scheduled) { + const algebraicType = builder.typeBuilder.algebraicType; + if (schedule_at_default.isScheduleAt(algebraicType)) scheduleAtCol = colIds.get(name2); + } + } + for (const indexOpts of userIndexes ?? []) { + const accessor = indexOpts.accessor; + if (typeof accessor !== "string" || accessor.length === 0) { + const tableLabel = name ?? ""; + const indexLabel = indexOpts.name ?? ""; + throw new TypeError(`Index '${indexLabel}' on table '${tableLabel}' must define a non-empty 'accessor'`); + } + let algorithm; + switch (indexOpts.algorithm) { + case "btree": + algorithm = { + tag: "BTree", + value: indexOpts.columns.map((c) => colIds.get(c)) + }; + break; + case "hash": + algorithm = { + tag: "Hash", + value: indexOpts.columns.map((c) => colIds.get(c)) + }; + break; + case "direct": + algorithm = { + tag: "Direct", + value: colIds.get(indexOpts.column) + }; + break; + } + indexes.push({ + sourceName: void 0, + accessorName: accessor, + algorithm, + canonicalName: indexOpts.name + }); + } + for (const constraintOpts of opts.constraints ?? []) if (constraintOpts.constraint === "unique") { + const data = { + tag: "Unique", + value: { columns: constraintOpts.columns.map((c) => colIds.get(c)) } + }; + constraints.push({ + sourceName: constraintOpts.name, + data + }); + continue; + } + const productType = row.algebraicType.value; + return { + rowType: row, + tableName: name, + rowSpacetimeType: productType, + tableDef: (ctx, accName) => { + const tableName = name ?? accName; + if (row.typeName === void 0) row.typeName = toPascalCase(tableName); + for (const index of indexes) { + const sourceName = index.sourceName = `${accName}_${(index.algorithm.tag === "Direct" ? [index.algorithm.value] : index.algorithm.value).map((i) => colNameList[i]).join("_")}_idx_${index.algorithm.tag.toLowerCase()}`; + const { canonicalName } = index; + if (canonicalName !== void 0) ctx.moduleDef.explicitNames.entries.push(ExplicitNameEntry.Index({ + sourceName, + canonicalName + })); + } + return { + sourceName: accName, + productTypeRef: ctx.registerTypesRecursively(row).ref, + primaryKey: pk, + indexes, + constraints, + sequences, + tableType: { tag: "User" }, + tableAccess: { tag: isPublic ? "Public" : "Private" }, + defaultValues, + isEvent + }; + }, + idxs: userIndexes, + constraints, + schedule: scheduled && scheduleAtCol !== void 0 ? { + scheduleAtCol, + reducer: scheduled + } : void 0 + }; +} +var QueryBrand = Symbol("QueryBrand"); +var isRowTypedQuery = (val) => !!val && typeof val === "object" && QueryBrand in val; +function toSql(q) { + return q.toSql(); +} +var SemijoinImpl = class _SemijoinImpl { + constructor(sourceQuery, filterQuery, joinCondition) { + this.sourceQuery = sourceQuery; + this.filterQuery = filterQuery; + this.joinCondition = joinCondition; + if (sourceQuery.table.sourceName === filterQuery.table.sourceName) throw new Error("Cannot semijoin a table to itself"); + } + [QueryBrand] = true; + type = "semijoin"; + build() { + return this; + } + where(predicate) { + return new _SemijoinImpl(this.sourceQuery.where(predicate), this.filterQuery, this.joinCondition); + } + toSql() { + const left = this.filterQuery; + const right = this.sourceQuery; + const leftTable = quoteIdentifier(left.table.sourceName); + const rightTable = quoteIdentifier(right.table.sourceName); + let sql = `SELECT ${rightTable}.* FROM ${leftTable} JOIN ${rightTable} ON ${booleanExprToSql(this.joinCondition)}`; + const clauses = []; + if (left.whereClause) clauses.push(booleanExprToSql(left.whereClause)); + if (right.whereClause) clauses.push(booleanExprToSql(right.whereClause)); + if (clauses.length > 0) { + const whereSql = clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(" AND "); + sql += ` WHERE ${whereSql}`; + } + return sql; + } +}; +var FromBuilder = class _FromBuilder { + constructor(table2, whereClause) { + this.table = table2; + this.whereClause = whereClause; + } + [QueryBrand] = true; + where(predicate) { + const newCondition = normalizePredicateExpr(predicate(this.table.cols)); + const nextWhere = this.whereClause ? this.whereClause.and(newCondition) : newCondition; + return new _FromBuilder(this.table, nextWhere); + } + rightSemijoin(right, on) { + const sourceQuery = new _FromBuilder(right); + const joinCondition = on(this.table.indexedCols, right.indexedCols); + return new SemijoinImpl(sourceQuery, this, joinCondition); + } + leftSemijoin(right, on) { + const filterQuery = new _FromBuilder(right); + const joinCondition = on(this.table.indexedCols, right.indexedCols); + return new SemijoinImpl(this, filterQuery, joinCondition); + } + toSql() { + return renderSelectSqlWithJoins(this.table, this.whereClause); + } + build() { + return this; + } +}; +var TableRefImpl = class { + [QueryBrand] = true; + type = "table"; + sourceName; + accessorName; + cols; + indexedCols; + tableDef; + get columns() { + return this.tableDef.columns; + } + get indexes() { + return this.tableDef.indexes; + } + get rowType() { + return this.tableDef.rowType; + } + get constraints() { + return this.tableDef.constraints; + } + constructor(tableDef) { + this.sourceName = tableDef.sourceName; + this.accessorName = tableDef.accessorName; + this.cols = createRowExpr(tableDef); + this.indexedCols = this.cols; + this.tableDef = tableDef; + Object.freeze(this); + } + asFrom() { + return new FromBuilder(this); + } + rightSemijoin(other, on) { + return this.asFrom().rightSemijoin(other, on); + } + leftSemijoin(other, on) { + return this.asFrom().leftSemijoin(other, on); + } + build() { + return this.asFrom().build(); + } + toSql() { + return this.asFrom().toSql(); + } + where(predicate) { + return this.asFrom().where(predicate); + } +}; +function createTableRefFromDef(tableDef) { + return new TableRefImpl(tableDef); +} +function makeQueryBuilder(schema2) { + const qb = /* @__PURE__ */ Object.create(null); + for (const table2 of Object.values(schema2.tables)) { + const ref = createTableRefFromDef(table2); + qb[table2.accessorName] = ref; + } + return Object.freeze(qb); +} +function createRowExpr(tableDef) { + const row = {}; + for (const columnName of Object.keys(tableDef.columns)) { + const columnBuilder = tableDef.columns[columnName]; + const column = new ColumnExpression(tableDef.sourceName, columnName, columnBuilder.typeBuilder.algebraicType, columnBuilder.columnMetadata.name); + row[columnName] = Object.freeze(column); + } + return Object.freeze(row); +} +function renderSelectSqlWithJoins(table2, where, extraClauses = []) { + const sql = `SELECT * FROM ${quoteIdentifier(table2.sourceName)}`; + const clauses = []; + if (where) clauses.push(booleanExprToSql(where)); + clauses.push(...extraClauses); + if (clauses.length === 0) return sql; + return `${sql} WHERE ${clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(" AND ")}`; +} +var ColumnExpression = class { + type = "column"; + column; + columnName; + table; + tsValueType; + spacetimeType; + constructor(table2, column, spacetimeType, columnName) { + this.table = table2; + this.column = column; + this.columnName = columnName || column; + this.spacetimeType = spacetimeType; + } + eq(x) { + return new BooleanExpr({ + type: "eq", + left: this, + right: normalizeValue(x) + }); + } + ne(x) { + return new BooleanExpr({ + type: "ne", + left: this, + right: normalizeValue(x) + }); + } + lt(x) { + return new BooleanExpr({ + type: "lt", + left: this, + right: normalizeValue(x) + }); + } + lte(x) { + return new BooleanExpr({ + type: "lte", + left: this, + right: normalizeValue(x) + }); + } + gt(x) { + return new BooleanExpr({ + type: "gt", + left: this, + right: normalizeValue(x) + }); + } + gte(x) { + return new BooleanExpr({ + type: "gte", + left: this, + right: normalizeValue(x) + }); + } +}; +function literal(value) { + return { + type: "literal", + value + }; +} +function normalizeValue(val) { + if (val.type === "literal") return val; + if (typeof val === "object" && val != null && "type" in val && val.type === "column") return val; + return literal(val); +} +function normalizePredicateExpr(value) { + if (value instanceof BooleanExpr) return value; + if (typeof value === "boolean") return new BooleanExpr({ + type: "eq", + left: literal(value), + right: literal(true) + }); + return new BooleanExpr({ + type: "eq", + left: value, + right: literal(true) + }); +} +var BooleanExpr = class _BooleanExpr { + constructor(data) { + this.data = data; + } + and(other) { + return new _BooleanExpr({ + type: "and", + clauses: [this.data, other.data] + }); + } + or(other) { + return new _BooleanExpr({ + type: "or", + clauses: [this.data, other.data] + }); + } + not() { + return new _BooleanExpr({ + type: "not", + clause: this.data + }); + } +}; +function booleanExprToSql(expr, tableAlias) { + const data = expr instanceof BooleanExpr ? expr.data : expr; + switch (data.type) { + case "eq": return `${valueExprToSql(data.left)} = ${valueExprToSql(data.right)}`; + case "ne": return `${valueExprToSql(data.left)} <> ${valueExprToSql(data.right)}`; + case "gt": return `${valueExprToSql(data.left)} > ${valueExprToSql(data.right)}`; + case "gte": return `${valueExprToSql(data.left)} >= ${valueExprToSql(data.right)}`; + case "lt": return `${valueExprToSql(data.left)} < ${valueExprToSql(data.right)}`; + case "lte": return `${valueExprToSql(data.left)} <= ${valueExprToSql(data.right)}`; + case "and": return data.clauses.map((c) => booleanExprToSql(c)).map(wrapInParens).join(" AND "); + case "or": return data.clauses.map((c) => booleanExprToSql(c)).map(wrapInParens).join(" OR "); + case "not": return `NOT ${wrapInParens(booleanExprToSql(data.clause))}`; + } +} +function wrapInParens(sql) { + return `(${sql})`; +} +function valueExprToSql(expr, tableAlias) { + if (isLiteralExpr(expr)) return literalValueToSql(expr.value); + const table2 = expr.table; + return `${quoteIdentifier(table2)}.${quoteIdentifier(expr.columnName)}`; +} +function literalValueToSql(value) { + if (value === null || value === void 0) return "NULL"; + if (value instanceof Identity || value instanceof ConnectionId) return `0x${value.toHexString()}`; + if (value instanceof Timestamp) return `'${value.toISOString()}'`; + switch (typeof value) { + case "number": + case "bigint": return String(value); + case "boolean": return value ? "TRUE" : "FALSE"; + case "string": return `'${value.replace(/'/g, "''")}'`; + default: return `'${JSON.stringify(value).replace(/'/g, "''")}'`; + } +} +function quoteIdentifier(name) { + return `"${name.replace(/"/g, "\"\"")}"`; +} +function isLiteralExpr(expr) { + return expr.type === "literal"; +} +function makeViewExport(ctx, opts, params, ret, fn) { + const viewExport = fn.bind(); + viewExport[exportContext] = ctx; + viewExport[registerExport] = (ctx2, exportName) => { + registerView(ctx2, opts, exportName, false, params, ret, fn); + }; + return viewExport; +} +function makeAnonViewExport(ctx, opts, params, ret, fn) { + const viewExport = fn.bind(); + viewExport[exportContext] = ctx; + viewExport[registerExport] = (ctx2, exportName) => { + registerView(ctx2, opts, exportName, true, params, ret, fn); + }; + return viewExport; +} +function registerView(ctx, opts, exportName, anon, params, ret, fn) { + const paramsBuilder = new RowBuilder(params, toPascalCase(exportName)); + let returnType = ctx.registerTypesRecursively(ret).algebraicType; + const { typespace } = ctx; + const { value: paramType } = ctx.resolveType(ctx.registerTypesRecursively(paramsBuilder)); + ctx.moduleDef.views.push({ + sourceName: exportName, + index: (anon ? ctx.anonViews : ctx.views).length, + isPublic: opts.public, + isAnonymous: anon, + params: paramType, + returnType + }); + if (opts.name != null) ctx.moduleDef.explicitNames.entries.push({ + tag: "Function", + value: { + sourceName: exportName, + canonicalName: opts.name + } + }); + if (returnType.tag == "Sum") { + const originalFn = fn; + fn = ((ctx2, args) => { + const ret2 = originalFn(ctx2, args); + return ret2 == null ? [] : [ret2]; + }); + returnType = AlgebraicType.Array(returnType.value.variants[0].algebraicType); + } + (anon ? ctx.anonViews : ctx.views).push({ + fn, + deserializeParams: ProductType.makeDeserializer(paramType, typespace), + serializeReturn: AlgebraicType.makeSerializer(returnType, typespace), + returnTypeBaseSize: bsatnBaseSize(typespace, returnType) + }); +} +var SenderError = class extends Error { + constructor(message) { + super(message); + } + get name() { + return "SenderError"; + } +}; +var SpacetimeHostError = class extends Error { + constructor(message) { + super(message); + } + get name() { + return "SpacetimeHostError"; + } +}; +var errorData = { + HostCallFailure: 1, + NotInTransaction: 2, + BsatnDecodeError: 3, + NoSuchTable: 4, + NoSuchIndex: 5, + NoSuchIter: 6, + NoSuchConsoleTimer: 7, + NoSuchBytes: 8, + NoSpace: 9, + BufferTooSmall: 11, + UniqueAlreadyExists: 12, + ScheduleAtDelayTooLong: 13, + IndexNotUnique: 14, + NoSuchRow: 15, + AutoIncOverflow: 16, + WouldBlockTransaction: 17, + TransactionNotAnonymous: 18, + TransactionIsReadOnly: 19, + TransactionIsMut: 20, + HttpError: 21 +}; +function mapEntries(x, f) { + return Object.fromEntries(Object.entries(x).map(([k, v]) => [k, f(k, v)])); +} +var errnoToClass = /* @__PURE__ */ new Map(); +var errors = Object.freeze(mapEntries(errorData, (name, code) => { + const cls = Object.defineProperty(class extends SpacetimeHostError { + get name() { + return name; + } + }, "name", { + value: name, + writable: false + }); + errnoToClass.set(code, cls); + return cls; +})); +function getErrorConstructor(code) { + return errnoToClass.get(code) ?? SpacetimeHostError; +} +var SBigInt = typeof BigInt !== "undefined" ? BigInt : void 0; +var One = typeof BigInt !== "undefined" ? BigInt(1) : void 0; +var ThirtyTwo = typeof BigInt !== "undefined" ? BigInt(32) : void 0; +var NumValues = typeof BigInt !== "undefined" ? BigInt(4294967296) : void 0; +function unsafeUniformBigIntDistribution(from, to, rng) { + var diff = to - from + One; + var FinalNumValues = NumValues; + var NumIterations = 1; + while (FinalNumValues < diff) { + FinalNumValues <<= ThirtyTwo; + ++NumIterations; + } + var value = generateNext(NumIterations, rng); + if (value < diff) return value + from; + if (value + diff < FinalNumValues) return value % diff + from; + var MaxAcceptedRandom = FinalNumValues - FinalNumValues % diff; + while (value >= MaxAcceptedRandom) value = generateNext(NumIterations, rng); + return value % diff + from; +} +function generateNext(NumIterations, rng) { + var value = SBigInt(rng.unsafeNext() + 2147483648); + for (var num = 1; num < NumIterations; ++num) { + var out = rng.unsafeNext(); + value = (value << ThirtyTwo) + SBigInt(out + 2147483648); + } + return value; +} +function unsafeUniformIntDistributionInternal(rangeSize, rng) { + var MaxAllowed = rangeSize > 2 ? ~~(4294967296 / rangeSize) * rangeSize : 4294967296; + var deltaV = rng.unsafeNext() + 2147483648; + while (deltaV >= MaxAllowed) deltaV = rng.unsafeNext() + 2147483648; + return deltaV % rangeSize; +} +function fromNumberToArrayInt64(out, n) { + if (n < 0) { + var posN = -n; + out.sign = -1; + out.data[0] = ~~(posN / 4294967296); + out.data[1] = posN >>> 0; + } else { + out.sign = 1; + out.data[0] = ~~(n / 4294967296); + out.data[1] = n >>> 0; + } + return out; +} +function substractArrayInt64(out, arrayIntA, arrayIntB) { + var lowA = arrayIntA.data[1]; + var highA = arrayIntA.data[0]; + var signA = arrayIntA.sign; + var lowB = arrayIntB.data[1]; + var highB = arrayIntB.data[0]; + var signB = arrayIntB.sign; + out.sign = 1; + if (signA === 1 && signB === -1) { + var low_1 = lowA + lowB; + var high = highA + highB + (low_1 > 4294967295 ? 1 : 0); + out.data[0] = high >>> 0; + out.data[1] = low_1 >>> 0; + return out; + } + var lowFirst = lowA; + var highFirst = highA; + var lowSecond = lowB; + var highSecond = highB; + if (signA === -1) { + lowFirst = lowB; + highFirst = highB; + lowSecond = lowA; + highSecond = highA; + } + var reminderLow = 0; + var low = lowFirst - lowSecond; + if (low < 0) { + reminderLow = 1; + low = low >>> 0; + } + out.data[0] = highFirst - highSecond - reminderLow; + out.data[1] = low; + return out; +} +function unsafeUniformArrayIntDistributionInternal(out, rangeSize, rng) { + var rangeLength = rangeSize.length; + while (true) { + for (var index = 0; index !== rangeLength; ++index) out[index] = unsafeUniformIntDistributionInternal(index === 0 ? rangeSize[0] + 1 : 4294967296, rng); + for (var index = 0; index !== rangeLength; ++index) { + var current = out[index]; + var currentInRange = rangeSize[index]; + if (current < currentInRange) return out; + else if (current > currentInRange) break; + } + } +} +var safeNumberMaxSafeInteger = Number.MAX_SAFE_INTEGER; +var sharedA = { + sign: 1, + data: [0, 0] +}; +var sharedB = { + sign: 1, + data: [0, 0] +}; +var sharedC = { + sign: 1, + data: [0, 0] +}; +var sharedData = [0, 0]; +function uniformLargeIntInternal(from, to, rangeSize, rng) { + var rangeSizeArrayIntValue = rangeSize <= safeNumberMaxSafeInteger ? fromNumberToArrayInt64(sharedC, rangeSize) : substractArrayInt64(sharedC, fromNumberToArrayInt64(sharedA, to), fromNumberToArrayInt64(sharedB, from)); + if (rangeSizeArrayIntValue.data[1] === 4294967295) { + rangeSizeArrayIntValue.data[0] += 1; + rangeSizeArrayIntValue.data[1] = 0; + } else rangeSizeArrayIntValue.data[1] += 1; + unsafeUniformArrayIntDistributionInternal(sharedData, rangeSizeArrayIntValue.data, rng); + return sharedData[0] * 4294967296 + sharedData[1] + from; +} +function unsafeUniformIntDistribution(from, to, rng) { + var rangeSize = to - from; + if (rangeSize <= 4294967295) return unsafeUniformIntDistributionInternal(rangeSize + 1, rng) + from; + return uniformLargeIntInternal(from, to, rangeSize, rng); +} +var XoroShiro128Plus = (function() { + function XoroShiro128Plus2(s01, s00, s11, s10) { + this.s01 = s01; + this.s00 = s00; + this.s11 = s11; + this.s10 = s10; + } + XoroShiro128Plus2.prototype.clone = function() { + return new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10); + }; + XoroShiro128Plus2.prototype.next = function() { + var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10); + return [nextRng.unsafeNext(), nextRng]; + }; + XoroShiro128Plus2.prototype.unsafeNext = function() { + var out = this.s00 + this.s10 | 0; + var a0 = this.s10 ^ this.s00; + var a1 = this.s11 ^ this.s01; + var s00 = this.s00; + var s01 = this.s01; + this.s00 = s00 << 24 ^ s01 >>> 8 ^ a0 ^ a0 << 16; + this.s01 = s01 << 24 ^ s00 >>> 8 ^ a1 ^ (a1 << 16 | a0 >>> 16); + this.s10 = a1 << 5 ^ a0 >>> 27; + this.s11 = a0 << 5 ^ a1 >>> 27; + return out; + }; + XoroShiro128Plus2.prototype.jump = function() { + var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10); + nextRng.unsafeJump(); + return nextRng; + }; + XoroShiro128Plus2.prototype.unsafeJump = function() { + var ns01 = 0; + var ns00 = 0; + var ns11 = 0; + var ns10 = 0; + var jump = [ + 3639956645, + 3750757012, + 1261568508, + 386426335 + ]; + for (var i = 0; i !== 4; ++i) for (var mask = 1; mask; mask <<= 1) { + if (jump[i] & mask) { + ns01 ^= this.s01; + ns00 ^= this.s00; + ns11 ^= this.s11; + ns10 ^= this.s10; + } + this.unsafeNext(); + } + this.s01 = ns01; + this.s00 = ns00; + this.s11 = ns11; + this.s10 = ns10; + }; + XoroShiro128Plus2.prototype.getState = function() { + return [ + this.s01, + this.s00, + this.s11, + this.s10 + ]; + }; + return XoroShiro128Plus2; +})(); +function fromState(state) { + if (!(state.length === 4)) throw new Error("The state must have been produced by a xoroshiro128plus RandomGenerator"); + return new XoroShiro128Plus(state[0], state[1], state[2], state[3]); +} +var xoroshiro128plus = Object.assign(function(seed) { + return new XoroShiro128Plus(-1, ~seed, seed | 0, 0); +}, { fromState }); +var { asUintN } = BigInt; +function pcg32(state) { + state = asUintN(64, state * 6364136223846793005n + 11634580027462260723n); + const xorshifted = Number(asUintN(32, (state >> 18n ^ state) >> 27n)); + const rot = Number(asUintN(32, state >> 59n)); + return xorshifted >> rot | xorshifted << 32 - rot; +} +function generateFloat64(rng) { + const g1 = unsafeUniformIntDistribution(0, (1 << 26) - 1, rng); + const g2 = unsafeUniformIntDistribution(0, (1 << 27) - 1, rng); + return (g1 * Math.pow(2, 27) + g2) * Math.pow(2, -53); +} +function makeRandom(seed) { + const rng = xoroshiro128plus(pcg32(seed.microsSinceUnixEpoch)); + const random = () => generateFloat64(rng); + random.fill = (array) => { + const elem = array.at(0); + if (typeof elem === "bigint") { + const upper = (1n << BigInt(array.BYTES_PER_ELEMENT * 8)) - 1n; + for (let i = 0; i < array.length; i++) array[i] = unsafeUniformBigIntDistribution(0n, upper, rng); + } else if (typeof elem === "number") { + const upper = (1 << array.BYTES_PER_ELEMENT * 8) - 1; + for (let i = 0; i < array.length; i++) array[i] = unsafeUniformIntDistribution(0, upper, rng); + } + return array; + }; + random.uint32 = () => rng.unsafeNext(); + random.integerInRange = (min, max) => unsafeUniformIntDistribution(min, max, rng); + random.bigintInRange = (min, max) => unsafeUniformBigIntDistribution(min, max, rng); + return random; +} +var { freeze } = Object; +var sys = _syscalls2_0; +function parseJsonObject(json) { + let value; + try { + value = JSON.parse(json); + } catch { + throw new Error("Invalid JSON: failed to parse string"); + } + if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error("Expected a JSON object at the top level"); + return value; +} +var JwtClaimsImpl = class { + /** + * Creates a new JwtClaims instance. + * @param rawPayload The JWT payload as a raw JSON string. + * @param identity The identity for this JWT. We are only taking this because we don't have a blake3 implementation (which we need to compute it). + */ + constructor(rawPayload, identity) { + this.rawPayload = rawPayload; + this.fullPayload = parseJsonObject(rawPayload); + this._identity = identity; + } + fullPayload; + _identity; + get identity() { + return this._identity; + } + get subject() { + return this.fullPayload["sub"]; + } + get issuer() { + return this.fullPayload["iss"]; + } + get audience() { + const aud = this.fullPayload["aud"]; + if (aud == null) return []; + return typeof aud === "string" ? [aud] : aud; + } +}; +var AuthCtxImpl = class _AuthCtxImpl { + isInternal; + _jwtSource; + _initializedJWT = false; + _jwtClaims; + _senderIdentity; + constructor(opts) { + this.isInternal = opts.isInternal; + this._jwtSource = opts.jwtSource; + this._senderIdentity = opts.senderIdentity; + } + _initializeJWT() { + if (this._initializedJWT) return; + this._initializedJWT = true; + const token = this._jwtSource(); + if (!token) this._jwtClaims = null; + else this._jwtClaims = new JwtClaimsImpl(token, this._senderIdentity); + Object.freeze(this); + } + /** Lazily compute whether a JWT exists and is parseable. */ + get hasJWT() { + this._initializeJWT(); + return this._jwtClaims !== null; + } + /** Lazily parse the JwtClaims only when accessed. */ + get jwt() { + this._initializeJWT(); + return this._jwtClaims; + } + /** Create a context representing internal (non-user) requests. */ + static internal() { + return new _AuthCtxImpl({ + isInternal: true, + jwtSource: () => null, + senderIdentity: Identity.zero() + }); + } + /** If there is a connection id, look up the JWT payload from the system tables. */ + static fromSystemTables(connectionId, sender) { + if (connectionId === null) return new _AuthCtxImpl({ + isInternal: false, + jwtSource: () => null, + senderIdentity: sender + }); + return new _AuthCtxImpl({ + isInternal: false, + jwtSource: () => { + const payloadBuf = sys.get_jwt_payload(connectionId.__connection_id__); + if (payloadBuf.length === 0) return null; + return new TextDecoder().decode(payloadBuf); + }, + senderIdentity: sender + }); + } +}; +var ReducerCtxImpl = class ReducerCtx { + #identity; + #senderAuth; + #uuidCounter; + #random; + sender; + timestamp; + connectionId; + db; + constructor(sender, timestamp, connectionId, dbView) { + Object.seal(this); + this.sender = sender; + this.timestamp = timestamp; + this.connectionId = connectionId; + this.db = dbView; + } + /** Reset the `ReducerCtx` to be used for a new transaction */ + static reset(me, sender, timestamp, connectionId) { + me.sender = sender; + me.timestamp = timestamp; + me.connectionId = connectionId; + me.#uuidCounter = void 0; + me.#senderAuth = void 0; + } + get identity() { + return this.#identity ??= new Identity(sys.identity()); + } + get senderAuth() { + return this.#senderAuth ??= AuthCtxImpl.fromSystemTables(this.connectionId, this.sender); + } + get random() { + return this.#random ??= makeRandom(this.timestamp); + } + /** + * Create a new random {@link Uuid} `v4` using this `ReducerCtx`'s RNG. + */ + newUuidV4() { + const bytes = this.random.fill(new Uint8Array(16)); + return Uuid.fromRandomBytesV4(bytes); + } + /** + * Create a new sortable {@link Uuid} `v7` using this `ReducerCtx`'s RNG, counter, + * and timestamp. + */ + newUuidV7() { + const bytes = this.random.fill(new Uint8Array(4)); + const counter = this.#uuidCounter ??= { value: 0 }; + return Uuid.fromCounterV7(counter, this.timestamp, bytes); + } +}; +var callUserFunction = function __spacetimedb_end_short_backtrace(fn, ...args) { + return fn(...args); +}; +var makeHooks = (schema2) => new ModuleHooksImpl(schema2); +var ModuleHooksImpl = class { + #schema; + #dbView_; + #reducerArgsDeserializers; + /** Cache the `ReducerCtx` object to avoid allocating anew for ever reducer call. */ + #reducerCtx_; + constructor(schema2) { + this.#schema = schema2; + this.#reducerArgsDeserializers = schema2.moduleDef.reducers.map(({ params }) => ProductType.makeDeserializer(params, schema2.typespace)); + } + get #dbView() { + return this.#dbView_ ??= freeze(Object.fromEntries(Object.values(this.#schema.schemaType.tables).map((table2) => [table2.accessorName, makeTableView(this.#schema.typespace, table2.tableDef)]))); + } + get #reducerCtx() { + return this.#reducerCtx_ ??= new ReducerCtxImpl(Identity.zero(), Timestamp.UNIX_EPOCH, null, this.#dbView); + } + __describe_module__() { + const writer = new BinaryWriter(128); + RawModuleDef.serialize(writer, RawModuleDef.V10(this.#schema.rawModuleDefV10())); + return writer.getBuffer(); + } + __get_error_constructor__(code) { + return getErrorConstructor(code); + } + get __sender_error_class__() { + return SenderError; + } + __call_reducer__(reducerId, sender, connId, timestamp, argsBuf) { + const moduleCtx = this.#schema; + const deserializeArgs = this.#reducerArgsDeserializers[reducerId]; + BINARY_READER.reset(argsBuf); + const args = deserializeArgs(BINARY_READER); + const senderIdentity = new Identity(sender); + const ctx = this.#reducerCtx; + ReducerCtxImpl.reset(ctx, senderIdentity, new Timestamp(timestamp), ConnectionId.nullIfZero(new ConnectionId(connId))); + callUserFunction(moduleCtx.reducers[reducerId], ctx, args); + } + __call_view__(id, sender, argsBuf) { + const moduleCtx = this.#schema; + const { fn, deserializeParams, serializeReturn, returnTypeBaseSize } = moduleCtx.views[id]; + const ret = callUserFunction(fn, freeze({ + sender: new Identity(sender), + db: this.#dbView, + from: makeQueryBuilder(moduleCtx.schemaType) + }), deserializeParams(new BinaryReader(argsBuf))); + const retBuf = new BinaryWriter(returnTypeBaseSize); + if (isRowTypedQuery(ret)) { + const query = toSql(ret); + ViewResultHeader.serialize(retBuf, ViewResultHeader.RawSql(query)); + } else { + ViewResultHeader.serialize(retBuf, ViewResultHeader.RowData); + serializeReturn(retBuf, ret); + } + return { data: retBuf.getBuffer() }; + } + __call_view_anon__(id, argsBuf) { + const moduleCtx = this.#schema; + const { fn, deserializeParams, serializeReturn, returnTypeBaseSize } = moduleCtx.anonViews[id]; + const ret = callUserFunction(fn, freeze({ + db: this.#dbView, + from: makeQueryBuilder(moduleCtx.schemaType) + }), deserializeParams(new BinaryReader(argsBuf))); + const retBuf = new BinaryWriter(returnTypeBaseSize); + if (isRowTypedQuery(ret)) { + const query = toSql(ret); + ViewResultHeader.serialize(retBuf, ViewResultHeader.RawSql(query)); + } else { + ViewResultHeader.serialize(retBuf, ViewResultHeader.RowData); + serializeReturn(retBuf, ret); + } + return { data: retBuf.getBuffer() }; + } + __call_procedure__(id, sender, connection_id, timestamp, args) { + return callProcedure(this.#schema, id, new Identity(sender), ConnectionId.nullIfZero(new ConnectionId(connection_id)), new Timestamp(timestamp), args, () => this.#dbView); + } +}; +var BINARY_WRITER = new BinaryWriter(0); +var BINARY_READER = new BinaryReader(new Uint8Array()); +function makeTableView(typespace, table2) { + const table_id = sys.table_id_from_name(table2.sourceName); + const rowType = typespace.types[table2.productTypeRef]; + if (rowType.tag !== "Product") throw "impossible"; + const serializeRow = AlgebraicType.makeSerializer(rowType, typespace); + const deserializeRow = AlgebraicType.makeDeserializer(rowType, typespace); + const sequences = table2.sequences.map((seq) => { + const col = rowType.value.elements[seq.column]; + const colType = col.algebraicType; + let sequenceTrigger; + switch (colType.tag) { + case "U8": + case "I8": + case "U16": + case "I16": + case "U32": + case "I32": + sequenceTrigger = 0; + break; + case "U64": + case "I64": + case "U128": + case "I128": + case "U256": + case "I256": + sequenceTrigger = 0n; + break; + default: throw new TypeError("invalid sequence type"); + } + return { + colName: col.name, + sequenceTrigger, + deserialize: AlgebraicType.makeDeserializer(colType, typespace) + }; + }); + const hasAutoIncrement = sequences.length > 0; + const iter = () => tableIterator(sys.datastore_table_scan_bsatn(table_id), deserializeRow); + const integrateGeneratedColumns = hasAutoIncrement ? (row, ret_buf) => { + BINARY_READER.reset(ret_buf); + for (const { colName, deserialize, sequenceTrigger } of sequences) if (row[colName] === sequenceTrigger) row[colName] = deserialize(BINARY_READER); + } : null; + const tableMethods = { + count: () => sys.datastore_table_row_count(table_id), + iter, + [Symbol.iterator]: () => iter(), + insert: (row) => { + const buf = LEAF_BUF; + BINARY_WRITER.reset(buf); + serializeRow(BINARY_WRITER, row); + sys.datastore_insert_bsatn(table_id, buf.buffer, BINARY_WRITER.offset); + const ret = { ...row }; + integrateGeneratedColumns?.(ret, buf.view); + return ret; + }, + delete: (row) => { + const buf = LEAF_BUF; + BINARY_WRITER.reset(buf); + BINARY_WRITER.writeU32(1); + serializeRow(BINARY_WRITER, row); + return sys.datastore_delete_all_by_eq_bsatn(table_id, buf.buffer, BINARY_WRITER.offset) > 0; + } + }; + const tableView = Object.assign(/* @__PURE__ */ Object.create(null), tableMethods); + for (const indexDef of table2.indexes) { + const accessorName = indexDef.accessorName; + const index_id = sys.index_id_from_name(indexDef.sourceName); + let column_ids; + let isHashIndex = false; + switch (indexDef.algorithm.tag) { + case "Hash": + isHashIndex = true; + column_ids = indexDef.algorithm.value; + break; + case "BTree": + column_ids = indexDef.algorithm.value; + break; + case "Direct": + column_ids = [indexDef.algorithm.value]; + break; + } + const numColumns = column_ids.length; + const columnSet = new Set(column_ids); + const isUnique = table2.constraints.filter((x) => x.data.tag === "Unique").some((x) => columnSet.isSubsetOf(new Set(x.data.value.columns))); + const isPrimaryKey = isUnique && column_ids.length === table2.primaryKey.length && column_ids.every((id, i) => table2.primaryKey[i] === id); + const indexSerializers = column_ids.map((id) => AlgebraicType.makeSerializer(rowType.value.elements[id].algebraicType, typespace)); + const serializePoint = (buffer, colVal) => { + BINARY_WRITER.reset(buffer); + for (let i = 0; i < numColumns; i++) indexSerializers[i](BINARY_WRITER, colVal[i]); + return BINARY_WRITER.offset; + }; + const serializeSingleElement = numColumns === 1 ? indexSerializers[0] : null; + const serializeSinglePoint = serializeSingleElement && ((buffer, colVal) => { + BINARY_WRITER.reset(buffer); + serializeSingleElement(BINARY_WRITER, colVal); + return BINARY_WRITER.offset; + }); + let index; + if (isUnique && serializeSinglePoint) { + const base = { + find: (colVal) => { + const buf = LEAF_BUF; + const point_len = serializeSinglePoint(buf, colVal); + return tableIterateOne(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow); + }, + delete: (colVal) => { + const buf = LEAF_BUF; + const point_len = serializeSinglePoint(buf, colVal); + return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len) > 0; + } + }; + if (isPrimaryKey) base.update = (row) => { + const buf = LEAF_BUF; + BINARY_WRITER.reset(buf); + serializeRow(BINARY_WRITER, row); + sys.datastore_update_bsatn(table_id, index_id, buf.buffer, BINARY_WRITER.offset); + integrateGeneratedColumns?.(row, buf.view); + return row; + }; + index = base; + } else if (isUnique) { + const base = { + find: (colVal) => { + if (colVal.length !== numColumns) throw new TypeError("wrong number of elements"); + const buf = LEAF_BUF; + const point_len = serializePoint(buf, colVal); + return tableIterateOne(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow); + }, + delete: (colVal) => { + if (colVal.length !== numColumns) throw new TypeError("wrong number of elements"); + const buf = LEAF_BUF; + const point_len = serializePoint(buf, colVal); + return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len) > 0; + } + }; + if (isPrimaryKey) base.update = (row) => { + const buf = LEAF_BUF; + BINARY_WRITER.reset(buf); + serializeRow(BINARY_WRITER, row); + sys.datastore_update_bsatn(table_id, index_id, buf.buffer, BINARY_WRITER.offset); + integrateGeneratedColumns?.(row, buf.view); + return row; + }; + index = base; + } else if (serializeSinglePoint) { + const rawIndex = { + filter: (range) => { + const buf = LEAF_BUF; + const point_len = serializeSinglePoint(buf, range); + return tableIterator(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow); + }, + delete: (range) => { + const buf = LEAF_BUF; + const point_len = serializeSinglePoint(buf, range); + return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len); + } + }; + if (isHashIndex) index = rawIndex; + else index = rawIndex; + } else if (isHashIndex) index = { + filter: (range) => { + const buf = LEAF_BUF; + const point_len = serializePoint(buf, range); + return tableIterator(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow); + }, + delete: (range) => { + const buf = LEAF_BUF; + const point_len = serializePoint(buf, range); + return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len); + } + }; + else { + const serializeRange = (buffer, range) => { + if (range.length > numColumns) throw new TypeError("too many elements"); + BINARY_WRITER.reset(buffer); + const writer = BINARY_WRITER; + const prefix_elems = range.length - 1; + for (let i = 0; i < prefix_elems; i++) indexSerializers[i](writer, range[i]); + const rstartOffset = writer.offset; + const term = range[range.length - 1]; + const serializeTerm = indexSerializers[range.length - 1]; + if (term instanceof Range) { + const writeBound = (bound) => { + writer.writeU8({ + included: 0, + excluded: 1, + unbounded: 2 + }[bound.tag]); + if (bound.tag !== "unbounded") serializeTerm(writer, bound.value); + }; + writeBound(term.from); + const rstartLen = writer.offset - rstartOffset; + writeBound(term.to); + return [ + rstartOffset, + prefix_elems, + rstartLen, + writer.offset - rstartLen + ]; + } else { + writer.writeU8(0); + serializeTerm(writer, term); + return [ + rstartOffset, + prefix_elems, + writer.offset, + 0 + ]; + } + }; + index = { + filter: (range) => { + if (range.length === numColumns) { + const buf = LEAF_BUF; + const point_len = serializePoint(buf, range); + return tableIterator(sys.datastore_index_scan_point_bsatn(index_id, buf.buffer, point_len), deserializeRow); + } else { + const buf = LEAF_BUF; + const args = serializeRange(buf, range); + return tableIterator(sys.datastore_index_scan_range_bsatn(index_id, buf.buffer, ...args), deserializeRow); + } + }, + delete: (range) => { + if (range.length === numColumns) { + const buf = LEAF_BUF; + const point_len = serializePoint(buf, range); + return sys.datastore_delete_by_index_scan_point_bsatn(index_id, buf.buffer, point_len); + } else { + const buf = LEAF_BUF; + const args = serializeRange(buf, range); + return sys.datastore_delete_by_index_scan_range_bsatn(index_id, buf.buffer, ...args); + } + } + }; + } + if (Object.hasOwn(tableView, accessorName)) freeze(Object.assign(tableView[accessorName], index)); + else tableView[accessorName] = freeze(index); + } + return freeze(tableView); +} +function* tableIterator(id, deserialize) { + using iter = new IteratorHandle(id); + const iterBuf = takeBuf(); + try { + let amt; + while (amt = iter.advance(iterBuf)) { + const reader = new BinaryReader(iterBuf.view); + while (reader.offset < amt) yield deserialize(reader); + } + } finally { + returnBuf(iterBuf); + } +} +function tableIterateOne(id, deserialize) { + const buf = LEAF_BUF; + if (advanceIterRaw(id, buf) !== 0) { + BINARY_READER.reset(buf.view); + return deserialize(BINARY_READER); + } + return null; +} +function advanceIterRaw(id, buf) { + while (true) try { + return 0 | sys.row_iter_bsatn_advance(id, buf.buffer); + } catch (e) { + if (e && typeof e === "object" && hasOwn(e, "__buffer_too_small__")) { + buf.grow(e.__buffer_too_small__); + continue; + } + throw e; + } +} +var DEFAULT_BUFFER_CAPACITY = 32 * 1024 * 2; +var ITER_BUFS = [new ResizableBuffer(DEFAULT_BUFFER_CAPACITY)]; +var ITER_BUF_COUNT = 1; +function takeBuf() { + return ITER_BUF_COUNT ? ITER_BUFS[--ITER_BUF_COUNT] : new ResizableBuffer(DEFAULT_BUFFER_CAPACITY); +} +function returnBuf(buf) { + ITER_BUFS[ITER_BUF_COUNT++] = buf; +} +var LEAF_BUF = new ResizableBuffer(DEFAULT_BUFFER_CAPACITY); +var IteratorHandle = class _IteratorHandle { + #id; + static #finalizationRegistry = new FinalizationRegistry(sys.row_iter_bsatn_close); + constructor(id) { + this.#id = id; + _IteratorHandle.#finalizationRegistry.register(this, id, this); + } + /** Unregister this object with the finalization registry and return the id */ + #detach() { + const id = this.#id; + this.#id = -1; + _IteratorHandle.#finalizationRegistry.unregister(this); + return id; + } + /** Call `row_iter_bsatn_advance`, returning 0 if this iterator has been exhausted. */ + advance(buf) { + if (this.#id === -1) return 0; + const ret = advanceIterRaw(this.#id, buf); + if (ret <= 0) this.#detach(); + return ret < 0 ? -ret : ret; + } + [Symbol.dispose]() { + if (this.#id >= 0) { + const id = this.#detach(); + sys.row_iter_bsatn_close(id); + } + } +}; +var { freeze: freeze2 } = Object; +var textEncoder = new TextEncoder(); +var textDecoder = new TextDecoder("utf-8"); +var makeResponse = Symbol("makeResponse"); +var SyncResponse = class _SyncResponse { + #body; + #inner; + constructor(body, init) { + if (body == null) this.#body = null; + else if (typeof body === "string") this.#body = body; + else this.#body = new Uint8Array(body).buffer; + this.#inner = { + headers: new Headers(init?.headers), + status: init?.status ?? 200, + statusText: init?.statusText ?? "", + type: "default", + url: null, + aborted: false + }; + } + static [makeResponse](body, inner) { + const me = new _SyncResponse(body); + me.#inner = inner; + return me; + } + get headers() { + return this.#inner.headers; + } + get status() { + return this.#inner.status; + } + get statusText() { + return this.#inner.statusText; + } + get ok() { + return 200 <= this.#inner.status && this.#inner.status <= 299; + } + get url() { + return this.#inner.url ?? ""; + } + get type() { + return this.#inner.type; + } + arrayBuffer() { + return this.bytes().buffer; + } + bytes() { + if (this.#body == null) return new Uint8Array(); + else if (typeof this.#body === "string") return textEncoder.encode(this.#body); + else return new Uint8Array(this.#body); + } + json() { + return JSON.parse(this.text()); + } + text() { + if (this.#body == null) return ""; + else if (typeof this.#body === "string") return this.#body; + else return textDecoder.decode(this.#body); + } +}; +var requestBaseSize = bsatnBaseSize({ types: [] }, HttpRequest.algebraicType); +var methods = /* @__PURE__ */ new Map([ + ["GET", { tag: "Get" }], + ["HEAD", { tag: "Head" }], + ["POST", { tag: "Post" }], + ["PUT", { tag: "Put" }], + ["DELETE", { tag: "Delete" }], + ["CONNECT", { tag: "Connect" }], + ["OPTIONS", { tag: "Options" }], + ["TRACE", { tag: "Trace" }], + ["PATCH", { tag: "Patch" }] +]); +function fetch(url, init = {}) { + const method = methods.get(init.method?.toUpperCase() ?? "GET") ?? { + tag: "Extension", + value: init.method + }; + const headers = { entries: headersToList(new Headers(init.headers)).flatMap(([k, v]) => Array.isArray(v) ? v.map((v2) => [k, v2]) : [[k, v]]).map(([name, value]) => ({ + name, + value: textEncoder.encode(value) + })) }; + const uri = "" + url; + const request = freeze2({ + method, + headers, + timeout: init.timeout, + uri, + version: { tag: "Http11" } + }); + const requestBuf = new BinaryWriter(requestBaseSize); + HttpRequest.serialize(requestBuf, request); + const body = init.body == null ? new Uint8Array() : typeof init.body === "string" ? init.body : new Uint8Array(init.body); + const [responseBuf, responseBody] = sys.procedure_http_request(requestBuf.getBuffer(), body); + const response = HttpResponse.deserialize(new BinaryReader(responseBuf)); + return SyncResponse[makeResponse](responseBody, { + type: "basic", + url: uri, + status: response.code, + statusText: (0, import_statuses.default)(response.code), + headers: new Headers(), + aborted: false + }); +} +freeze2(fetch); +var httpClient = freeze2({ fetch }); +function makeProcedureExport(ctx, opts, params, ret, fn) { + const name = opts?.name; + const procedureExport = (...args) => fn(...args); + procedureExport[exportContext] = ctx; + procedureExport[registerExport] = (ctx2, exportName) => { + registerProcedure(ctx2, name ?? exportName, params, ret, fn); + ctx2.functionExports.set(procedureExport, name ?? exportName); + }; + return procedureExport; +} +var TransactionCtxImpl = class TransactionCtx extends ReducerCtxImpl {}; +function registerProcedure(ctx, exportName, params, ret, fn, opts) { + ctx.defineFunction(exportName); + const paramsType = { elements: Object.entries(params).map(([n, c]) => ({ + name: n, + algebraicType: ctx.registerTypesRecursively("typeBuilder" in c ? c.typeBuilder : c).algebraicType + })) }; + const returnType = ctx.registerTypesRecursively(ret).algebraicType; + ctx.moduleDef.procedures.push({ + sourceName: exportName, + params: paramsType, + returnType, + visibility: FunctionVisibility.ClientCallable + }); + const { typespace } = ctx; + ctx.procedures.push({ + fn, + deserializeArgs: ProductType.makeDeserializer(paramsType, typespace), + serializeReturn: AlgebraicType.makeSerializer(returnType, typespace), + returnTypeBaseSize: bsatnBaseSize(typespace, returnType) + }); +} +function callProcedure(moduleCtx, id, sender, connectionId, timestamp, argsBuf, dbView) { + const { fn, deserializeArgs, serializeReturn, returnTypeBaseSize } = moduleCtx.procedures[id]; + const args = deserializeArgs(new BinaryReader(argsBuf)); + const ret = callUserFunction(fn, new ProcedureCtxImpl(sender, timestamp, connectionId, dbView), args); + const retBuf = new BinaryWriter(returnTypeBaseSize); + serializeReturn(retBuf, ret); + return retBuf.getBuffer(); +} +var ProcedureCtxImpl = class ProcedureCtx { + constructor(sender, timestamp, connectionId, dbView) { + this.sender = sender; + this.timestamp = timestamp; + this.connectionId = connectionId; + this.#dbView = dbView; + } + #identity; + #uuidCounter; + #random; + #dbView; + get identity() { + return this.#identity ??= new Identity(sys.identity()); + } + get random() { + return this.#random ??= makeRandom(this.timestamp); + } + get http() { + return httpClient; + } + withTx(body) { + const run = () => { + const timestamp = sys.procedure_start_mut_tx(); + try { + return body(new TransactionCtxImpl(this.sender, new Timestamp(timestamp), this.connectionId, this.#dbView())); + } catch (e) { + sys.procedure_abort_mut_tx(); + throw e; + } + }; + let res = run(); + try { + sys.procedure_commit_mut_tx(); + return res; + } catch {} + console.warn("committing anonymous transaction failed"); + res = run(); + try { + sys.procedure_commit_mut_tx(); + return res; + } catch (e) { + throw new Error("transaction retry failed again", { cause: e }); + } + } + newUuidV4() { + const bytes = this.random.fill(new Uint8Array(16)); + return Uuid.fromRandomBytesV4(bytes); + } + newUuidV7() { + const bytes = this.random.fill(new Uint8Array(4)); + const counter = this.#uuidCounter ??= { value: 0 }; + return Uuid.fromCounterV7(counter, this.timestamp, bytes); + } +}; +function makeReducerExport(ctx, opts, params, fn, lifecycle) { + const reducerExport = (...args) => fn(...args); + reducerExport[exportContext] = ctx; + reducerExport[registerExport] = (ctx2, exportName) => { + registerReducer(ctx2, exportName, params, fn, opts, lifecycle); + ctx2.functionExports.set(reducerExport, exportName); + }; + return reducerExport; +} +function registerReducer(ctx, exportName, params, fn, opts, lifecycle) { + ctx.defineFunction(exportName); + if (!(params instanceof RowBuilder)) params = new RowBuilder(params); + if (params.typeName === void 0) params.typeName = toPascalCase(exportName); + const ref = ctx.registerTypesRecursively(params); + const paramsType = ctx.resolveType(ref).value; + const isLifecycle = lifecycle != null; + ctx.moduleDef.reducers.push({ + sourceName: exportName, + params: paramsType, + visibility: FunctionVisibility.ClientCallable, + okReturnType: AlgebraicType.Product({ elements: [] }), + errReturnType: AlgebraicType.String + }); + if (opts?.name != null) ctx.moduleDef.explicitNames.entries.push({ + tag: "Function", + value: { + sourceName: exportName, + canonicalName: opts.name + } + }); + if (isLifecycle) ctx.moduleDef.lifeCycleReducers.push({ + lifecycleSpec: lifecycle, + functionName: exportName + }); + if (!fn.name) Object.defineProperty(fn, "name", { + value: exportName, + writable: false + }); + ctx.reducers.push(fn); +} +var SchemaInner = class extends ModuleContext { + schemaType; + existingFunctions = /* @__PURE__ */ new Set(); + reducers = []; + procedures = []; + views = []; + anonViews = []; + /** + * Maps ReducerExport objects to the name of the reducer. + * Used for resolving the reducers of scheduled tables. + */ + functionExports = /* @__PURE__ */ new Map(); + pendingSchedules = []; + constructor(getSchemaType) { + super(); + this.schemaType = getSchemaType(this); + } + defineFunction(name) { + if (this.existingFunctions.has(name)) throw new TypeError(`There is already a reducer or procedure with the name '${name}'`); + this.existingFunctions.add(name); + } + resolveSchedules() { + for (const { reducer, scheduleAtCol, tableName } of this.pendingSchedules) { + const functionName = this.functionExports.get(reducer()); + if (functionName === void 0) { + const msg = `Table ${tableName} defines a schedule, but it seems like the associated function was not exported.`; + throw new TypeError(msg); + } + this.moduleDef.schedules.push({ + sourceName: void 0, + tableName, + scheduleAtCol, + functionName + }); + } + } +}; +var Schema = class { + #ctx; + constructor(ctx) { + this.#ctx = ctx; + } + [moduleHooks](exports) { + const registeredSchema = this.#ctx; + for (const [name, moduleExport] of Object.entries(exports)) { + if (name === "default") continue; + if (!isModuleExport(moduleExport)) throw new TypeError("exporting something that is not a spacetime export"); + checkExportContext(moduleExport, registeredSchema); + moduleExport[registerExport](registeredSchema, name); + } + registeredSchema.resolveSchedules(); + return makeHooks(registeredSchema); + } + get schemaType() { + return this.#ctx.schemaType; + } + get moduleDef() { + return this.#ctx.moduleDef; + } + get typespace() { + return this.#ctx.typespace; + } + reducer(...args) { + let opts, params = {}, fn; + switch (args.length) { + case 1: + [fn] = args; + break; + case 2: { + let arg1; + [arg1, fn] = args; + if (typeof arg1.name === "string") opts = arg1; + else params = arg1; + break; + } + case 3: + [opts, params, fn] = args; + break; + } + return makeReducerExport(this.#ctx, opts, params, fn); + } + init(...args) { + let opts, fn; + switch (args.length) { + case 1: + [fn] = args; + break; + case 2: + [opts, fn] = args; + break; + } + return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.Init); + } + clientConnected(...args) { + let opts, fn; + switch (args.length) { + case 1: + [fn] = args; + break; + case 2: + [opts, fn] = args; + break; + } + return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.OnConnect); + } + clientDisconnected(...args) { + let opts, fn; + switch (args.length) { + case 1: + [fn] = args; + break; + case 2: + [opts, fn] = args; + break; + } + return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.OnDisconnect); + } + view(opts, ret, fn) { + return makeViewExport(this.#ctx, opts, {}, ret, fn); + } + anonymousView(opts, ret, fn) { + return makeAnonViewExport(this.#ctx, opts, {}, ret, fn); + } + procedure(...args) { + let opts, params = {}, ret, fn; + switch (args.length) { + case 2: + [ret, fn] = args; + break; + case 3: { + let arg1; + [arg1, ret, fn] = args; + if (typeof arg1.name === "string") opts = arg1; + else params = arg1; + break; + } + case 4: + [opts, params, ret, fn] = args; + break; + } + return makeProcedureExport(this.#ctx, opts, params, ret, fn); + } + /** + * Bundle multiple reducers, procedures, etc into one value to export. + * The name they will be exported with is their corresponding key in the `exports` argument. + */ + exportGroup(exports) { + return { + [exportContext]: this.#ctx, + [registerExport](ctx, _exportName) { + for (const [exportName, moduleExport] of Object.entries(exports)) { + checkExportContext(moduleExport, ctx); + moduleExport[registerExport](ctx, exportName); + } + } + }; + } + clientVisibilityFilter = { sql: (filter) => ({ + [exportContext]: this.#ctx, + [registerExport](ctx, _exportName) { + ctx.moduleDef.rowLevelSecurity.push({ sql: filter }); + } + }) }; +}; +var registerExport = Symbol("SpacetimeDB.registerExport"); +var exportContext = Symbol("SpacetimeDB.exportContext"); +function isModuleExport(x) { + return (typeof x === "function" || typeof x === "object") && x !== null && registerExport in x; +} +function checkExportContext(exp, schema2) { + if (exp[exportContext] != null && exp[exportContext] !== schema2) throw new TypeError("multiple schemas are not supported"); +} +function schema(tables, moduleSettings) { + return new Schema(new SchemaInner((ctx2) => { + if (moduleSettings?.CASE_CONVERSION_POLICY != null) ctx2.setCaseConversionPolicy(moduleSettings.CASE_CONVERSION_POLICY); + const tableSchemas = {}; + for (const [accName, table2] of Object.entries(tables)) { + const tableDef = table2.tableDef(ctx2, accName); + tableSchemas[accName] = tableToSchema(accName, table2, tableDef); + ctx2.moduleDef.tables.push(tableDef); + if (table2.schedule) ctx2.pendingSchedules.push({ + ...table2.schedule, + tableName: tableDef.sourceName + }); + if (table2.tableName) ctx2.moduleDef.explicitNames.entries.push({ + tag: "Table", + value: { + sourceName: accName, + canonicalName: table2.tableName + } + }); + } + return { tables: tableSchemas }; + })); +} +var import_object_inspect = __toESM(require_object_inspect()); +var fmtLog = (...data) => data.map((x) => typeof x === "string" ? x : (0, import_object_inspect.default)(x)).join(" "); +var console_level_error = 0; +var console_level_warn = 1; +var console_level_info = 2; +var console_level_debug = 3; +var console_level_trace = 4; +var timerMap = /* @__PURE__ */ new Map(); +var console2 = { + __proto__: {}, + [Symbol.toStringTag]: "console", + assert: (condition = false, ...data) => { + if (!condition) sys.console_log(console_level_error, fmtLog(...data)); + }, + clear: () => {}, + debug: (...data) => { + sys.console_log(console_level_debug, fmtLog(...data)); + }, + error: (...data) => { + sys.console_log(console_level_error, fmtLog(...data)); + }, + info: (...data) => { + sys.console_log(console_level_info, fmtLog(...data)); + }, + log: (...data) => { + sys.console_log(console_level_info, fmtLog(...data)); + }, + table: (tabularData, _properties) => { + sys.console_log(console_level_info, fmtLog(tabularData)); + }, + trace: (...data) => { + sys.console_log(console_level_trace, fmtLog(...data)); + }, + warn: (...data) => { + sys.console_log(console_level_warn, fmtLog(...data)); + }, + dir: (_item, _options) => {}, + dirxml: (..._data) => {}, + count: (_label = "default") => {}, + countReset: (_label = "default") => {}, + group: (..._data) => {}, + groupCollapsed: (..._data) => {}, + groupEnd: () => {}, + time: (label = "default") => { + if (timerMap.has(label)) { + sys.console_log(console_level_warn, `Timer '${label}' already exists.`); + return; + } + timerMap.set(label, sys.console_timer_start(label)); + }, + timeLog: (label = "default", ...data) => { + sys.console_log(console_level_info, fmtLog(label, ...data)); + }, + timeEnd: (label = "default") => { + const spanId = timerMap.get(label); + if (spanId === void 0) { + sys.console_log(console_level_warn, `Timer '${label}' does not exist.`); + return; + } + sys.console_timer_end(spanId); + timerMap.delete(label); + }, + timeStamp: () => {}, + profile: () => {}, + profileEnd: () => {} +}; +globalThis.console = console2; + +//#endregion +//#region src/index.ts +const channel_kind = t.enum("ChannelKind", { + text: t.unit(), + voice: t.unit() +}); +const spacetimedb = schema({ + user: table({ + name: "user", + public: true + }, { + identity: t.identity().primaryKey(), + name: t.string().optional(), + online: t.bool(), + issuer: t.string().optional(), + subject: t.string().optional(), + username: t.string().optional(), + password: t.string().optional() + }), + server: table({ + name: "server", + public: true + }, { + id: t.u64().primaryKey().autoInc(), + name: t.string(), + owner: t.identity().optional() + }), + channel: table({ + name: "channel", + public: true, + indexes: [{ + accessor: "by_server_id", + algorithm: "btree", + columns: ["server_id"] + }] + }, { + id: t.u64().primaryKey().autoInc(), + server_id: t.u64(), + name: t.string(), + kind: channel_kind + }), + voice_state: table({ + name: "voice_state", + public: true, + indexes: [{ + accessor: "by_channel_id", + algorithm: "btree", + columns: ["channel_id"] + }] + }, { + identity: t.identity().primaryKey(), + channel_id: t.u64() + }), + sdp_offer: table({ + name: "sdp_offer", + public: true, + indexes: [{ + accessor: "by_receiver", + algorithm: "btree", + columns: ["receiver"] + }] + }, { + sender: t.identity(), + receiver: t.identity(), + sdp: t.string(), + channel_id: t.u64() + }), + sdp_answer: table({ + name: "sdp_answer", + public: true, + indexes: [{ + accessor: "by_receiver", + algorithm: "btree", + columns: ["receiver"] + }] + }, { + sender: t.identity(), + receiver: t.identity(), + sdp: t.string(), + channel_id: t.u64() + }), + ice_candidate: table({ + name: "ice_candidate", + public: true, + indexes: [{ + accessor: "by_receiver", + algorithm: "btree", + columns: ["receiver"] + }] + }, { + sender: t.identity(), + receiver: t.identity(), + candidate: t.string(), + channel_id: t.u64() + }), + thread: table({ + name: "thread", + public: true, + indexes: [{ + accessor: "by_channel_id", + algorithm: "btree", + columns: ["channel_id"] + }] + }, { + id: t.u64().primaryKey().autoInc(), + channel_id: t.u64(), + parent_message_id: t.u64().unique(), + name: t.string() + }), + message: table({ + name: "message", + public: true, + indexes: [{ + accessor: "by_channel_id", + algorithm: "btree", + columns: ["channel_id"] + }, { + accessor: "by_thread_id", + algorithm: "btree", + columns: ["thread_id"] + }] + }, { + id: t.u64().primaryKey().autoInc(), + sender: t.identity(), + sent: t.timestamp(), + text: t.string(), + channel_id: t.u64(), + thread_id: t.u64().optional() + }) +}); +function validateName(name) { + if (!name || name.trim().length === 0) throw new SenderError("Names must not be empty"); +} +const set_name = spacetimedb.reducer({ name: t.string() }, (ctx, { name }) => { + validateName(name); + const user = ctx.db.user.identity.find(ctx.sender); + if (!user) throw new SenderError("Cannot set name for unknown user"); + ctx.db.user.identity.update({ + ...user, + name + }); +}); +const register = spacetimedb.reducer({ + username: t.string(), + password: t.string() +}, (ctx, { username, password }) => { + validateName(username); + if (!password || password.length < 4) throw new SenderError("Password must be at least 4 characters"); + for (const u of ctx.db.user.iter()) if (u.username === username) throw new SenderError("Username already taken"); + const user = ctx.db.user.identity.find(ctx.sender); + if (user) ctx.db.user.identity.update({ + ...user, + username, + password, + name: user.name || username + }); + else ctx.db.user.insert({ + identity: ctx.sender, + username, + password, + name: username, + online: true, + issuer: void 0, + subject: void 0 + }); +}); +const login = spacetimedb.reducer({ + username: t.string(), + password: t.string() +}, (ctx, { username, password }) => { + let foundUser = null; + for (const u of ctx.db.user.iter()) if (u.username === username && u.password === password) { + foundUser = u; + break; + } + if (!foundUser) throw new SenderError("Invalid username or password"); + const currentIdentityUser = ctx.db.user.identity.find(ctx.sender); + if (currentIdentityUser && currentIdentityUser.identity.toHexString() !== foundUser.identity.toHexString()) ctx.db.user.identity.delete(ctx.sender); + if (foundUser.identity.toHexString() !== ctx.sender.toHexString()) { + ctx.db.user.identity.delete(foundUser.identity); + ctx.db.user.insert({ + ...foundUser, + identity: ctx.sender, + online: true + }); + } else ctx.db.user.identity.update({ + ...foundUser, + online: true + }); +}); +const create_server = spacetimedb.reducer({ name: t.string() }, (ctx, { name }) => { + validateName(name); + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to create a server"); + const s = ctx.db.server.insert({ + id: 0n, + name, + owner: ctx.sender + }); + ctx.db.channel.insert({ + id: 0n, + server_id: s.id, + name: "general", + kind: { tag: "text" } + }); + ctx.db.channel.insert({ + id: 0n, + server_id: s.id, + name: "Voice General", + kind: { tag: "voice" } + }); +}); +const create_channel = spacetimedb.reducer({ + name: t.string(), + serverId: t.u64(), + isVoice: t.bool() +}, (ctx, { name, serverId, isVoice }) => { + validateName(name); + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to create a channel"); + if (!ctx.db.server.id.find(serverId)) throw new SenderError("Server not found"); + ctx.db.channel.insert({ + id: 0n, + server_id: serverId, + name, + kind: isVoice ? { tag: "voice" } : { tag: "text" } + }); +}); +const join_voice = spacetimedb.reducer({ channelId: t.u64() }, (ctx, { channelId }) => { + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to join voice"); + const chan = ctx.db.channel.id.find(channelId); + if (!chan || chan.kind.tag !== "voice") throw new SenderError("Invalid voice channel"); + const existing = ctx.db.voice_state.identity.find(ctx.sender); + if (existing) { + if (existing.channel_id !== channelId) { + clearSignalingForUser(ctx, ctx.sender); + ctx.db.voice_state.identity.update({ + identity: ctx.sender, + channel_id: channelId + }); + } + } else ctx.db.voice_state.insert({ + identity: ctx.sender, + channel_id: channelId + }); +}); +const leave_voice = spacetimedb.reducer((ctx) => { + ctx.db.voice_state.identity.delete(ctx.sender); + clearSignalingForUser(ctx, ctx.sender); +}); +const send_sdp_offer = spacetimedb.reducer({ + receiver: t.identity(), + sdp: t.string(), + channelId: t.u64() +}, (ctx, { receiver, sdp, channelId }) => { + ctx.db.sdp_offer.insert({ + sender: ctx.sender, + receiver, + sdp, + channel_id: channelId + }); +}); +const send_sdp_answer = spacetimedb.reducer({ + receiver: t.identity(), + sdp: t.string(), + channelId: t.u64() +}, (ctx, { receiver, sdp, channelId }) => { + ctx.db.sdp_answer.insert({ + sender: ctx.sender, + receiver, + sdp, + channel_id: channelId + }); +}); +const send_ice_candidate = spacetimedb.reducer({ + receiver: t.identity(), + candidate: t.string(), + channelId: t.u64() +}, (ctx, { receiver, candidate, channelId }) => { + ctx.db.ice_candidate.insert({ + sender: ctx.sender, + receiver, + candidate, + channel_id: channelId + }); +}); +function clearSignalingForUser(ctx, identity) { + const userOffers = ctx.db.sdp_offer.iter().filter((offer) => offer.sender.isEqual(identity) || offer.receiver.isEqual(identity)); + for (const offer of userOffers) ctx.db.sdp_offer.delete(offer.id); + const userAnswers = ctx.db.sdp_answer.iter().filter((answer) => answer.sender.isEqual(identity) || answer.receiver.isEqual(identity)); + for (const answer of userAnswers) ctx.db.sdp_answer.delete(answer.id); + const userCandidates = ctx.db.ice_candidate.iter().filter((candidate) => candidate.sender.isEqual(identity) || candidate.receiver.isEqual(identity)); + for (const candidate of userCandidates) ctx.db.ice_candidate.delete(candidate.id); +} +const create_thread = spacetimedb.reducer({ + name: t.string(), + channelId: t.u64(), + parentMessageId: t.u64() +}, (ctx, { name, channelId, parentMessageId }) => { + validateName(name); + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to create a thread"); + if (!ctx.db.message.id.find(parentMessageId)) throw new SenderError("Parent message not found"); + ctx.db.thread.insert({ + id: 0n, + channel_id: channelId, + parent_message_id: parentMessageId, + name + }); +}); +const send_message = spacetimedb.reducer({ + text: t.string(), + channelId: t.u64(), + threadId: t.u64().optional() +}, (ctx, { text, channelId, threadId }) => { + if (!text || text.trim().length === 0) throw new SenderError("Messages must not be empty"); + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || !user.username && !user.subject) throw new SenderError("You must be logged in to send messages"); + ctx.db.message.insert({ + id: 0n, + sender: ctx.sender, + text, + sent: ctx.timestamp, + channel_id: channelId, + thread_id: threadId + }); +}); +const init = spacetimedb.init((ctx) => { + let hasServers = false; + for (const _ of ctx.db.server.iter()) { + hasServers = true; + break; + } + if (!hasServers) { + const s = ctx.db.server.insert({ + id: 0n, + name: "Spacetime Community", + owner: void 0 + }); + ctx.db.channel.insert({ + id: 0n, + server_id: s.id, + name: "general", + kind: { tag: "text" } + }); + ctx.db.channel.insert({ + id: 0n, + server_id: s.id, + name: "Voice General", + kind: { tag: "voice" } + }); + } +}); +const onConnect = spacetimedb.clientConnected((ctx) => { + const user = ctx.db.user.identity.find(ctx.sender); + if (ctx.senderAuth.hasJWT && ctx.senderAuth.jwt) { + const jwt = ctx.senderAuth.jwt; + const issuer = jwt.issuer; + const subject = jwt.subject; + const payload = jwt.fullPayload; + const name = payload.name || payload.nickname || payload.preferred_username || payload.email; + if (user) ctx.db.user.identity.update({ + ...user, + online: true, + name: user.name || name, + issuer, + subject + }); + else ctx.db.user.insert({ + name, + identity: ctx.sender, + online: true, + issuer, + subject, + username: void 0, + password: void 0 + }); + } else if (user) ctx.db.user.identity.update({ + ...user, + online: true + }); +}); +const onDisconnect = spacetimedb.clientDisconnected((ctx) => { + const user = ctx.db.user.identity.find(ctx.sender); + if (user) ctx.db.user.identity.update({ + ...user, + online: false + }); + ctx.db.voice_state.identity.delete(ctx.sender); + clearSignalingForUser(ctx, ctx.sender); +}); + +//#endregion +export { create_channel, create_server, create_thread, spacetimedb as default, init, join_voice, leave_voice, login, onConnect, onDisconnect, register, send_ice_candidate, send_message, send_sdp_answer, send_sdp_offer, set_name }; +//# debugId=c9a38ab5-d5c5-4af9-81c8-7086063e3faf +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"bundle.js","names":["__create","__defProp","__getOwnPropDesc","__getOwnPropNames","__getProtoOf","__hasOwnProp","__commonJS","__copyProps","__toESM","#ensure","#moduleDef","#registerCompoundTypeRecursively","#compoundTypes","#from","#to","#uuidCounter","#senderAuth","#identity","#random","#schema","#reducerArgsDeserializers","#dbView","#dbView_","#reducerCtx","#reducerCtx_","#finalizationRegistry","#id","#detach","#body","#inner","#ctx"],"sources":["node_modules/.pnpm/headers-polyfill@4.0.3/node_modules/headers-polyfill/lib/index.mjs","node_modules/.pnpm/spacetimedb@2.1.0/node_modules/spacetimedb/dist/server/index.mjs","src/index.ts"],"sourcesContent":["var __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n  mod\n));\n\n// node_modules/set-cookie-parser/lib/set-cookie.js\nvar require_set_cookie = __commonJS({\n  \"node_modules/set-cookie-parser/lib/set-cookie.js\"(exports, module) {\n    \"use strict\";\n    var defaultParseOptions = {\n      decodeValues: true,\n      map: false,\n      silent: false\n    };\n    function isNonEmptyString(str) {\n      return typeof str === \"string\" && !!str.trim();\n    }\n    function parseString(setCookieValue, options) {\n      var parts = setCookieValue.split(\";\").filter(isNonEmptyString);\n      var nameValuePairStr = parts.shift();\n      var parsed = parseNameValuePair(nameValuePairStr);\n      var name = parsed.name;\n      var value = parsed.value;\n      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;\n      try {\n        value = options.decodeValues ? decodeURIComponent(value) : value;\n      } catch (e) {\n        console.error(\n          \"set-cookie-parser encountered an error while decoding a cookie with value '\" + value + \"'. Set options.decodeValues to false to disable this feature.\",\n          e\n        );\n      }\n      var cookie = {\n        name,\n        value\n      };\n      parts.forEach(function(part) {\n        var sides = part.split(\"=\");\n        var key = sides.shift().trimLeft().toLowerCase();\n        var value2 = sides.join(\"=\");\n        if (key === \"expires\") {\n          cookie.expires = new Date(value2);\n        } else if (key === \"max-age\") {\n          cookie.maxAge = parseInt(value2, 10);\n        } else if (key === \"secure\") {\n          cookie.secure = true;\n        } else if (key === \"httponly\") {\n          cookie.httpOnly = true;\n        } else if (key === \"samesite\") {\n          cookie.sameSite = value2;\n        } else {\n          cookie[key] = value2;\n        }\n      });\n      return cookie;\n    }\n    function parseNameValuePair(nameValuePairStr) {\n      var name = \"\";\n      var value = \"\";\n      var nameValueArr = nameValuePairStr.split(\"=\");\n      if (nameValueArr.length > 1) {\n        name = nameValueArr.shift();\n        value = nameValueArr.join(\"=\");\n      } else {\n        value = nameValuePairStr;\n      }\n      return { name, value };\n    }\n    function parse(input, options) {\n      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;\n      if (!input) {\n        if (!options.map) {\n          return [];\n        } else {\n          return {};\n        }\n      }\n      if (input.headers) {\n        if (typeof input.headers.getSetCookie === \"function\") {\n          input = input.headers.getSetCookie();\n        } else if (input.headers[\"set-cookie\"]) {\n          input = input.headers[\"set-cookie\"];\n        } else {\n          var sch = input.headers[Object.keys(input.headers).find(function(key) {\n            return key.toLowerCase() === \"set-cookie\";\n          })];\n          if (!sch && input.headers.cookie && !options.silent) {\n            console.warn(\n              \"Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning.\"\n            );\n          }\n          input = sch;\n        }\n      }\n      if (!Array.isArray(input)) {\n        input = [input];\n      }\n      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;\n      if (!options.map) {\n        return input.filter(isNonEmptyString).map(function(str) {\n          return parseString(str, options);\n        });\n      } else {\n        var cookies = {};\n        return input.filter(isNonEmptyString).reduce(function(cookies2, str) {\n          var cookie = parseString(str, options);\n          cookies2[cookie.name] = cookie;\n          return cookies2;\n        }, cookies);\n      }\n    }\n    function splitCookiesString2(cookiesString) {\n      if (Array.isArray(cookiesString)) {\n        return cookiesString;\n      }\n      if (typeof cookiesString !== \"string\") {\n        return [];\n      }\n      var cookiesStrings = [];\n      var pos = 0;\n      var start;\n      var ch;\n      var lastComma;\n      var nextStart;\n      var cookiesSeparatorFound;\n      function skipWhitespace() {\n        while (pos < cookiesString.length && /\\s/.test(cookiesString.charAt(pos))) {\n          pos += 1;\n        }\n        return pos < cookiesString.length;\n      }\n      function notSpecialChar() {\n        ch = cookiesString.charAt(pos);\n        return ch !== \"=\" && ch !== \";\" && ch !== \",\";\n      }\n      while (pos < cookiesString.length) {\n        start = pos;\n        cookiesSeparatorFound = false;\n        while (skipWhitespace()) {\n          ch = cookiesString.charAt(pos);\n          if (ch === \",\") {\n            lastComma = pos;\n            pos += 1;\n            skipWhitespace();\n            nextStart = pos;\n            while (pos < cookiesString.length && notSpecialChar()) {\n              pos += 1;\n            }\n            if (pos < cookiesString.length && cookiesString.charAt(pos) === \"=\") {\n              cookiesSeparatorFound = true;\n              pos = nextStart;\n              cookiesStrings.push(cookiesString.substring(start, lastComma));\n              start = pos;\n            } else {\n              pos = lastComma + 1;\n            }\n          } else {\n            pos += 1;\n          }\n        }\n        if (!cookiesSeparatorFound || pos >= cookiesString.length) {\n          cookiesStrings.push(cookiesString.substring(start, cookiesString.length));\n        }\n      }\n      return cookiesStrings;\n    }\n    module.exports = parse;\n    module.exports.parse = parse;\n    module.exports.parseString = parseString;\n    module.exports.splitCookiesString = splitCookiesString2;\n  }\n});\n\n// src/Headers.ts\nvar import_set_cookie_parser = __toESM(require_set_cookie());\n\n// src/utils/normalizeHeaderName.ts\nvar HEADERS_INVALID_CHARACTERS = /[^a-z0-9\\-#$%&'*+.^_`|~]/i;\nfunction normalizeHeaderName(name) {\n  if (HEADERS_INVALID_CHARACTERS.test(name) || name.trim() === \"\") {\n    throw new TypeError(\"Invalid character in header field name\");\n  }\n  return name.trim().toLowerCase();\n}\n\n// src/utils/normalizeHeaderValue.ts\nvar charCodesToRemove = [\n  String.fromCharCode(10),\n  String.fromCharCode(13),\n  String.fromCharCode(9),\n  String.fromCharCode(32)\n];\nvar HEADER_VALUE_REMOVE_REGEXP = new RegExp(\n  `(^[${charCodesToRemove.join(\"\")}]|$[${charCodesToRemove.join(\"\")}])`,\n  \"g\"\n);\nfunction normalizeHeaderValue(value) {\n  const nextValue = value.replace(HEADER_VALUE_REMOVE_REGEXP, \"\");\n  return nextValue;\n}\n\n// src/utils/isValidHeaderName.ts\nfunction isValidHeaderName(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n  if (value.length === 0) {\n    return false;\n  }\n  for (let i = 0; i < value.length; i++) {\n    const character = value.charCodeAt(i);\n    if (character > 127 || !isToken(character)) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction isToken(value) {\n  return ![\n    127,\n    32,\n    \"(\",\n    \")\",\n    \"<\",\n    \">\",\n    \"@\",\n    \",\",\n    \";\",\n    \":\",\n    \"\\\\\",\n    '\"',\n    \"/\",\n    \"[\",\n    \"]\",\n    \"?\",\n    \"=\",\n    \"{\",\n    \"}\"\n  ].includes(value);\n}\n\n// src/utils/isValidHeaderValue.ts\nfunction isValidHeaderValue(value) {\n  if (typeof value !== \"string\") {\n    return false;\n  }\n  if (value.trim() !== value) {\n    return false;\n  }\n  for (let i = 0; i < value.length; i++) {\n    const character = value.charCodeAt(i);\n    if (\n      // NUL.\n      character === 0 || // HTTP newline bytes.\n      character === 10 || character === 13\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// src/Headers.ts\nvar NORMALIZED_HEADERS = Symbol(\"normalizedHeaders\");\nvar RAW_HEADER_NAMES = Symbol(\"rawHeaderNames\");\nvar HEADER_VALUE_DELIMITER = \", \";\nvar _a, _b, _c;\nvar Headers = class _Headers {\n  constructor(init) {\n    // Normalized header {\"name\":\"a, b\"} storage.\n    this[_a] = {};\n    // Keeps the mapping between the raw header name\n    // and the normalized header name to ease the lookup.\n    this[_b] = /* @__PURE__ */ new Map();\n    this[_c] = \"Headers\";\n    if ([\"Headers\", \"HeadersPolyfill\"].includes(init?.constructor.name) || init instanceof _Headers || typeof globalThis.Headers !== \"undefined\" && init instanceof globalThis.Headers) {\n      const initialHeaders = init;\n      initialHeaders.forEach((value, name) => {\n        this.append(name, value);\n      }, this);\n    } else if (Array.isArray(init)) {\n      init.forEach(([name, value]) => {\n        this.append(\n          name,\n          Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value\n        );\n      });\n    } else if (init) {\n      Object.getOwnPropertyNames(init).forEach((name) => {\n        const value = init[name];\n        this.append(\n          name,\n          Array.isArray(value) ? value.join(HEADER_VALUE_DELIMITER) : value\n        );\n      });\n    }\n  }\n  [(_a = NORMALIZED_HEADERS, _b = RAW_HEADER_NAMES, _c = Symbol.toStringTag, Symbol.iterator)]() {\n    return this.entries();\n  }\n  *keys() {\n    for (const [name] of this.entries()) {\n      yield name;\n    }\n  }\n  *values() {\n    for (const [, value] of this.entries()) {\n      yield value;\n    }\n  }\n  *entries() {\n    let sortedKeys = Object.keys(this[NORMALIZED_HEADERS]).sort(\n      (a, b) => a.localeCompare(b)\n    );\n    for (const name of sortedKeys) {\n      if (name === \"set-cookie\") {\n        for (const value of this.getSetCookie()) {\n          yield [name, value];\n        }\n      } else {\n        yield [name, this.get(name)];\n      }\n    }\n  }\n  /**\n   * Returns a boolean stating whether a `Headers` object contains a certain header.\n   */\n  has(name) {\n    if (!isValidHeaderName(name)) {\n      throw new TypeError(`Invalid header name \"${name}\"`);\n    }\n    return this[NORMALIZED_HEADERS].hasOwnProperty(normalizeHeaderName(name));\n  }\n  /**\n   * Returns a `ByteString` sequence of all the values of a header with a given name.\n   */\n  get(name) {\n    if (!isValidHeaderName(name)) {\n      throw TypeError(`Invalid header name \"${name}\"`);\n    }\n    return this[NORMALIZED_HEADERS][normalizeHeaderName(name)] ?? null;\n  }\n  /**\n   * Sets a new value for an existing header inside a `Headers` object, or adds the header if it does not already exist.\n   */\n  set(name, value) {\n    if (!isValidHeaderName(name) || !isValidHeaderValue(value)) {\n      return;\n    }\n    const normalizedName = normalizeHeaderName(name);\n    const normalizedValue = normalizeHeaderValue(value);\n    this[NORMALIZED_HEADERS][normalizedName] = normalizeHeaderValue(normalizedValue);\n    this[RAW_HEADER_NAMES].set(normalizedName, name);\n  }\n  /**\n   * Appends a new value onto an existing header inside a `Headers` object, or adds the header if it does not already exist.\n   */\n  append(name, value) {\n    if (!isValidHeaderName(name) || !isValidHeaderValue(value)) {\n      return;\n    }\n    const normalizedName = normalizeHeaderName(name);\n    const normalizedValue = normalizeHeaderValue(value);\n    let resolvedValue = this.has(normalizedName) ? `${this.get(normalizedName)}, ${normalizedValue}` : normalizedValue;\n    this.set(name, resolvedValue);\n  }\n  /**\n   * Deletes a header from the `Headers` object.\n   */\n  delete(name) {\n    if (!isValidHeaderName(name)) {\n      return;\n    }\n    if (!this.has(name)) {\n      return;\n    }\n    const normalizedName = normalizeHeaderName(name);\n    delete this[NORMALIZED_HEADERS][normalizedName];\n    this[RAW_HEADER_NAMES].delete(normalizedName);\n  }\n  /**\n   * Traverses the `Headers` object,\n   * calling the given callback for each header.\n   */\n  forEach(callback, thisArg) {\n    for (const [name, value] of this.entries()) {\n      callback.call(thisArg, value, name, this);\n    }\n  }\n  /**\n   * Returns an array containing the values\n   * of all Set-Cookie headers associated\n   * with a response\n   */\n  getSetCookie() {\n    const setCookieHeader = this.get(\"set-cookie\");\n    if (setCookieHeader === null) {\n      return [];\n    }\n    if (setCookieHeader === \"\") {\n      return [\"\"];\n    }\n    return (0, import_set_cookie_parser.splitCookiesString)(setCookieHeader);\n  }\n};\n\n// src/getRawHeaders.ts\nfunction getRawHeaders(headers) {\n  const rawHeaders = {};\n  for (const [name, value] of headers.entries()) {\n    rawHeaders[headers[RAW_HEADER_NAMES].get(name)] = value;\n  }\n  return rawHeaders;\n}\n\n// src/transformers/headersToList.ts\nfunction headersToList(headers) {\n  const headersList = [];\n  headers.forEach((value, name) => {\n    const resolvedValue = value.includes(\",\") ? value.split(\",\").map((value2) => value2.trim()) : value;\n    headersList.push([name, resolvedValue]);\n  });\n  return headersList;\n}\n\n// src/transformers/headersToString.ts\nfunction headersToString(headers) {\n  const list = headersToList(headers);\n  const lines = list.map(([name, value]) => {\n    const values = [].concat(value);\n    return `${name}: ${values.join(\", \")}`;\n  });\n  return lines.join(\"\\r\\n\");\n}\n\n// src/transformers/headersToObject.ts\nvar singleValueHeaders = [\"user-agent\"];\nfunction headersToObject(headers) {\n  const headersObject = {};\n  headers.forEach((value, name) => {\n    const isMultiValue = !singleValueHeaders.includes(name.toLowerCase()) && value.includes(\",\");\n    headersObject[name] = isMultiValue ? value.split(\",\").map((s) => s.trim()) : value;\n  });\n  return headersObject;\n}\n\n// src/transformers/stringToHeaders.ts\nfunction stringToHeaders(str) {\n  const lines = str.trim().split(/[\\r\\n]+/);\n  return lines.reduce((headers, line) => {\n    if (line.trim() === \"\") {\n      return headers;\n    }\n    const parts = line.split(\": \");\n    const name = parts.shift();\n    const value = parts.join(\": \");\n    headers.append(name, value);\n    return headers;\n  }, new Headers());\n}\n\n// src/transformers/listToHeaders.ts\nfunction listToHeaders(list) {\n  const headers = new Headers();\n  list.forEach(([name, value]) => {\n    const values = [].concat(value);\n    values.forEach((value2) => {\n      headers.append(name, value2);\n    });\n  });\n  return headers;\n}\n\n// src/transformers/reduceHeadersObject.ts\nfunction reduceHeadersObject(headers, reducer, initialState) {\n  return Object.keys(headers).reduce((nextHeaders, name) => {\n    return reducer(nextHeaders, name, headers[name]);\n  }, initialState);\n}\n\n// src/transformers/objectToHeaders.ts\nfunction objectToHeaders(headersObject) {\n  return reduceHeadersObject(\n    headersObject,\n    (headers, name, value) => {\n      const values = [].concat(value).filter(Boolean);\n      values.forEach((value2) => {\n        headers.append(name, value2);\n      });\n      return headers;\n    },\n    new Headers()\n  );\n}\n\n// src/transformers/flattenHeadersList.ts\nfunction flattenHeadersList(list) {\n  return list.map(([name, values]) => {\n    return [name, [].concat(values).join(\", \")];\n  });\n}\n\n// src/transformers/flattenHeadersObject.ts\nfunction flattenHeadersObject(headersObject) {\n  return reduceHeadersObject(\n    headersObject,\n    (headers, name, value) => {\n      headers[name] = [].concat(value).join(\", \");\n      return headers;\n    },\n    {}\n  );\n}\nexport {\n  Headers,\n  flattenHeadersList,\n  flattenHeadersObject,\n  getRawHeaders,\n  headersToList,\n  headersToObject,\n  headersToString,\n  listToHeaders,\n  objectToHeaders,\n  reduceHeadersObject,\n  stringToHeaders\n};\n//# sourceMappingURL=index.mjs.map","import * as _syscalls2_0 from 'spacetime:sys@2.0';\nimport { moduleHooks } from 'spacetime:sys@2.0';\nimport { headersToList, Headers } from 'headers-polyfill';\n\ntypeof globalThis!==\"undefined\"&&((globalThis.global=globalThis.global||globalThis),(globalThis.window=globalThis.window||globalThis));\nvar __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __esm = (fn, res) => function __init() {\n  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;\n};\nvar __commonJS = (cb, mod) => function __require() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  __defProp(target, \"default\", { value: mod, enumerable: true }) ,\n  mod\n));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js\nvar require_base64_js = __commonJS({\n  \"../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js\"(exports) {\n    exports.byteLength = byteLength;\n    exports.toByteArray = toByteArray;\n    exports.fromByteArray = fromByteArray2;\n    var lookup = [];\n    var revLookup = [];\n    var Arr = typeof Uint8Array !== \"undefined\" ? Uint8Array : Array;\n    var code = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n    for (i = 0, len = code.length; i < len; ++i) {\n      lookup[i] = code[i];\n      revLookup[code.charCodeAt(i)] = i;\n    }\n    var i;\n    var len;\n    revLookup[\"-\".charCodeAt(0)] = 62;\n    revLookup[\"_\".charCodeAt(0)] = 63;\n    function getLens(b64) {\n      var len2 = b64.length;\n      if (len2 % 4 > 0) {\n        throw new Error(\"Invalid string. Length must be a multiple of 4\");\n      }\n      var validLen = b64.indexOf(\"=\");\n      if (validLen === -1) validLen = len2;\n      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;\n      return [validLen, placeHoldersLen];\n    }\n    function byteLength(b64) {\n      var lens = getLens(b64);\n      var validLen = lens[0];\n      var placeHoldersLen = lens[1];\n      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n    }\n    function _byteLength(b64, validLen, placeHoldersLen) {\n      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;\n    }\n    function toByteArray(b64) {\n      var tmp;\n      var lens = getLens(b64);\n      var validLen = lens[0];\n      var placeHoldersLen = lens[1];\n      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));\n      var curByte = 0;\n      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;\n      var i2;\n      for (i2 = 0; i2 < len2; i2 += 4) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];\n        arr[curByte++] = tmp >> 16 & 255;\n        arr[curByte++] = tmp >> 8 & 255;\n        arr[curByte++] = tmp & 255;\n      }\n      if (placeHoldersLen === 2) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;\n        arr[curByte++] = tmp & 255;\n      }\n      if (placeHoldersLen === 1) {\n        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;\n        arr[curByte++] = tmp >> 8 & 255;\n        arr[curByte++] = tmp & 255;\n      }\n      return arr;\n    }\n    function tripletToBase64(num) {\n      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];\n    }\n    function encodeChunk(uint8, start, end) {\n      var tmp;\n      var output = [];\n      for (var i2 = start; i2 < end; i2 += 3) {\n        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);\n        output.push(tripletToBase64(tmp));\n      }\n      return output.join(\"\");\n    }\n    function fromByteArray2(uint8) {\n      var tmp;\n      var len2 = uint8.length;\n      var extraBytes = len2 % 3;\n      var parts = [];\n      var maxChunkLength = 16383;\n      for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {\n        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));\n      }\n      if (extraBytes === 1) {\n        tmp = uint8[len2 - 1];\n        parts.push(\n          lookup[tmp >> 2] + lookup[tmp << 4 & 63] + \"==\"\n        );\n      } else if (extraBytes === 2) {\n        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];\n        parts.push(\n          lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + \"=\"\n        );\n      }\n      return parts.join(\"\");\n    }\n  }\n});\n\n// ../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json\nvar require_codes = __commonJS({\n  \"../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/codes.json\"(exports, module) {\n    module.exports = {\n      \"100\": \"Continue\",\n      \"101\": \"Switching Protocols\",\n      \"102\": \"Processing\",\n      \"103\": \"Early Hints\",\n      \"200\": \"OK\",\n      \"201\": \"Created\",\n      \"202\": \"Accepted\",\n      \"203\": \"Non-Authoritative Information\",\n      \"204\": \"No Content\",\n      \"205\": \"Reset Content\",\n      \"206\": \"Partial Content\",\n      \"207\": \"Multi-Status\",\n      \"208\": \"Already Reported\",\n      \"226\": \"IM Used\",\n      \"300\": \"Multiple Choices\",\n      \"301\": \"Moved Permanently\",\n      \"302\": \"Found\",\n      \"303\": \"See Other\",\n      \"304\": \"Not Modified\",\n      \"305\": \"Use Proxy\",\n      \"307\": \"Temporary Redirect\",\n      \"308\": \"Permanent Redirect\",\n      \"400\": \"Bad Request\",\n      \"401\": \"Unauthorized\",\n      \"402\": \"Payment Required\",\n      \"403\": \"Forbidden\",\n      \"404\": \"Not Found\",\n      \"405\": \"Method Not Allowed\",\n      \"406\": \"Not Acceptable\",\n      \"407\": \"Proxy Authentication Required\",\n      \"408\": \"Request Timeout\",\n      \"409\": \"Conflict\",\n      \"410\": \"Gone\",\n      \"411\": \"Length Required\",\n      \"412\": \"Precondition Failed\",\n      \"413\": \"Payload Too Large\",\n      \"414\": \"URI Too Long\",\n      \"415\": \"Unsupported Media Type\",\n      \"416\": \"Range Not Satisfiable\",\n      \"417\": \"Expectation Failed\",\n      \"418\": \"I'm a Teapot\",\n      \"421\": \"Misdirected Request\",\n      \"422\": \"Unprocessable Entity\",\n      \"423\": \"Locked\",\n      \"424\": \"Failed Dependency\",\n      \"425\": \"Too Early\",\n      \"426\": \"Upgrade Required\",\n      \"428\": \"Precondition Required\",\n      \"429\": \"Too Many Requests\",\n      \"431\": \"Request Header Fields Too Large\",\n      \"451\": \"Unavailable For Legal Reasons\",\n      \"500\": \"Internal Server Error\",\n      \"501\": \"Not Implemented\",\n      \"502\": \"Bad Gateway\",\n      \"503\": \"Service Unavailable\",\n      \"504\": \"Gateway Timeout\",\n      \"505\": \"HTTP Version Not Supported\",\n      \"506\": \"Variant Also Negotiates\",\n      \"507\": \"Insufficient Storage\",\n      \"508\": \"Loop Detected\",\n      \"509\": \"Bandwidth Limit Exceeded\",\n      \"510\": \"Not Extended\",\n      \"511\": \"Network Authentication Required\"\n    };\n  }\n});\n\n// ../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/index.js\nvar require_statuses = __commonJS({\n  \"../../node_modules/.pnpm/statuses@2.0.2/node_modules/statuses/index.js\"(exports, module) {\n    var codes = require_codes();\n    module.exports = status2;\n    status2.message = codes;\n    status2.code = createMessageToStatusCodeMap(codes);\n    status2.codes = createStatusCodeList(codes);\n    status2.redirect = {\n      300: true,\n      301: true,\n      302: true,\n      303: true,\n      305: true,\n      307: true,\n      308: true\n    };\n    status2.empty = {\n      204: true,\n      205: true,\n      304: true\n    };\n    status2.retry = {\n      502: true,\n      503: true,\n      504: true\n    };\n    function createMessageToStatusCodeMap(codes2) {\n      var map = {};\n      Object.keys(codes2).forEach(function forEachCode(code) {\n        var message = codes2[code];\n        var status3 = Number(code);\n        map[message.toLowerCase()] = status3;\n      });\n      return map;\n    }\n    function createStatusCodeList(codes2) {\n      return Object.keys(codes2).map(function mapCode(code) {\n        return Number(code);\n      });\n    }\n    function getStatusCode(message) {\n      var msg = message.toLowerCase();\n      if (!Object.prototype.hasOwnProperty.call(status2.code, msg)) {\n        throw new Error('invalid status message: \"' + message + '\"');\n      }\n      return status2.code[msg];\n    }\n    function getStatusMessage(code) {\n      if (!Object.prototype.hasOwnProperty.call(status2.message, code)) {\n        throw new Error(\"invalid status code: \" + code);\n      }\n      return status2.message[code];\n    }\n    function status2(code) {\n      if (typeof code === \"number\") {\n        return getStatusMessage(code);\n      }\n      if (typeof code !== \"string\") {\n        throw new TypeError(\"code must be a number or string\");\n      }\n      var n = parseInt(code, 10);\n      if (!isNaN(n)) {\n        return getStatusMessage(n);\n      }\n      return getStatusCode(code);\n    }\n  }\n});\n\n// src/util-stub.ts\nvar util_stub_exports = {};\n__export(util_stub_exports, {\n  inspect: () => inspect\n});\nvar inspect;\nvar init_util_stub = __esm({\n  \"src/util-stub.ts\"() {\n    inspect = {};\n  }\n});\n\n// ../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/util.inspect.js\nvar require_util_inspect = __commonJS({\n  \"../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/util.inspect.js\"(exports, module) {\n    module.exports = (init_util_stub(), __toCommonJS(util_stub_exports)).inspect;\n  }\n});\n\n// ../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/index.js\nvar require_object_inspect = __commonJS({\n  \"../../node_modules/.pnpm/object-inspect@1.13.4/node_modules/object-inspect/index.js\"(exports, module) {\n    var hasMap = typeof Map === \"function\" && Map.prototype;\n    var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, \"size\") : null;\n    var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === \"function\" ? mapSizeDescriptor.get : null;\n    var mapForEach = hasMap && Map.prototype.forEach;\n    var hasSet = typeof Set === \"function\" && Set.prototype;\n    var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, \"size\") : null;\n    var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === \"function\" ? setSizeDescriptor.get : null;\n    var setForEach = hasSet && Set.prototype.forEach;\n    var hasWeakMap = typeof WeakMap === \"function\" && WeakMap.prototype;\n    var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;\n    var hasWeakSet = typeof WeakSet === \"function\" && WeakSet.prototype;\n    var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;\n    var hasWeakRef = typeof WeakRef === \"function\" && WeakRef.prototype;\n    var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;\n    var booleanValueOf = Boolean.prototype.valueOf;\n    var objectToString = Object.prototype.toString;\n    var functionToString = Function.prototype.toString;\n    var $match = String.prototype.match;\n    var $slice = String.prototype.slice;\n    var $replace = String.prototype.replace;\n    var $toUpperCase = String.prototype.toUpperCase;\n    var $toLowerCase = String.prototype.toLowerCase;\n    var $test = RegExp.prototype.test;\n    var $concat = Array.prototype.concat;\n    var $join = Array.prototype.join;\n    var $arrSlice = Array.prototype.slice;\n    var $floor = Math.floor;\n    var bigIntValueOf = typeof BigInt === \"function\" ? BigInt.prototype.valueOf : null;\n    var gOPS = Object.getOwnPropertySymbols;\n    var symToString = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? Symbol.prototype.toString : null;\n    var hasShammedSymbols = typeof Symbol === \"function\" && typeof Symbol.iterator === \"object\";\n    var toStringTag = typeof Symbol === \"function\" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? \"object\" : \"symbol\") ? Symbol.toStringTag : null;\n    var isEnumerable = Object.prototype.propertyIsEnumerable;\n    var gPO = (typeof Reflect === \"function\" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {\n      return O.__proto__;\n    } : null);\n    function addNumericSeparator(num, str) {\n      if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {\n        return str;\n      }\n      var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;\n      if (typeof num === \"number\") {\n        var int = num < 0 ? -$floor(-num) : $floor(num);\n        if (int !== num) {\n          var intStr = String(int);\n          var dec = $slice.call(str, intStr.length + 1);\n          return $replace.call(intStr, sepRegex, \"$&_\") + \".\" + $replace.call($replace.call(dec, /([0-9]{3})/g, \"$&_\"), /_$/, \"\");\n        }\n      }\n      return $replace.call(str, sepRegex, \"$&_\");\n    }\n    var utilInspect = require_util_inspect();\n    var inspectCustom = utilInspect.custom;\n    var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;\n    var quotes = {\n      __proto__: null,\n      \"double\": '\"',\n      single: \"'\"\n    };\n    var quoteREs = {\n      __proto__: null,\n      \"double\": /([\"\\\\])/g,\n      single: /(['\\\\])/g\n    };\n    module.exports = function inspect_(obj, options, depth, seen) {\n      var opts = options || {};\n      if (has(opts, \"quoteStyle\") && !has(quotes, opts.quoteStyle)) {\n        throw new TypeError('option \"quoteStyle\" must be \"single\" or \"double\"');\n      }\n      if (has(opts, \"maxStringLength\") && (typeof opts.maxStringLength === \"number\" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {\n        throw new TypeError('option \"maxStringLength\", if provided, must be a positive integer, Infinity, or `null`');\n      }\n      var customInspect = has(opts, \"customInspect\") ? opts.customInspect : true;\n      if (typeof customInspect !== \"boolean\" && customInspect !== \"symbol\") {\n        throw new TypeError(\"option \\\"customInspect\\\", if provided, must be `true`, `false`, or `'symbol'`\");\n      }\n      if (has(opts, \"indent\") && opts.indent !== null && opts.indent !== \"\t\" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {\n        throw new TypeError('option \"indent\" must be \"\\\\t\", an integer > 0, or `null`');\n      }\n      if (has(opts, \"numericSeparator\") && typeof opts.numericSeparator !== \"boolean\") {\n        throw new TypeError('option \"numericSeparator\", if provided, must be `true` or `false`');\n      }\n      var numericSeparator = opts.numericSeparator;\n      if (typeof obj === \"undefined\") {\n        return \"undefined\";\n      }\n      if (obj === null) {\n        return \"null\";\n      }\n      if (typeof obj === \"boolean\") {\n        return obj ? \"true\" : \"false\";\n      }\n      if (typeof obj === \"string\") {\n        return inspectString(obj, opts);\n      }\n      if (typeof obj === \"number\") {\n        if (obj === 0) {\n          return Infinity / obj > 0 ? \"0\" : \"-0\";\n        }\n        var str = String(obj);\n        return numericSeparator ? addNumericSeparator(obj, str) : str;\n      }\n      if (typeof obj === \"bigint\") {\n        var bigIntStr = String(obj) + \"n\";\n        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;\n      }\n      var maxDepth = typeof opts.depth === \"undefined\" ? 5 : opts.depth;\n      if (typeof depth === \"undefined\") {\n        depth = 0;\n      }\n      if (depth >= maxDepth && maxDepth > 0 && typeof obj === \"object\") {\n        return isArray(obj) ? \"[Array]\" : \"[Object]\";\n      }\n      var indent = getIndent(opts, depth);\n      if (typeof seen === \"undefined\") {\n        seen = [];\n      } else if (indexOf(seen, obj) >= 0) {\n        return \"[Circular]\";\n      }\n      function inspect3(value, from, noIndent) {\n        if (from) {\n          seen = $arrSlice.call(seen);\n          seen.push(from);\n        }\n        if (noIndent) {\n          var newOpts = {\n            depth: opts.depth\n          };\n          if (has(opts, \"quoteStyle\")) {\n            newOpts.quoteStyle = opts.quoteStyle;\n          }\n          return inspect_(value, newOpts, depth + 1, seen);\n        }\n        return inspect_(value, opts, depth + 1, seen);\n      }\n      if (typeof obj === \"function\" && !isRegExp(obj)) {\n        var name = nameOf(obj);\n        var keys = arrObjKeys(obj, inspect3);\n        return \"[Function\" + (name ? \": \" + name : \" (anonymous)\") + \"]\" + (keys.length > 0 ? \" { \" + $join.call(keys, \", \") + \" }\" : \"\");\n      }\n      if (isSymbol(obj)) {\n        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\\(.*\\))_[^)]*$/, \"$1\") : symToString.call(obj);\n        return typeof obj === \"object\" && !hasShammedSymbols ? markBoxed(symString) : symString;\n      }\n      if (isElement(obj)) {\n        var s = \"<\" + $toLowerCase.call(String(obj.nodeName));\n        var attrs = obj.attributes || [];\n        for (var i = 0; i < attrs.length; i++) {\n          s += \" \" + attrs[i].name + \"=\" + wrapQuotes(quote(attrs[i].value), \"double\", opts);\n        }\n        s += \">\";\n        if (obj.childNodes && obj.childNodes.length) {\n          s += \"...\";\n        }\n        s += \"</\" + $toLowerCase.call(String(obj.nodeName)) + \">\";\n        return s;\n      }\n      if (isArray(obj)) {\n        if (obj.length === 0) {\n          return \"[]\";\n        }\n        var xs = arrObjKeys(obj, inspect3);\n        if (indent && !singleLineValues(xs)) {\n          return \"[\" + indentedJoin(xs, indent) + \"]\";\n        }\n        return \"[ \" + $join.call(xs, \", \") + \" ]\";\n      }\n      if (isError(obj)) {\n        var parts = arrObjKeys(obj, inspect3);\n        if (!(\"cause\" in Error.prototype) && \"cause\" in obj && !isEnumerable.call(obj, \"cause\")) {\n          return \"{ [\" + String(obj) + \"] \" + $join.call($concat.call(\"[cause]: \" + inspect3(obj.cause), parts), \", \") + \" }\";\n        }\n        if (parts.length === 0) {\n          return \"[\" + String(obj) + \"]\";\n        }\n        return \"{ [\" + String(obj) + \"] \" + $join.call(parts, \", \") + \" }\";\n      }\n      if (typeof obj === \"object\" && customInspect) {\n        if (inspectSymbol && typeof obj[inspectSymbol] === \"function\" && utilInspect) {\n          return utilInspect(obj, { depth: maxDepth - depth });\n        } else if (customInspect !== \"symbol\" && typeof obj.inspect === \"function\") {\n          return obj.inspect();\n        }\n      }\n      if (isMap(obj)) {\n        var mapParts = [];\n        if (mapForEach) {\n          mapForEach.call(obj, function(value, key) {\n            mapParts.push(inspect3(key, obj, true) + \" => \" + inspect3(value, obj));\n          });\n        }\n        return collectionOf(\"Map\", mapSize.call(obj), mapParts, indent);\n      }\n      if (isSet(obj)) {\n        var setParts = [];\n        if (setForEach) {\n          setForEach.call(obj, function(value) {\n            setParts.push(inspect3(value, obj));\n          });\n        }\n        return collectionOf(\"Set\", setSize.call(obj), setParts, indent);\n      }\n      if (isWeakMap(obj)) {\n        return weakCollectionOf(\"WeakMap\");\n      }\n      if (isWeakSet(obj)) {\n        return weakCollectionOf(\"WeakSet\");\n      }\n      if (isWeakRef(obj)) {\n        return weakCollectionOf(\"WeakRef\");\n      }\n      if (isNumber(obj)) {\n        return markBoxed(inspect3(Number(obj)));\n      }\n      if (isBigInt(obj)) {\n        return markBoxed(inspect3(bigIntValueOf.call(obj)));\n      }\n      if (isBoolean(obj)) {\n        return markBoxed(booleanValueOf.call(obj));\n      }\n      if (isString(obj)) {\n        return markBoxed(inspect3(String(obj)));\n      }\n      if (typeof window !== \"undefined\" && obj === window) {\n        return \"{ [object Window] }\";\n      }\n      if (typeof globalThis !== \"undefined\" && obj === globalThis || typeof global !== \"undefined\" && obj === global) {\n        return \"{ [object globalThis] }\";\n      }\n      if (!isDate(obj) && !isRegExp(obj)) {\n        var ys = arrObjKeys(obj, inspect3);\n        var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;\n        var protoTag = obj instanceof Object ? \"\" : \"null prototype\";\n        var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? \"Object\" : \"\";\n        var constructorTag = isPlainObject || typeof obj.constructor !== \"function\" ? \"\" : obj.constructor.name ? obj.constructor.name + \" \" : \"\";\n        var tag = constructorTag + (stringTag || protoTag ? \"[\" + $join.call($concat.call([], stringTag || [], protoTag || []), \": \") + \"] \" : \"\");\n        if (ys.length === 0) {\n          return tag + \"{}\";\n        }\n        if (indent) {\n          return tag + \"{\" + indentedJoin(ys, indent) + \"}\";\n        }\n        return tag + \"{ \" + $join.call(ys, \", \") + \" }\";\n      }\n      return String(obj);\n    };\n    function wrapQuotes(s, defaultStyle, opts) {\n      var style = opts.quoteStyle || defaultStyle;\n      var quoteChar = quotes[style];\n      return quoteChar + s + quoteChar;\n    }\n    function quote(s) {\n      return $replace.call(String(s), /\"/g, \"&quot;\");\n    }\n    function canTrustToString(obj) {\n      return !toStringTag || !(typeof obj === \"object\" && (toStringTag in obj || typeof obj[toStringTag] !== \"undefined\"));\n    }\n    function isArray(obj) {\n      return toStr(obj) === \"[object Array]\" && canTrustToString(obj);\n    }\n    function isDate(obj) {\n      return toStr(obj) === \"[object Date]\" && canTrustToString(obj);\n    }\n    function isRegExp(obj) {\n      return toStr(obj) === \"[object RegExp]\" && canTrustToString(obj);\n    }\n    function isError(obj) {\n      return toStr(obj) === \"[object Error]\" && canTrustToString(obj);\n    }\n    function isString(obj) {\n      return toStr(obj) === \"[object String]\" && canTrustToString(obj);\n    }\n    function isNumber(obj) {\n      return toStr(obj) === \"[object Number]\" && canTrustToString(obj);\n    }\n    function isBoolean(obj) {\n      return toStr(obj) === \"[object Boolean]\" && canTrustToString(obj);\n    }\n    function isSymbol(obj) {\n      if (hasShammedSymbols) {\n        return obj && typeof obj === \"object\" && obj instanceof Symbol;\n      }\n      if (typeof obj === \"symbol\") {\n        return true;\n      }\n      if (!obj || typeof obj !== \"object\" || !symToString) {\n        return false;\n      }\n      try {\n        symToString.call(obj);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isBigInt(obj) {\n      if (!obj || typeof obj !== \"object\" || !bigIntValueOf) {\n        return false;\n      }\n      try {\n        bigIntValueOf.call(obj);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    var hasOwn2 = Object.prototype.hasOwnProperty || function(key) {\n      return key in this;\n    };\n    function has(obj, key) {\n      return hasOwn2.call(obj, key);\n    }\n    function toStr(obj) {\n      return objectToString.call(obj);\n    }\n    function nameOf(f) {\n      if (f.name) {\n        return f.name;\n      }\n      var m = $match.call(functionToString.call(f), /^function\\s*([\\w$]+)/);\n      if (m) {\n        return m[1];\n      }\n      return null;\n    }\n    function indexOf(xs, x) {\n      if (xs.indexOf) {\n        return xs.indexOf(x);\n      }\n      for (var i = 0, l = xs.length; i < l; i++) {\n        if (xs[i] === x) {\n          return i;\n        }\n      }\n      return -1;\n    }\n    function isMap(x) {\n      if (!mapSize || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        mapSize.call(x);\n        try {\n          setSize.call(x);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof Map;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakMap(x) {\n      if (!weakMapHas || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakMapHas.call(x, weakMapHas);\n        try {\n          weakSetHas.call(x, weakSetHas);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof WeakMap;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakRef(x) {\n      if (!weakRefDeref || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakRefDeref.call(x);\n        return true;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isSet(x) {\n      if (!setSize || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        setSize.call(x);\n        try {\n          mapSize.call(x);\n        } catch (m) {\n          return true;\n        }\n        return x instanceof Set;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isWeakSet(x) {\n      if (!weakSetHas || !x || typeof x !== \"object\") {\n        return false;\n      }\n      try {\n        weakSetHas.call(x, weakSetHas);\n        try {\n          weakMapHas.call(x, weakMapHas);\n        } catch (s) {\n          return true;\n        }\n        return x instanceof WeakSet;\n      } catch (e) {\n      }\n      return false;\n    }\n    function isElement(x) {\n      if (!x || typeof x !== \"object\") {\n        return false;\n      }\n      if (typeof HTMLElement !== \"undefined\" && x instanceof HTMLElement) {\n        return true;\n      }\n      return typeof x.nodeName === \"string\" && typeof x.getAttribute === \"function\";\n    }\n    function inspectString(str, opts) {\n      if (str.length > opts.maxStringLength) {\n        var remaining = str.length - opts.maxStringLength;\n        var trailer = \"... \" + remaining + \" more character\" + (remaining > 1 ? \"s\" : \"\");\n        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;\n      }\n      var quoteRE = quoteREs[opts.quoteStyle || \"single\"];\n      quoteRE.lastIndex = 0;\n      var s = $replace.call($replace.call(str, quoteRE, \"\\\\$1\"), /[\\x00-\\x1f]/g, lowbyte);\n      return wrapQuotes(s, \"single\", opts);\n    }\n    function lowbyte(c) {\n      var n = c.charCodeAt(0);\n      var x = {\n        8: \"b\",\n        9: \"t\",\n        10: \"n\",\n        12: \"f\",\n        13: \"r\"\n      }[n];\n      if (x) {\n        return \"\\\\\" + x;\n      }\n      return \"\\\\x\" + (n < 16 ? \"0\" : \"\") + $toUpperCase.call(n.toString(16));\n    }\n    function markBoxed(str) {\n      return \"Object(\" + str + \")\";\n    }\n    function weakCollectionOf(type) {\n      return type + \" { ? }\";\n    }\n    function collectionOf(type, size, entries, indent) {\n      var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, \", \");\n      return type + \" (\" + size + \") {\" + joinedEntries + \"}\";\n    }\n    function singleLineValues(xs) {\n      for (var i = 0; i < xs.length; i++) {\n        if (indexOf(xs[i], \"\\n\") >= 0) {\n          return false;\n        }\n      }\n      return true;\n    }\n    function getIndent(opts, depth) {\n      var baseIndent;\n      if (opts.indent === \"\t\") {\n        baseIndent = \"\t\";\n      } else if (typeof opts.indent === \"number\" && opts.indent > 0) {\n        baseIndent = $join.call(Array(opts.indent + 1), \" \");\n      } else {\n        return null;\n      }\n      return {\n        base: baseIndent,\n        prev: $join.call(Array(depth + 1), baseIndent)\n      };\n    }\n    function indentedJoin(xs, indent) {\n      if (xs.length === 0) {\n        return \"\";\n      }\n      var lineJoiner = \"\\n\" + indent.prev + indent.base;\n      return lineJoiner + $join.call(xs, \",\" + lineJoiner) + \"\\n\" + indent.prev;\n    }\n    function arrObjKeys(obj, inspect3) {\n      var isArr = isArray(obj);\n      var xs = [];\n      if (isArr) {\n        xs.length = obj.length;\n        for (var i = 0; i < obj.length; i++) {\n          xs[i] = has(obj, i) ? inspect3(obj[i], obj) : \"\";\n        }\n      }\n      var syms = typeof gOPS === \"function\" ? gOPS(obj) : [];\n      var symMap;\n      if (hasShammedSymbols) {\n        symMap = {};\n        for (var k = 0; k < syms.length; k++) {\n          symMap[\"$\" + syms[k]] = syms[k];\n        }\n      }\n      for (var key in obj) {\n        if (!has(obj, key)) {\n          continue;\n        }\n        if (isArr && String(Number(key)) === key && key < obj.length) {\n          continue;\n        }\n        if (hasShammedSymbols && symMap[\"$\" + key] instanceof Symbol) {\n          continue;\n        } else if ($test.call(/[^\\w$]/, key)) {\n          xs.push(inspect3(key, obj) + \": \" + inspect3(obj[key], obj));\n        } else {\n          xs.push(key + \": \" + inspect3(obj[key], obj));\n        }\n      }\n      if (typeof gOPS === \"function\") {\n        for (var j = 0; j < syms.length; j++) {\n          if (isEnumerable.call(obj, syms[j])) {\n            xs.push(\"[\" + inspect3(syms[j]) + \"]: \" + inspect3(obj[syms[j]], obj));\n          }\n        }\n      }\n      return xs;\n    }\n  }\n});\n\n// src/lib/time_duration.ts\nvar TimeDuration = class _TimeDuration {\n  __time_duration_micros__;\n  static MICROS_PER_MILLIS = 1000n;\n  /**\n   * Get the algebraic type representation of the {@link TimeDuration} type.\n   * @returns The algebraic type representation of the type.\n   */\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [\n        {\n          name: \"__time_duration_micros__\",\n          algebraicType: AlgebraicType.I64\n        }\n      ]\n    });\n  }\n  static isTimeDuration(algebraicType) {\n    if (algebraicType.tag !== \"Product\") {\n      return false;\n    }\n    const elements = algebraicType.value.elements;\n    if (elements.length !== 1) {\n      return false;\n    }\n    const microsElement = elements[0];\n    return microsElement.name === \"__time_duration_micros__\" && microsElement.algebraicType.tag === \"I64\";\n  }\n  get micros() {\n    return this.__time_duration_micros__;\n  }\n  get millis() {\n    return Number(this.micros / _TimeDuration.MICROS_PER_MILLIS);\n  }\n  constructor(micros) {\n    this.__time_duration_micros__ = micros;\n  }\n  static fromMillis(millis) {\n    return new _TimeDuration(BigInt(millis) * _TimeDuration.MICROS_PER_MILLIS);\n  }\n  /** This outputs the same string format that we use in the host and in Rust modules */\n  toString() {\n    const micros = this.micros;\n    const sign = micros < 0 ? \"-\" : \"+\";\n    const pos = micros < 0 ? -micros : micros;\n    const secs = pos / 1000000n;\n    const micros_remaining = pos % 1000000n;\n    return `${sign}${secs}.${String(micros_remaining).padStart(6, \"0\")}`;\n  }\n};\n\n// src/lib/timestamp.ts\nvar Timestamp = class _Timestamp {\n  __timestamp_micros_since_unix_epoch__;\n  static MICROS_PER_MILLIS = 1000n;\n  get microsSinceUnixEpoch() {\n    return this.__timestamp_micros_since_unix_epoch__;\n  }\n  constructor(micros) {\n    this.__timestamp_micros_since_unix_epoch__ = micros;\n  }\n  /**\n   * Get the algebraic type representation of the {@link Timestamp} type.\n   * @returns The algebraic type representation of the type.\n   */\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [\n        {\n          name: \"__timestamp_micros_since_unix_epoch__\",\n          algebraicType: AlgebraicType.I64\n        }\n      ]\n    });\n  }\n  static isTimestamp(algebraicType) {\n    if (algebraicType.tag !== \"Product\") {\n      return false;\n    }\n    const elements = algebraicType.value.elements;\n    if (elements.length !== 1) {\n      return false;\n    }\n    const microsElement = elements[0];\n    return microsElement.name === \"__timestamp_micros_since_unix_epoch__\" && microsElement.algebraicType.tag === \"I64\";\n  }\n  /**\n   * The Unix epoch, the midnight at the beginning of January 1, 1970, UTC.\n   */\n  static UNIX_EPOCH = new _Timestamp(0n);\n  /**\n   * Get a `Timestamp` representing the execution environment's belief of the current moment in time.\n   */\n  static now() {\n    return _Timestamp.fromDate(/* @__PURE__ */ new Date());\n  }\n  /** Convert to milliseconds since Unix epoch. */\n  toMillis() {\n    return this.microsSinceUnixEpoch / 1000n;\n  }\n  /**\n   * Get a `Timestamp` representing the same point in time as `date`.\n   */\n  static fromDate(date) {\n    const millis = date.getTime();\n    const micros = BigInt(millis) * _Timestamp.MICROS_PER_MILLIS;\n    return new _Timestamp(micros);\n  }\n  /**\n   * Get a `Date` representing approximately the same point in time as `this`.\n   *\n   * This method truncates to millisecond precision,\n   * and throws `RangeError` if the `Timestamp` is outside the range representable as a `Date`.\n   */\n  toDate() {\n    const micros = this.__timestamp_micros_since_unix_epoch__;\n    const millis = micros / _Timestamp.MICROS_PER_MILLIS;\n    if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) {\n      throw new RangeError(\n        \"Timestamp is outside of the representable range of JS's Date\"\n      );\n    }\n    return new Date(Number(millis));\n  }\n  /**\n   * Get an ISO 8601 / RFC 3339 formatted string representation of this timestamp with microsecond precision.\n   *\n   * This method preserves the full microsecond precision of the timestamp,\n   * and throws `RangeError` if the `Timestamp` is outside the range representable in ISO format.\n   *\n   * @returns ISO 8601 formatted string with microsecond precision (e.g., '2025-02-17T10:30:45.123456Z')\n   */\n  toISOString() {\n    const micros = this.__timestamp_micros_since_unix_epoch__;\n    const millis = micros / _Timestamp.MICROS_PER_MILLIS;\n    if (millis > BigInt(Number.MAX_SAFE_INTEGER) || millis < BigInt(Number.MIN_SAFE_INTEGER)) {\n      throw new RangeError(\n        \"Timestamp is outside of the representable range for ISO string formatting\"\n      );\n    }\n    const date = new Date(Number(millis));\n    const isoBase = date.toISOString();\n    const microsRemainder = Math.abs(Number(micros % 1000000n));\n    const fractionalPart = String(microsRemainder).padStart(6, \"0\");\n    return isoBase.replace(/\\.\\d{3}Z$/, `.${fractionalPart}Z`);\n  }\n  since(other) {\n    return new TimeDuration(\n      this.__timestamp_micros_since_unix_epoch__ - other.__timestamp_micros_since_unix_epoch__\n    );\n  }\n};\n\n// src/lib/uuid.ts\nvar Uuid = class _Uuid {\n  __uuid__;\n  /**\n   * The nil UUID (all zeros).\n   *\n   * @example\n   * ```ts\n   * const uuid = Uuid.NIL;\n   * console.assert(\n   *   uuid.toString() === \"00000000-0000-0000-0000-000000000000\"\n   * );\n   * ```\n   */\n  static NIL = new _Uuid(0n);\n  static MAX_UUID_BIGINT = 0xffffffffffffffffffffffffffffffffn;\n  /**\n   * The max UUID (all ones).\n   *\n   * @example\n   * ```ts\n   * const uuid = Uuid.MAX;\n   * console.assert(\n   *   uuid.toString() === \"ffffffff-ffff-ffff-ffff-ffffffffffff\"\n   * );\n   * ```\n   */\n  static MAX = new _Uuid(_Uuid.MAX_UUID_BIGINT);\n  /**\n   * Create a UUID from a raw 128-bit value.\n   *\n   * @param u - Unsigned 128-bit integer\n   * @throws {Error} If the value is outside the valid UUID range\n   */\n  constructor(u) {\n    if (u < 0n || u > _Uuid.MAX_UUID_BIGINT) {\n      throw new Error(\"Invalid UUID: must be between 0 and `MAX_UUID_BIGINT`\");\n    }\n    this.__uuid__ = u;\n  }\n  /**\n   * Create a UUID `v4` from explicit random bytes.\n   *\n   * This method assumes the bytes are already sufficiently random.\n   * It only sets the appropriate bits for the UUID version and variant.\n   *\n   * @param bytes - Exactly 16 random bytes\n   * @returns A UUID `v4`\n   * @throws {Error} If `bytes.length !== 16`\n   *\n   * @example\n   * ```ts\n   * const randomBytes = new Uint8Array(16);\n   * const uuid = Uuid.fromRandomBytesV4(randomBytes);\n   *\n   * console.assert(\n   *   uuid.toString() === \"00000000-0000-4000-8000-000000000000\"\n   * );\n   * ```\n   */\n  static fromRandomBytesV4(bytes) {\n    if (bytes.length !== 16) throw new Error(\"UUID v4 requires 16 bytes\");\n    const arr = new Uint8Array(bytes);\n    arr[6] = arr[6] & 15 | 64;\n    arr[8] = arr[8] & 63 | 128;\n    return new _Uuid(_Uuid.bytesToBigInt(arr));\n  }\n  /**\n   * Generate a UUID `v7` using a monotonic counter from `0` to `2^31 - 1`,\n   * a timestamp, and 4 random bytes.\n   *\n   * The counter wraps around on overflow.\n   *\n   * The UUID `v7` is structured as follows:\n   *\n   * ```ascii\n   * ┌───────────────────────────────────────────────┬───────────────────┐\n   * | B0  | B1  | B2  | B3  | B4  | B5              |         B6        |\n   * ├───────────────────────────────────────────────┼───────────────────┤\n   * |                 unix_ts_ms                    |      version 7    |\n   * └───────────────────────────────────────────────┴───────────────────┘\n   * ┌──────────────┬─────────┬──────────────────┬───────────────────────┐\n   * | B7           | B8      | B9  | B10 | B11  | B12 | B13 | B14 | B15 |\n   * ├──────────────┼─────────┼──────────────────┼───────────────────────┤\n   * | counter_high | variant |    counter_low   |        random         |\n   * └──────────────┴─────────┴──────────────────┴───────────────────────┘\n   * ```\n   *\n   * @param counter - Mutable monotonic counter (31-bit)\n   * @param now - Timestamp since the Unix epoch\n   * @param randomBytes - Exactly 4 random bytes\n   * @returns A UUID `v7`\n   *\n   * @throws {Error} If the `counter` is negative\n   * @throws {Error} If the `timestamp` is before the Unix epoch\n   * @throws {Error} If `randomBytes.length !== 4`\n   *\n   * @example\n   * ```ts\n   * const now = Timestamp.fromMillis(1_686_000_000_000n);\n   * const counter = { value: 1 };\n   * const randomBytes = new Uint8Array(4);\n   *\n   * const uuid = Uuid.fromCounterV7(counter, now, randomBytes);\n   *\n   * console.assert(\n   *   uuid.toString() === \"0000647e-5180-7000-8000-000200000000\"\n   * );\n   * ```\n   */\n  static fromCounterV7(counter, now, randomBytes) {\n    if (randomBytes.length !== 4) {\n      throw new Error(\"`fromCounterV7` requires `randomBytes.length == 4`\");\n    }\n    if (counter.value < 0) {\n      throw new Error(\"`fromCounterV7` uuid `counter` must be non-negative\");\n    }\n    if (now.__timestamp_micros_since_unix_epoch__ < 0) {\n      throw new Error(\"`fromCounterV7` `timestamp` before unix epoch\");\n    }\n    const counterVal = counter.value;\n    counter.value = counterVal + 1 & 2147483647;\n    const tsMs = now.toMillis() & 0xffffffffffffn;\n    const bytes = new Uint8Array(16);\n    bytes[0] = Number(tsMs >> 40n & 0xffn);\n    bytes[1] = Number(tsMs >> 32n & 0xffn);\n    bytes[2] = Number(tsMs >> 24n & 0xffn);\n    bytes[3] = Number(tsMs >> 16n & 0xffn);\n    bytes[4] = Number(tsMs >> 8n & 0xffn);\n    bytes[5] = Number(tsMs & 0xffn);\n    bytes[7] = counterVal >>> 23 & 255;\n    bytes[9] = counterVal >>> 15 & 255;\n    bytes[10] = counterVal >>> 7 & 255;\n    bytes[11] = (counterVal & 127) << 1 & 255;\n    bytes[12] |= randomBytes[0] & 127;\n    bytes[13] = randomBytes[1];\n    bytes[14] = randomBytes[2];\n    bytes[15] = randomBytes[3];\n    bytes[6] = bytes[6] & 15 | 112;\n    bytes[8] = bytes[8] & 63 | 128;\n    return new _Uuid(_Uuid.bytesToBigInt(bytes));\n  }\n  /**\n   * Parse a UUID from a string representation.\n   *\n   * @param s - UUID string\n   * @returns Parsed UUID\n   * @throws {Error} If the string is not a valid UUID\n   *\n   * @example\n   * ```ts\n   * const s = \"01888d6e-5c00-7000-8000-000000000000\";\n   * const uuid = Uuid.parse(s);\n   *\n   * console.assert(uuid.toString() === s);\n   * ```\n   */\n  static parse(s) {\n    const hex = s.replace(/-/g, \"\");\n    if (hex.length !== 32) throw new Error(\"Invalid hex UUID\");\n    let v = 0n;\n    for (let i = 0; i < 32; i += 2) {\n      v = v << 8n | BigInt(parseInt(hex.slice(i, i + 2), 16));\n    }\n    return new _Uuid(v);\n  }\n  /** Convert to string (hyphenated form). */\n  toString() {\n    const bytes = _Uuid.bigIntToBytes(this.__uuid__);\n    const hex = [...bytes].map((b) => b.toString(16).padStart(2, \"0\")).join(\"\");\n    return hex.slice(0, 8) + \"-\" + hex.slice(8, 12) + \"-\" + hex.slice(12, 16) + \"-\" + hex.slice(16, 20) + \"-\" + hex.slice(20);\n  }\n  /** Convert to bigint (u128). */\n  asBigInt() {\n    return this.__uuid__;\n  }\n  /** Return a `Uint8Array` of 16 bytes. */\n  toBytes() {\n    return _Uuid.bigIntToBytes(this.__uuid__);\n  }\n  static bytesToBigInt(bytes) {\n    let result = 0n;\n    for (const b of bytes) result = result << 8n | BigInt(b);\n    return result;\n  }\n  static bigIntToBytes(value) {\n    const bytes = new Uint8Array(16);\n    for (let i = 15; i >= 0; i--) {\n      bytes[i] = Number(value & 0xffn);\n      value >>= 8n;\n    }\n    return bytes;\n  }\n  /**\n   * Returns the version of this UUID.\n   *\n   * This represents the algorithm used to generate the value.\n   *\n   * @returns A `UuidVersion`\n   * @throws {Error} If the version field is not recognized\n   */\n  getVersion() {\n    const version = this.toBytes()[6] >> 4 & 15;\n    switch (version) {\n      case 4:\n        return \"V4\";\n      case 7:\n        return \"V7\";\n      default:\n        if (this == _Uuid.NIL) {\n          return \"Nil\";\n        }\n        if (this == _Uuid.MAX) {\n          return \"Max\";\n        }\n        throw new Error(`Unsupported UUID version: ${version}`);\n    }\n  }\n  /**\n   * Extract the monotonic counter from a UUIDv7.\n   *\n   * Intended for testing and diagnostics.\n   * Behavior is undefined if called on a non-V7 UUID.\n   *\n   * @returns 31-bit counter value\n   */\n  getCounter() {\n    const bytes = this.toBytes();\n    const high = bytes[7];\n    const mid1 = bytes[9];\n    const mid2 = bytes[10];\n    const low = bytes[11] >>> 1;\n    return high << 23 | mid1 << 15 | mid2 << 7 | low | 0;\n  }\n  compareTo(other) {\n    if (this.__uuid__ < other.__uuid__) return -1;\n    if (this.__uuid__ > other.__uuid__) return 1;\n    return 0;\n  }\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [\n        {\n          name: \"__uuid__\",\n          algebraicType: AlgebraicType.U128\n        }\n      ]\n    });\n  }\n};\n\n// src/lib/binary_reader.ts\nvar BinaryReader = class {\n  /**\n   * The DataView used to read values from the binary data.\n   *\n   * Note: The DataView's `byteOffset` is relative to the beginning of the\n   * underlying ArrayBuffer, not the start of the provided Uint8Array input.\n   * This `BinaryReader`'s `#offset` field is used to track the current read position\n   * relative to the start of the provided Uint8Array input.\n   */\n  view;\n  /**\n   * Represents the offset (in bytes) relative to the start of the DataView\n   * and provided Uint8Array input.\n   *\n   * Note: This is *not* the absolute byte offset within the underlying ArrayBuffer.\n   */\n  offset = 0;\n  constructor(input) {\n    this.view = input instanceof DataView ? input : new DataView(input.buffer, input.byteOffset, input.byteLength);\n    this.offset = 0;\n  }\n  reset(view) {\n    this.view = view;\n    this.offset = 0;\n  }\n  get remaining() {\n    return this.view.byteLength - this.offset;\n  }\n  /** Ensure we have at least `n` bytes left to read */\n  #ensure(n) {\n    if (this.offset + n > this.view.byteLength) {\n      throw new RangeError(\n        `Tried to read ${n} byte(s) at relative offset ${this.offset}, but only ${this.remaining} byte(s) remain`\n      );\n    }\n  }\n  readUInt8Array() {\n    const length = this.readU32();\n    this.#ensure(length);\n    return this.readBytes(length);\n  }\n  readBool() {\n    const value = this.view.getUint8(this.offset);\n    this.offset += 1;\n    return value !== 0;\n  }\n  readByte() {\n    const value = this.view.getUint8(this.offset);\n    this.offset += 1;\n    return value;\n  }\n  readBytes(length) {\n    const array = new Uint8Array(\n      this.view.buffer,\n      this.view.byteOffset + this.offset,\n      length\n    );\n    this.offset += length;\n    return array;\n  }\n  readI8() {\n    const value = this.view.getInt8(this.offset);\n    this.offset += 1;\n    return value;\n  }\n  readU8() {\n    return this.readByte();\n  }\n  readI16() {\n    const value = this.view.getInt16(this.offset, true);\n    this.offset += 2;\n    return value;\n  }\n  readU16() {\n    const value = this.view.getUint16(this.offset, true);\n    this.offset += 2;\n    return value;\n  }\n  readI32() {\n    const value = this.view.getInt32(this.offset, true);\n    this.offset += 4;\n    return value;\n  }\n  readU32() {\n    const value = this.view.getUint32(this.offset, true);\n    this.offset += 4;\n    return value;\n  }\n  readI64() {\n    const value = this.view.getBigInt64(this.offset, true);\n    this.offset += 8;\n    return value;\n  }\n  readU64() {\n    const value = this.view.getBigUint64(this.offset, true);\n    this.offset += 8;\n    return value;\n  }\n  readU128() {\n    const lowerPart = this.view.getBigUint64(this.offset, true);\n    const upperPart = this.view.getBigUint64(this.offset + 8, true);\n    this.offset += 16;\n    return (upperPart << BigInt(64)) + lowerPart;\n  }\n  readI128() {\n    const lowerPart = this.view.getBigUint64(this.offset, true);\n    const upperPart = this.view.getBigInt64(this.offset + 8, true);\n    this.offset += 16;\n    return (upperPart << BigInt(64)) + lowerPart;\n  }\n  readU256() {\n    const p0 = this.view.getBigUint64(this.offset, true);\n    const p1 = this.view.getBigUint64(this.offset + 8, true);\n    const p2 = this.view.getBigUint64(this.offset + 16, true);\n    const p3 = this.view.getBigUint64(this.offset + 24, true);\n    this.offset += 32;\n    return (p3 << BigInt(3 * 64)) + (p2 << BigInt(2 * 64)) + (p1 << BigInt(1 * 64)) + p0;\n  }\n  readI256() {\n    const p0 = this.view.getBigUint64(this.offset, true);\n    const p1 = this.view.getBigUint64(this.offset + 8, true);\n    const p2 = this.view.getBigUint64(this.offset + 16, true);\n    const p3 = this.view.getBigInt64(this.offset + 24, true);\n    this.offset += 32;\n    return (p3 << BigInt(3 * 64)) + (p2 << BigInt(2 * 64)) + (p1 << BigInt(1 * 64)) + p0;\n  }\n  readF32() {\n    const value = this.view.getFloat32(this.offset, true);\n    this.offset += 4;\n    return value;\n  }\n  readF64() {\n    const value = this.view.getFloat64(this.offset, true);\n    this.offset += 8;\n    return value;\n  }\n  readString() {\n    const uint8Array = this.readUInt8Array();\n    return new TextDecoder(\"utf-8\").decode(uint8Array);\n  }\n};\n\n// src/lib/binary_writer.ts\nvar import_base64_js = __toESM(require_base64_js());\nvar ArrayBufferPrototypeTransfer = ArrayBuffer.prototype.transfer ?? function(newByteLength) {\n  if (newByteLength === void 0) {\n    return this.slice();\n  } else if (newByteLength <= this.byteLength) {\n    return this.slice(0, newByteLength);\n  } else {\n    const copy = new Uint8Array(newByteLength);\n    copy.set(new Uint8Array(this));\n    return copy.buffer;\n  }\n};\nvar ResizableBuffer = class {\n  buffer;\n  view;\n  constructor(init) {\n    this.buffer = typeof init === \"number\" ? new ArrayBuffer(init) : init;\n    this.view = new DataView(this.buffer);\n  }\n  get capacity() {\n    return this.buffer.byteLength;\n  }\n  grow(newSize) {\n    if (newSize <= this.buffer.byteLength) return;\n    this.buffer = ArrayBufferPrototypeTransfer.call(this.buffer, newSize);\n    this.view = new DataView(this.buffer);\n  }\n};\nvar BinaryWriter = class {\n  buffer;\n  offset = 0;\n  constructor(init) {\n    this.buffer = typeof init === \"number\" ? new ResizableBuffer(init) : init;\n  }\n  clear() {\n    this.offset = 0;\n  }\n  reset(buffer) {\n    this.buffer = buffer;\n    this.offset = 0;\n  }\n  expandBuffer(additionalCapacity) {\n    const minCapacity = this.offset + additionalCapacity + 1;\n    if (minCapacity <= this.buffer.capacity) return;\n    let newCapacity = this.buffer.capacity * 2;\n    if (newCapacity < minCapacity) newCapacity = minCapacity;\n    this.buffer.grow(newCapacity);\n  }\n  toBase64() {\n    return (0, import_base64_js.fromByteArray)(this.getBuffer());\n  }\n  getBuffer() {\n    return new Uint8Array(this.buffer.buffer, 0, this.offset);\n  }\n  get view() {\n    return this.buffer.view;\n  }\n  writeUInt8Array(value) {\n    const length = value.length;\n    this.expandBuffer(4 + length);\n    this.writeU32(length);\n    new Uint8Array(this.buffer.buffer, this.offset).set(value);\n    this.offset += length;\n  }\n  writeBool(value) {\n    this.expandBuffer(1);\n    this.view.setUint8(this.offset, value ? 1 : 0);\n    this.offset += 1;\n  }\n  writeByte(value) {\n    this.expandBuffer(1);\n    this.view.setUint8(this.offset, value);\n    this.offset += 1;\n  }\n  writeI8(value) {\n    this.expandBuffer(1);\n    this.view.setInt8(this.offset, value);\n    this.offset += 1;\n  }\n  writeU8(value) {\n    this.expandBuffer(1);\n    this.view.setUint8(this.offset, value);\n    this.offset += 1;\n  }\n  writeI16(value) {\n    this.expandBuffer(2);\n    this.view.setInt16(this.offset, value, true);\n    this.offset += 2;\n  }\n  writeU16(value) {\n    this.expandBuffer(2);\n    this.view.setUint16(this.offset, value, true);\n    this.offset += 2;\n  }\n  writeI32(value) {\n    this.expandBuffer(4);\n    this.view.setInt32(this.offset, value, true);\n    this.offset += 4;\n  }\n  writeU32(value) {\n    this.expandBuffer(4);\n    this.view.setUint32(this.offset, value, true);\n    this.offset += 4;\n  }\n  writeI64(value) {\n    this.expandBuffer(8);\n    this.view.setBigInt64(this.offset, value, true);\n    this.offset += 8;\n  }\n  writeU64(value) {\n    this.expandBuffer(8);\n    this.view.setBigUint64(this.offset, value, true);\n    this.offset += 8;\n  }\n  writeU128(value) {\n    this.expandBuffer(16);\n    const lowerPart = value & BigInt(\"0xFFFFFFFFFFFFFFFF\");\n    const upperPart = value >> BigInt(64);\n    this.view.setBigUint64(this.offset, lowerPart, true);\n    this.view.setBigUint64(this.offset + 8, upperPart, true);\n    this.offset += 16;\n  }\n  writeI128(value) {\n    this.expandBuffer(16);\n    const lowerPart = value & BigInt(\"0xFFFFFFFFFFFFFFFF\");\n    const upperPart = value >> BigInt(64);\n    this.view.setBigInt64(this.offset, lowerPart, true);\n    this.view.setBigInt64(this.offset + 8, upperPart, true);\n    this.offset += 16;\n  }\n  writeU256(value) {\n    this.expandBuffer(32);\n    const low_64_mask = BigInt(\"0xFFFFFFFFFFFFFFFF\");\n    const p0 = value & low_64_mask;\n    const p1 = value >> BigInt(64 * 1) & low_64_mask;\n    const p2 = value >> BigInt(64 * 2) & low_64_mask;\n    const p3 = value >> BigInt(64 * 3);\n    this.view.setBigUint64(this.offset + 8 * 0, p0, true);\n    this.view.setBigUint64(this.offset + 8 * 1, p1, true);\n    this.view.setBigUint64(this.offset + 8 * 2, p2, true);\n    this.view.setBigUint64(this.offset + 8 * 3, p3, true);\n    this.offset += 32;\n  }\n  writeI256(value) {\n    this.expandBuffer(32);\n    const low_64_mask = BigInt(\"0xFFFFFFFFFFFFFFFF\");\n    const p0 = value & low_64_mask;\n    const p1 = value >> BigInt(64 * 1) & low_64_mask;\n    const p2 = value >> BigInt(64 * 2) & low_64_mask;\n    const p3 = value >> BigInt(64 * 3);\n    this.view.setBigUint64(this.offset + 8 * 0, p0, true);\n    this.view.setBigUint64(this.offset + 8 * 1, p1, true);\n    this.view.setBigUint64(this.offset + 8 * 2, p2, true);\n    this.view.setBigInt64(this.offset + 8 * 3, p3, true);\n    this.offset += 32;\n  }\n  writeF32(value) {\n    this.expandBuffer(4);\n    this.view.setFloat32(this.offset, value, true);\n    this.offset += 4;\n  }\n  writeF64(value) {\n    this.expandBuffer(8);\n    this.view.setFloat64(this.offset, value, true);\n    this.offset += 8;\n  }\n  writeString(value) {\n    const encoder = new TextEncoder();\n    const encodedString = encoder.encode(value);\n    this.writeUInt8Array(encodedString);\n  }\n};\n\n// src/lib/util.ts\nfunction uint8ArrayToHexString(array) {\n  return Array.prototype.map.call(array.reverse(), (x) => (\"00\" + x.toString(16)).slice(-2)).join(\"\");\n}\nfunction uint8ArrayToU128(array) {\n  if (array.length != 16) {\n    throw new Error(`Uint8Array is not 16 bytes long: ${array}`);\n  }\n  return new BinaryReader(array).readU128();\n}\nfunction uint8ArrayToU256(array) {\n  if (array.length != 32) {\n    throw new Error(`Uint8Array is not 32 bytes long: [${array}]`);\n  }\n  return new BinaryReader(array).readU256();\n}\nfunction hexStringToUint8Array(str) {\n  if (str.startsWith(\"0x\")) {\n    str = str.slice(2);\n  }\n  const matches = str.match(/.{1,2}/g) || [];\n  const data = Uint8Array.from(\n    matches.map((byte) => parseInt(byte, 16))\n  );\n  return data.reverse();\n}\nfunction hexStringToU128(str) {\n  return uint8ArrayToU128(hexStringToUint8Array(str));\n}\nfunction hexStringToU256(str) {\n  return uint8ArrayToU256(hexStringToUint8Array(str));\n}\nfunction u128ToUint8Array(data) {\n  const writer = new BinaryWriter(16);\n  writer.writeU128(data);\n  return writer.getBuffer();\n}\nfunction u128ToHexString(data) {\n  return uint8ArrayToHexString(u128ToUint8Array(data));\n}\nfunction u256ToUint8Array(data) {\n  const writer = new BinaryWriter(32);\n  writer.writeU256(data);\n  return writer.getBuffer();\n}\nfunction u256ToHexString(data) {\n  return uint8ArrayToHexString(u256ToUint8Array(data));\n}\nfunction toPascalCase(s) {\n  const str = toCamelCase(s);\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\nfunction toCamelCase(s) {\n  const str = s.replace(/[-_]+/g, \"_\").replace(/_([a-zA-Z0-9])/g, (_, c) => c.toUpperCase());\n  return str.charAt(0).toLowerCase() + str.slice(1);\n}\nfunction bsatnBaseSize(typespace, ty) {\n  const assumedArrayLength = 4;\n  while (ty.tag === \"Ref\") ty = typespace.types[ty.value];\n  if (ty.tag === \"Product\") {\n    let sum = 0;\n    for (const { algebraicType: elem } of ty.value.elements) {\n      sum += bsatnBaseSize(typespace, elem);\n    }\n    return sum;\n  } else if (ty.tag === \"Sum\") {\n    let min = Infinity;\n    for (const { algebraicType: vari } of ty.value.variants) {\n      const vSize = bsatnBaseSize(typespace, vari);\n      if (vSize < min) min = vSize;\n    }\n    if (min === Infinity) min = 0;\n    return 4 + min;\n  } else if (ty.tag == \"Array\") {\n    return 4 + assumedArrayLength * bsatnBaseSize(typespace, ty.value);\n  }\n  return {\n    String: 4 + assumedArrayLength,\n    Sum: 1,\n    Bool: 1,\n    I8: 1,\n    U8: 1,\n    I16: 2,\n    U16: 2,\n    I32: 4,\n    U32: 4,\n    F32: 4,\n    I64: 8,\n    U64: 8,\n    F64: 8,\n    I128: 16,\n    U128: 16,\n    I256: 32,\n    U256: 32\n  }[ty.tag];\n}\nvar hasOwn = Object.hasOwn;\n\n// src/lib/connection_id.ts\nvar ConnectionId = class _ConnectionId {\n  __connection_id__;\n  /**\n   * Creates a new `ConnectionId`.\n   */\n  constructor(data) {\n    this.__connection_id__ = data;\n  }\n  /**\n   * Get the algebraic type representation of the {@link ConnectionId} type.\n   * @returns The algebraic type representation of the type.\n   */\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [\n        { name: \"__connection_id__\", algebraicType: AlgebraicType.U128 }\n      ]\n    });\n  }\n  isZero() {\n    return this.__connection_id__ === BigInt(0);\n  }\n  static nullIfZero(addr) {\n    if (addr.isZero()) {\n      return null;\n    } else {\n      return addr;\n    }\n  }\n  static random() {\n    function randomU8() {\n      return Math.floor(Math.random() * 255);\n    }\n    let result = BigInt(0);\n    for (let i = 0; i < 16; i++) {\n      result = result << BigInt(8) | BigInt(randomU8());\n    }\n    return new _ConnectionId(result);\n  }\n  /**\n   * Compare two connection IDs for equality.\n   */\n  isEqual(other) {\n    return this.__connection_id__ == other.__connection_id__;\n  }\n  /**\n   * Check if two connection IDs are equal.\n   */\n  equals(other) {\n    return this.isEqual(other);\n  }\n  /**\n   * Print the connection ID as a hexadecimal string.\n   */\n  toHexString() {\n    return u128ToHexString(this.__connection_id__);\n  }\n  /**\n   * Convert the connection ID to a Uint8Array.\n   */\n  toUint8Array() {\n    return u128ToUint8Array(this.__connection_id__);\n  }\n  /**\n   * Parse a connection ID from a hexadecimal string.\n   */\n  static fromString(str) {\n    return new _ConnectionId(hexStringToU128(str));\n  }\n  static fromStringOrNull(str) {\n    const addr = _ConnectionId.fromString(str);\n    if (addr.isZero()) {\n      return null;\n    } else {\n      return addr;\n    }\n  }\n};\n\n// src/lib/identity.ts\nvar Identity = class _Identity {\n  __identity__;\n  /**\n   * Creates a new `Identity`.\n   *\n   * `data` can be a hexadecimal string or a `bigint`.\n   */\n  constructor(data) {\n    this.__identity__ = typeof data === \"string\" ? hexStringToU256(data) : data;\n  }\n  /**\n   * Get the algebraic type representation of the {@link Identity} type.\n   * @returns The algebraic type representation of the type.\n   */\n  static getAlgebraicType() {\n    return AlgebraicType.Product({\n      elements: [{ name: \"__identity__\", algebraicType: AlgebraicType.U256 }]\n    });\n  }\n  /**\n   * Check if two identities are equal.\n   */\n  isEqual(other) {\n    return this.toHexString() === other.toHexString();\n  }\n  /**\n   * Check if two identities are equal.\n   */\n  equals(other) {\n    return this.isEqual(other);\n  }\n  /**\n   * Print the identity as a hexadecimal string.\n   */\n  toHexString() {\n    return u256ToHexString(this.__identity__);\n  }\n  /**\n   * Convert the address to a Uint8Array.\n   */\n  toUint8Array() {\n    return u256ToUint8Array(this.__identity__);\n  }\n  /**\n   * Parse an Identity from a hexadecimal string.\n   */\n  static fromString(str) {\n    return new _Identity(str);\n  }\n  /**\n   * Zero identity (0x0000000000000000000000000000000000000000000000000000000000000000)\n   */\n  static zero() {\n    return new _Identity(0n);\n  }\n  toString() {\n    return this.toHexString();\n  }\n};\n\n// src/lib/algebraic_type.ts\nvar SERIALIZERS = /* @__PURE__ */ new Map();\nvar DESERIALIZERS = /* @__PURE__ */ new Map();\nvar AlgebraicType = {\n  Ref: (value) => ({ tag: \"Ref\", value }),\n  Sum: (value) => ({\n    tag: \"Sum\",\n    value\n  }),\n  Product: (value) => ({\n    tag: \"Product\",\n    value\n  }),\n  Array: (value) => ({\n    tag: \"Array\",\n    value\n  }),\n  String: { tag: \"String\" },\n  Bool: { tag: \"Bool\" },\n  I8: { tag: \"I8\" },\n  U8: { tag: \"U8\" },\n  I16: { tag: \"I16\" },\n  U16: { tag: \"U16\" },\n  I32: { tag: \"I32\" },\n  U32: { tag: \"U32\" },\n  I64: { tag: \"I64\" },\n  U64: { tag: \"U64\" },\n  I128: { tag: \"I128\" },\n  U128: { tag: \"U128\" },\n  I256: { tag: \"I256\" },\n  U256: { tag: \"U256\" },\n  F32: { tag: \"F32\" },\n  F64: { tag: \"F64\" },\n  makeSerializer(ty, typespace) {\n    if (ty.tag === \"Ref\") {\n      if (!typespace)\n        throw new Error(\"cannot serialize refs without a typespace\");\n      while (ty.tag === \"Ref\") ty = typespace.types[ty.value];\n    }\n    switch (ty.tag) {\n      case \"Product\":\n        return ProductType.makeSerializer(ty.value, typespace);\n      case \"Sum\":\n        return SumType.makeSerializer(ty.value, typespace);\n      case \"Array\":\n        if (ty.value.tag === \"U8\") {\n          return serializeUint8Array;\n        } else {\n          const serialize = AlgebraicType.makeSerializer(ty.value, typespace);\n          return (writer, value) => {\n            writer.writeU32(value.length);\n            for (const elem of value) {\n              serialize(writer, elem);\n            }\n          };\n        }\n      default:\n        return primitiveSerializers[ty.tag];\n    }\n  },\n  /** @deprecated Use `makeSerializer` instead. */\n  serializeValue(writer, ty, value, typespace) {\n    AlgebraicType.makeSerializer(ty, typespace)(writer, value);\n  },\n  makeDeserializer(ty, typespace) {\n    if (ty.tag === \"Ref\") {\n      if (!typespace)\n        throw new Error(\"cannot deserialize refs without a typespace\");\n      while (ty.tag === \"Ref\") ty = typespace.types[ty.value];\n    }\n    switch (ty.tag) {\n      case \"Product\":\n        return ProductType.makeDeserializer(ty.value, typespace);\n      case \"Sum\":\n        return SumType.makeDeserializer(ty.value, typespace);\n      case \"Array\":\n        if (ty.value.tag === \"U8\") {\n          return deserializeUint8Array;\n        } else {\n          const deserialize = AlgebraicType.makeDeserializer(\n            ty.value,\n            typespace\n          );\n          return (reader) => {\n            const length = reader.readU32();\n            const result = Array(length);\n            for (let i = 0; i < length; i++) {\n              result[i] = deserialize(reader);\n            }\n            return result;\n          };\n        }\n      default:\n        return primitiveDeserializers[ty.tag];\n    }\n  },\n  /** @deprecated Use `makeDeserializer` instead. */\n  deserializeValue(reader, ty, typespace) {\n    return AlgebraicType.makeDeserializer(ty, typespace)(reader);\n  },\n  /**\n   * Convert a value of the algebraic type into something that can be used as a key in a map.\n   * There are no guarantees about being able to order it.\n   * This is only guaranteed to be comparable to other values of the same type.\n   * @param value A value of the algebraic type\n   * @returns Something that can be used as a key in a map.\n   */\n  intoMapKey: function(ty, value) {\n    switch (ty.tag) {\n      case \"U8\":\n      case \"U16\":\n      case \"U32\":\n      case \"U64\":\n      case \"U128\":\n      case \"U256\":\n      case \"I8\":\n      case \"I16\":\n      case \"I32\":\n      case \"I64\":\n      case \"I128\":\n      case \"I256\":\n      case \"F32\":\n      case \"F64\":\n      case \"String\":\n      case \"Bool\":\n        return value;\n      case \"Product\":\n        return ProductType.intoMapKey(ty.value, value);\n      default: {\n        const writer = new BinaryWriter(10);\n        AlgebraicType.serializeValue(writer, ty, value);\n        return writer.toBase64();\n      }\n    }\n  }\n};\nfunction bindCall(f) {\n  return Function.prototype.call.bind(f);\n}\nvar primitiveSerializers = {\n  Bool: bindCall(BinaryWriter.prototype.writeBool),\n  I8: bindCall(BinaryWriter.prototype.writeI8),\n  U8: bindCall(BinaryWriter.prototype.writeU8),\n  I16: bindCall(BinaryWriter.prototype.writeI16),\n  U16: bindCall(BinaryWriter.prototype.writeU16),\n  I32: bindCall(BinaryWriter.prototype.writeI32),\n  U32: bindCall(BinaryWriter.prototype.writeU32),\n  I64: bindCall(BinaryWriter.prototype.writeI64),\n  U64: bindCall(BinaryWriter.prototype.writeU64),\n  I128: bindCall(BinaryWriter.prototype.writeI128),\n  U128: bindCall(BinaryWriter.prototype.writeU128),\n  I256: bindCall(BinaryWriter.prototype.writeI256),\n  U256: bindCall(BinaryWriter.prototype.writeU256),\n  F32: bindCall(BinaryWriter.prototype.writeF32),\n  F64: bindCall(BinaryWriter.prototype.writeF64),\n  String: bindCall(BinaryWriter.prototype.writeString)\n};\nObject.freeze(primitiveSerializers);\nvar serializeUint8Array = bindCall(BinaryWriter.prototype.writeUInt8Array);\nvar primitiveDeserializers = {\n  Bool: bindCall(BinaryReader.prototype.readBool),\n  I8: bindCall(BinaryReader.prototype.readI8),\n  U8: bindCall(BinaryReader.prototype.readU8),\n  I16: bindCall(BinaryReader.prototype.readI16),\n  U16: bindCall(BinaryReader.prototype.readU16),\n  I32: bindCall(BinaryReader.prototype.readI32),\n  U32: bindCall(BinaryReader.prototype.readU32),\n  I64: bindCall(BinaryReader.prototype.readI64),\n  U64: bindCall(BinaryReader.prototype.readU64),\n  I128: bindCall(BinaryReader.prototype.readI128),\n  U128: bindCall(BinaryReader.prototype.readU128),\n  I256: bindCall(BinaryReader.prototype.readI256),\n  U256: bindCall(BinaryReader.prototype.readU256),\n  F32: bindCall(BinaryReader.prototype.readF32),\n  F64: bindCall(BinaryReader.prototype.readF64),\n  String: bindCall(BinaryReader.prototype.readString)\n};\nObject.freeze(primitiveDeserializers);\nvar deserializeUint8Array = bindCall(BinaryReader.prototype.readUInt8Array);\nvar primitiveSizes = {\n  Bool: 1,\n  I8: 1,\n  U8: 1,\n  I16: 2,\n  U16: 2,\n  I32: 4,\n  U32: 4,\n  I64: 8,\n  U64: 8,\n  I128: 16,\n  U128: 16,\n  I256: 32,\n  U256: 32,\n  F32: 4,\n  F64: 8\n};\nvar fixedSizePrimitives = new Set(Object.keys(primitiveSizes));\nvar isFixedSizeProduct = (ty) => ty.elements.every(\n  ({ algebraicType }) => fixedSizePrimitives.has(algebraicType.tag)\n);\nvar productSize = (ty) => ty.elements.reduce(\n  (acc, { algebraicType }) => acc + primitiveSizes[algebraicType.tag],\n  0\n);\nvar primitiveJSName = {\n  Bool: \"Uint8\",\n  I8: \"Int8\",\n  U8: \"Uint8\",\n  I16: \"Int16\",\n  U16: \"Uint16\",\n  I32: \"Int32\",\n  U32: \"Uint32\",\n  I64: \"BigInt64\",\n  U64: \"BigUint64\",\n  F32: \"Float32\",\n  F64: \"Float64\"\n};\nvar specialProductDeserializers = {\n  __time_duration_micros__: (reader) => new TimeDuration(reader.readI64()),\n  __timestamp_micros_since_unix_epoch__: (reader) => new Timestamp(reader.readI64()),\n  __identity__: (reader) => new Identity(reader.readU256()),\n  __connection_id__: (reader) => new ConnectionId(reader.readU128()),\n  __uuid__: (reader) => new Uuid(reader.readU128())\n};\nObject.freeze(specialProductDeserializers);\nvar unitDeserializer = () => ({});\nvar getElementInitializer = (element) => {\n  let init;\n  switch (element.algebraicType.tag) {\n    case \"String\":\n      init = \"''\";\n      break;\n    case \"Bool\":\n      init = \"false\";\n      break;\n    case \"I8\":\n    case \"U8\":\n    case \"I16\":\n    case \"U16\":\n    case \"I32\":\n    case \"U32\":\n      init = \"0\";\n      break;\n    case \"I64\":\n    case \"U64\":\n    case \"I128\":\n    case \"U128\":\n    case \"I256\":\n    case \"U256\":\n      init = \"0n\";\n      break;\n    case \"F32\":\n    case \"F64\":\n      init = \"0.0\";\n      break;\n    default:\n      init = \"undefined\";\n  }\n  return `${element.name}: ${init}`;\n};\nvar ProductType = {\n  makeSerializer(ty, typespace) {\n    let serializer = SERIALIZERS.get(ty);\n    if (serializer != null) return serializer;\n    if (isFixedSizeProduct(ty)) {\n      const size = productSize(ty);\n      const body2 = `\"use strict\";\nwriter.expandBuffer(${size});\nconst view = writer.view;\n${ty.elements.map(\n        ({ name, algebraicType: { tag } }) => tag in primitiveJSName ? `view.set${primitiveJSName[tag]}(writer.offset, value.${name}, ${primitiveSizes[tag] > 1 ? \"true\" : \"\"});\nwriter.offset += ${primitiveSizes[tag]};` : `writer.write${tag}(value.${name});`\n      ).join(\"\\n\")}`;\n      serializer = Function(\"writer\", \"value\", body2);\n      SERIALIZERS.set(ty, serializer);\n      return serializer;\n    }\n    const serializers = {};\n    const body = '\"use strict\";\\n' + ty.elements.map(\n      (element) => `this.${element.name}(writer, value.${element.name});`\n    ).join(\"\\n\");\n    serializer = Function(\"writer\", \"value\", body).bind(\n      serializers\n    );\n    SERIALIZERS.set(ty, serializer);\n    for (const { name, algebraicType } of ty.elements) {\n      serializers[name] = AlgebraicType.makeSerializer(\n        algebraicType,\n        typespace\n      );\n    }\n    Object.freeze(serializers);\n    return serializer;\n  },\n  /** @deprecated Use `makeSerializer` instead. */\n  serializeValue(writer, ty, value, typespace) {\n    ProductType.makeSerializer(ty, typespace)(writer, value);\n  },\n  makeDeserializer(ty, typespace) {\n    switch (ty.elements.length) {\n      case 0:\n        return unitDeserializer;\n      case 1: {\n        const fieldName = ty.elements[0].name;\n        if (hasOwn(specialProductDeserializers, fieldName))\n          return specialProductDeserializers[fieldName];\n      }\n    }\n    let deserializer = DESERIALIZERS.get(ty);\n    if (deserializer != null) return deserializer;\n    if (isFixedSizeProduct(ty)) {\n      const body = `\"use strict\";\nconst result = { ${ty.elements.map(getElementInitializer).join(\", \")} };\nconst view = reader.view;\n${ty.elements.map(\n        ({ name, algebraicType: { tag } }) => tag in primitiveJSName ? tag === \"Bool\" ? `result.${name} = view.getUint8(reader.offset) !== 0;\nreader.offset += 1;` : `result.${name} = view.get${primitiveJSName[tag]}(reader.offset, ${primitiveSizes[tag] > 1 ? \"true\" : \"\"});\nreader.offset += ${primitiveSizes[tag]};` : `result.${name} = reader.read${tag}();`\n      ).join(\"\\n\")}\nreturn result;`;\n      deserializer = Function(\"reader\", body);\n      DESERIALIZERS.set(ty, deserializer);\n      return deserializer;\n    }\n    const deserializers = {};\n    deserializer = Function(\n      \"reader\",\n      `\"use strict\";\nconst result = { ${ty.elements.map(getElementInitializer).join(\", \")} };\n${ty.elements.map(({ name }) => `result.${name} = this.${name}(reader);`).join(\"\\n\")}\nreturn result;`\n    ).bind(deserializers);\n    DESERIALIZERS.set(ty, deserializer);\n    for (const { name, algebraicType } of ty.elements) {\n      deserializers[name] = AlgebraicType.makeDeserializer(\n        algebraicType,\n        typespace\n      );\n    }\n    Object.freeze(deserializers);\n    return deserializer;\n  },\n  /** @deprecated Use `makeDeserializer` instead. */\n  deserializeValue(reader, ty, typespace) {\n    return ProductType.makeDeserializer(ty, typespace)(reader);\n  },\n  intoMapKey(ty, value) {\n    if (ty.elements.length === 1) {\n      const fieldName = ty.elements[0].name;\n      if (hasOwn(specialProductDeserializers, fieldName)) {\n        return value[fieldName];\n      }\n    }\n    const writer = new BinaryWriter(10);\n    AlgebraicType.serializeValue(writer, AlgebraicType.Product(ty), value);\n    return writer.toBase64();\n  }\n};\nvar SumType = {\n  makeSerializer(ty, typespace) {\n    if (ty.variants.length == 2 && ty.variants[0].name === \"some\" && ty.variants[1].name === \"none\") {\n      const serialize = AlgebraicType.makeSerializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      return (writer, value) => {\n        if (value !== null && value !== void 0) {\n          writer.writeByte(0);\n          serialize(writer, value);\n        } else {\n          writer.writeByte(1);\n        }\n      };\n    } else if (ty.variants.length == 2 && ty.variants[0].name === \"ok\" && ty.variants[1].name === \"err\") {\n      const serializeOk = AlgebraicType.makeSerializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      const serializeErr = AlgebraicType.makeSerializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      return (writer, value) => {\n        if (\"ok\" in value) {\n          writer.writeU8(0);\n          serializeOk(writer, value.ok);\n        } else if (\"err\" in value) {\n          writer.writeU8(1);\n          serializeErr(writer, value.err);\n        } else {\n          throw new TypeError(\n            \"could not serialize result: object had neither a `ok` nor an `err` field\"\n          );\n        }\n      };\n    } else {\n      let serializer = SERIALIZERS.get(ty);\n      if (serializer != null) return serializer;\n      const serializers = {};\n      const body = `switch (value.tag) {\n${ty.variants.map(\n        ({ name }, i) => `  case ${JSON.stringify(name)}:\n    writer.writeByte(${i});\n    return this.${name}(writer, value.value);`\n      ).join(\"\\n\")}\n  default:\n    throw new TypeError(\n      \\`Could not serialize sum type; unknown tag \\${value.tag}\\`\n    )\n}\n`;\n      serializer = Function(\"writer\", \"value\", body).bind(\n        serializers\n      );\n      SERIALIZERS.set(ty, serializer);\n      for (const { name, algebraicType } of ty.variants) {\n        serializers[name] = AlgebraicType.makeSerializer(\n          algebraicType,\n          typespace\n        );\n      }\n      Object.freeze(serializers);\n      return serializer;\n    }\n  },\n  /** @deprecated Use `makeSerializer` instead. */\n  serializeValue(writer, ty, value, typespace) {\n    SumType.makeSerializer(ty, typespace)(writer, value);\n  },\n  makeDeserializer(ty, typespace) {\n    if (ty.variants.length == 2 && ty.variants[0].name === \"some\" && ty.variants[1].name === \"none\") {\n      const deserialize = AlgebraicType.makeDeserializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      return (reader) => {\n        const tag = reader.readU8();\n        if (tag === 0) {\n          return deserialize(reader);\n        } else if (tag === 1) {\n          return void 0;\n        } else {\n          throw `Can't deserialize an option type, couldn't find ${tag} tag`;\n        }\n      };\n    } else if (ty.variants.length == 2 && ty.variants[0].name === \"ok\" && ty.variants[1].name === \"err\") {\n      const deserializeOk = AlgebraicType.makeDeserializer(\n        ty.variants[0].algebraicType,\n        typespace\n      );\n      const deserializeErr = AlgebraicType.makeDeserializer(\n        ty.variants[1].algebraicType,\n        typespace\n      );\n      return (reader) => {\n        const tag = reader.readByte();\n        if (tag === 0) {\n          return { ok: deserializeOk(reader) };\n        } else if (tag === 1) {\n          return { err: deserializeErr(reader) };\n        } else {\n          throw `Can't deserialize a result type, couldn't find ${tag} tag`;\n        }\n      };\n    } else {\n      let deserializer = DESERIALIZERS.get(ty);\n      if (deserializer != null) return deserializer;\n      const deserializers = {};\n      deserializer = Function(\n        \"reader\",\n        `switch (reader.readU8()) {\n${ty.variants.map(\n          ({ name }, i) => `case ${i}: return { tag: ${JSON.stringify(name)}, value: this.${name}(reader) };`\n        ).join(\"\\n\")} }`\n      ).bind(deserializers);\n      DESERIALIZERS.set(ty, deserializer);\n      for (const { name, algebraicType } of ty.variants) {\n        deserializers[name] = AlgebraicType.makeDeserializer(\n          algebraicType,\n          typespace\n        );\n      }\n      Object.freeze(deserializers);\n      return deserializer;\n    }\n  },\n  /** @deprecated Use `makeDeserializer` instead. */\n  deserializeValue(reader, ty, typespace) {\n    return SumType.makeDeserializer(ty, typespace)(reader);\n  }\n};\n\n// src/lib/option.ts\nvar Option = {\n  getAlgebraicType(innerType) {\n    return AlgebraicType.Sum({\n      variants: [\n        { name: \"some\", algebraicType: innerType },\n        {\n          name: \"none\",\n          algebraicType: AlgebraicType.Product({ elements: [] })\n        }\n      ]\n    });\n  }\n};\n\n// src/lib/result.ts\nvar Result = {\n  getAlgebraicType(okType, errType) {\n    return AlgebraicType.Sum({\n      variants: [\n        { name: \"ok\", algebraicType: okType },\n        { name: \"err\", algebraicType: errType }\n      ]\n    });\n  }\n};\n\n// src/lib/schedule_at.ts\nvar ScheduleAt = {\n  interval(value) {\n    return Interval(value);\n  },\n  time(value) {\n    return Time(value);\n  },\n  getAlgebraicType() {\n    return AlgebraicType.Sum({\n      variants: [\n        {\n          name: \"Interval\",\n          algebraicType: TimeDuration.getAlgebraicType()\n        },\n        { name: \"Time\", algebraicType: Timestamp.getAlgebraicType() }\n      ]\n    });\n  },\n  isScheduleAt(algebraicType) {\n    if (algebraicType.tag !== \"Sum\") {\n      return false;\n    }\n    const variants = algebraicType.value.variants;\n    if (variants.length !== 2) {\n      return false;\n    }\n    const intervalVariant = variants.find((v) => v.name === \"Interval\");\n    const timeVariant = variants.find((v) => v.name === \"Time\");\n    if (!intervalVariant || !timeVariant) {\n      return false;\n    }\n    return TimeDuration.isTimeDuration(intervalVariant.algebraicType) && Timestamp.isTimestamp(timeVariant.algebraicType);\n  }\n};\nvar Interval = (micros) => ({\n  tag: \"Interval\",\n  value: new TimeDuration(micros)\n});\nvar Time = (microsSinceUnixEpoch) => ({\n  tag: \"Time\",\n  value: new Timestamp(microsSinceUnixEpoch)\n});\nvar schedule_at_default = ScheduleAt;\n\n// src/lib/type_util.ts\nfunction set(x, t2) {\n  return { ...x, ...t2 };\n}\n\n// src/lib/type_builders.ts\nvar TypeBuilder = class {\n  /**\n   * The TypeScript phantom type. This is not stored at runtime,\n   * but is visible to the compiler\n   */\n  type;\n  /**\n   * The SpacetimeDB algebraic type (run‑time value). In addition to storing\n   * the runtime representation of the `AlgebraicType`, it also captures\n   * the TypeScript type information of the `AlgebraicType`. That is to say\n   * the value is not merely an `AlgebraicType`, but is constructed to be\n   * the corresponding concrete `AlgebraicType` for the TypeScript type `Type`.\n   *\n   * e.g. `string` corresponds to `AlgebraicType.String`\n   */\n  algebraicType;\n  constructor(algebraicType) {\n    this.algebraicType = algebraicType;\n  }\n  optional() {\n    return new OptionBuilder(this);\n  }\n  serialize(writer, value) {\n    const serialize = this.serialize = AlgebraicType.makeSerializer(\n      this.algebraicType\n    );\n    serialize(writer, value);\n  }\n  deserialize(reader) {\n    const deserialize = this.deserialize = AlgebraicType.makeDeserializer(\n      this.algebraicType\n    );\n    return deserialize(reader);\n  }\n};\nvar U8Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U8);\n  }\n  index(algorithm = \"btree\") {\n    return new U8ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U8ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new U8ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U8ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U8ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U8ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U16Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U16);\n  }\n  index(algorithm = \"btree\") {\n    return new U16ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U16ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new U16ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U16ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U16ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U16ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U32Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U32);\n  }\n  index(algorithm = \"btree\") {\n    return new U32ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U32ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new U32ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U32ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U32ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U32ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U64Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U64);\n  }\n  index(algorithm = \"btree\") {\n    return new U64ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U64ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new U64ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U64ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U64ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U64ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U128Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U128);\n  }\n  index(algorithm = \"btree\") {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U128ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U128ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar U256Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.U256);\n  }\n  index(algorithm = \"btree\") {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new U256ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new U256ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I8Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I8);\n  }\n  index(algorithm = \"btree\") {\n    return new I8ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I8ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new I8ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I8ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I8ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I8ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I16Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I16);\n  }\n  index(algorithm = \"btree\") {\n    return new I16ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I16ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new I16ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I16ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I16ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I16ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I32Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I32);\n  }\n  index(algorithm = \"btree\") {\n    return new I32ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I32ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new I32ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I32ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I32ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I32ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I64Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I64);\n  }\n  index(algorithm = \"btree\") {\n    return new I64ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I64ColumnBuilder(this, set(defaultMetadata, { isUnique: true }));\n  }\n  primaryKey() {\n    return new I64ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I64ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I64ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I64ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I128Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I128);\n  }\n  index(algorithm = \"btree\") {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I128ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I128ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar I256Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.I256);\n  }\n  index(algorithm = \"btree\") {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new I256ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new I256ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar F32Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.F32);\n  }\n  default(value) {\n    return new F32ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new F32ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar F64Builder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.F64);\n  }\n  default(value) {\n    return new F64ColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new F64ColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar BoolBuilder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.Bool);\n  }\n  index(algorithm = \"btree\") {\n    return new BoolColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new BoolColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new BoolColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new BoolColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new BoolColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar StringBuilder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.String);\n  }\n  index(algorithm = \"btree\") {\n    return new StringColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new StringColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new StringColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new StringColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new StringColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ArrayBuilder = class extends TypeBuilder {\n  element;\n  constructor(element) {\n    super(AlgebraicType.Array(element.algebraicType));\n    this.element = element;\n  }\n  default(value) {\n    return new ArrayColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ArrayColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ByteArrayBuilder = class extends TypeBuilder {\n  constructor() {\n    super(AlgebraicType.Array(AlgebraicType.U8));\n  }\n  default(value) {\n    return new ByteArrayColumnBuilder(\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ByteArrayColumnBuilder(set(defaultMetadata, { name }));\n  }\n};\nvar OptionBuilder = class extends TypeBuilder {\n  value;\n  constructor(value) {\n    super(Option.getAlgebraicType(value.algebraicType));\n    this.value = value;\n  }\n  default(value) {\n    return new OptionColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new OptionColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ProductBuilder = class extends TypeBuilder {\n  typeName;\n  elements;\n  constructor(elements, name) {\n    function elementsArrayFromElementsObj(obj) {\n      return Object.keys(obj).map((key) => ({\n        name: key,\n        // Lazily resolve the underlying object's algebraicType.\n        // This will call obj[key].algebraicType only when someone\n        // actually reads this property.\n        get algebraicType() {\n          return obj[key].algebraicType;\n        }\n      }));\n    }\n    super(\n      AlgebraicType.Product({\n        elements: elementsArrayFromElementsObj(elements)\n      })\n    );\n    this.typeName = name;\n    this.elements = elements;\n  }\n  default(value) {\n    return new ProductColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ProductColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ResultBuilder = class extends TypeBuilder {\n  ok;\n  err;\n  constructor(ok, err) {\n    super(Result.getAlgebraicType(ok.algebraicType, err.algebraicType));\n    this.ok = ok;\n    this.err = err;\n  }\n  default(value) {\n    return new ResultColumnBuilder(this, set(defaultMetadata, { defaultValue: value }));\n  }\n};\nvar UnitBuilder = class extends TypeBuilder {\n  constructor() {\n    super({ tag: \"Product\", value: { elements: [] } });\n  }\n};\nvar RowBuilder = class extends TypeBuilder {\n  row;\n  typeName;\n  constructor(row, name) {\n    const mappedRow = Object.fromEntries(\n      Object.entries(row).map(([colName, builder]) => [\n        colName,\n        builder instanceof ColumnBuilder ? builder : new ColumnBuilder(builder, {})\n      ])\n    );\n    const elements = Object.keys(mappedRow).map((name2) => ({\n      name: name2,\n      get algebraicType() {\n        return mappedRow[name2].typeBuilder.algebraicType;\n      }\n    }));\n    super(AlgebraicType.Product({ elements }));\n    this.row = mappedRow;\n    this.typeName = name;\n  }\n};\nvar SumBuilderImpl = class extends TypeBuilder {\n  variants;\n  typeName;\n  constructor(variants, name) {\n    function variantsArrayFromVariantsObj(variants2) {\n      return Object.keys(variants2).map((key) => ({\n        name: key,\n        // Lazily resolve the underlying object's algebraicType.\n        // This will call obj[key].algebraicType only when someone\n        // actually reads this property.\n        get algebraicType() {\n          return variants2[key].algebraicType;\n        }\n      }));\n    }\n    super(\n      AlgebraicType.Sum({\n        variants: variantsArrayFromVariantsObj(variants)\n      })\n    );\n    this.variants = variants;\n    this.typeName = name;\n    for (const key of Object.keys(variants)) {\n      const desc = Object.getOwnPropertyDescriptor(variants, key);\n      const isAccessor = !!desc && (typeof desc.get === \"function\" || typeof desc.set === \"function\");\n      let isUnit2 = false;\n      if (!isAccessor) {\n        const variant = variants[key];\n        isUnit2 = variant instanceof UnitBuilder;\n      }\n      if (isUnit2) {\n        const constant = this.create(key);\n        Object.defineProperty(this, key, {\n          value: constant,\n          writable: false,\n          enumerable: true,\n          configurable: false\n        });\n      } else {\n        const fn = ((value) => this.create(key, value));\n        Object.defineProperty(this, key, {\n          value: fn,\n          writable: false,\n          enumerable: true,\n          configurable: false\n        });\n      }\n    }\n  }\n  create(tag, value) {\n    return value === void 0 ? { tag } : { tag, value };\n  }\n  default(value) {\n    return new SumColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new SumColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar SumBuilder = SumBuilderImpl;\nvar SimpleSumBuilderImpl = class extends SumBuilderImpl {\n  index(algorithm = \"btree\") {\n    return new SimpleSumColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  primaryKey() {\n    return new SimpleSumColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n};\nvar SimpleSumBuilder = SimpleSumBuilderImpl;\nvar ScheduleAtBuilder = class extends TypeBuilder {\n  constructor() {\n    super(schedule_at_default.getAlgebraicType());\n  }\n  default(value) {\n    return new ScheduleAtColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ScheduleAtColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar IdentityBuilder = class extends TypeBuilder {\n  constructor() {\n    super(Identity.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new IdentityColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new IdentityColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar ConnectionIdBuilder = class extends TypeBuilder {\n  constructor() {\n    super(ConnectionId.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new ConnectionIdColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new ConnectionIdColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar TimestampBuilder = class extends TypeBuilder {\n  constructor() {\n    super(Timestamp.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new TimestampColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new TimestampColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar TimeDurationBuilder = class extends TypeBuilder {\n  constructor() {\n    super(TimeDuration.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new TimeDurationColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new TimeDurationColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar UuidBuilder = class extends TypeBuilder {\n  constructor() {\n    super(Uuid.getAlgebraicType());\n  }\n  index(algorithm = \"btree\") {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new UuidColumnBuilder(\n      this,\n      set(defaultMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new UuidColumnBuilder(this, set(defaultMetadata, { name }));\n  }\n};\nvar defaultMetadata = {};\nvar ColumnBuilder = class {\n  typeBuilder;\n  columnMetadata;\n  constructor(typeBuilder, metadata) {\n    this.typeBuilder = typeBuilder;\n    this.columnMetadata = metadata;\n  }\n  serialize(writer, value) {\n    this.typeBuilder.serialize(writer, value);\n  }\n  deserialize(reader) {\n    return this.typeBuilder.deserialize(reader);\n  }\n};\nvar U8ColumnBuilder = class _U8ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U16ColumnBuilder = class _U16ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U32ColumnBuilder = class _U32ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U64ColumnBuilder = class _U64ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U128ColumnBuilder = class _U128ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar U256ColumnBuilder = class _U256ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _U256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I8ColumnBuilder = class _I8ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I8ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I16ColumnBuilder = class _I16ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I16ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I32ColumnBuilder = class _I32ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I64ColumnBuilder = class _I64ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I128ColumnBuilder = class _I128ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I128ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar I256ColumnBuilder = class _I256ColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  autoInc() {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isAutoIncrement: true })\n    );\n  }\n  default(value) {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _I256ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar F32ColumnBuilder = class _F32ColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _F32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _F32ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar F64ColumnBuilder = class _F64ColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _F64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _F64ColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar BoolColumnBuilder = class _BoolColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _BoolColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar StringColumnBuilder = class _StringColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _StringColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar ArrayColumnBuilder = class _ArrayColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _ArrayColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _ArrayColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar ByteArrayColumnBuilder = class _ByteArrayColumnBuilder extends ColumnBuilder {\n  constructor(metadata) {\n    super(new TypeBuilder(AlgebraicType.Array(AlgebraicType.U8)), metadata);\n  }\n  default(value) {\n    return new _ByteArrayColumnBuilder(\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _ByteArrayColumnBuilder(set(this.columnMetadata, { name }));\n  }\n};\nvar OptionColumnBuilder = class _OptionColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _OptionColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n  name(name) {\n    return new _OptionColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar ResultColumnBuilder = class _ResultColumnBuilder extends ColumnBuilder {\n  constructor(typeBuilder, metadata) {\n    super(typeBuilder, metadata);\n  }\n  default(value) {\n    return new _ResultColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, {\n        defaultValue: value\n      })\n    );\n  }\n};\nvar ProductColumnBuilder = class _ProductColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _ProductColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _ProductColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar SumColumnBuilder = class _SumColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _SumColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _SumColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar SimpleSumColumnBuilder = class _SimpleSumColumnBuilder extends SumColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _SimpleSumColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  primaryKey() {\n    return new _SimpleSumColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n};\nvar ScheduleAtColumnBuilder = class _ScheduleAtColumnBuilder extends ColumnBuilder {\n  default(value) {\n    return new _ScheduleAtColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _ScheduleAtColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar IdentityColumnBuilder = class _IdentityColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _IdentityColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar ConnectionIdColumnBuilder = class _ConnectionIdColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _ConnectionIdColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar TimestampColumnBuilder = class _TimestampColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _TimestampColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar TimeDurationColumnBuilder = class _TimeDurationColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _TimeDurationColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar UuidColumnBuilder = class _UuidColumnBuilder extends ColumnBuilder {\n  index(algorithm = \"btree\") {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { indexType: algorithm })\n    );\n  }\n  unique() {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isUnique: true })\n    );\n  }\n  primaryKey() {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { isPrimaryKey: true })\n    );\n  }\n  default(value) {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { defaultValue: value })\n    );\n  }\n  name(name) {\n    return new _UuidColumnBuilder(\n      this.typeBuilder,\n      set(this.columnMetadata, { name })\n    );\n  }\n};\nvar RefBuilder = class extends TypeBuilder {\n  ref;\n  /** The phantom type of the pointee of this ref. */\n  __spacetimeType;\n  constructor(ref) {\n    super(AlgebraicType.Ref(ref));\n    this.ref = ref;\n  }\n};\nvar enumImpl = ((nameOrObj, maybeObj) => {\n  let obj = nameOrObj;\n  let name = void 0;\n  if (typeof nameOrObj === \"string\") {\n    if (!maybeObj) {\n      throw new TypeError(\n        \"When providing a name, you must also provide the variants object or array.\"\n      );\n    }\n    obj = maybeObj;\n    name = nameOrObj;\n  }\n  if (Array.isArray(obj)) {\n    const simpleVariantsObj = {};\n    for (const variant of obj) {\n      simpleVariantsObj[variant] = new UnitBuilder();\n    }\n    return new SimpleSumBuilderImpl(simpleVariantsObj, name);\n  }\n  return new SumBuilder(obj, name);\n});\nvar t = {\n  /**\n   * Creates a new `Bool` {@link AlgebraicType} to be used in table definitions\n   * Represented as `boolean` in TypeScript.\n   * @returns A new {@link BoolBuilder} instance\n   */\n  bool: () => new BoolBuilder(),\n  /**\n   * Creates a new `String` {@link AlgebraicType} to be used in table definitions\n   * Represented as `string` in TypeScript.\n   * @returns A new {@link StringBuilder} instance\n   */\n  string: () => new StringBuilder(),\n  /**\n   * Creates a new `F64` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link F64Builder} instance\n   */\n  number: () => new F64Builder(),\n  /**\n   * Creates a new `I8` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link I8Builder} instance\n   */\n  i8: () => new I8Builder(),\n  /**\n   * Creates a new `U8` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link U8Builder} instance\n   */\n  u8: () => new U8Builder(),\n  /**\n   * Creates a new `I16` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link I16Builder} instance\n   */\n  i16: () => new I16Builder(),\n  /**\n   * Creates a new `U16` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link U16Builder} instance\n   */\n  u16: () => new U16Builder(),\n  /**\n   * Creates a new `I32` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link I32Builder} instance\n   */\n  i32: () => new I32Builder(),\n  /**\n   * Creates a new `U32` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link U32Builder} instance\n   */\n  u32: () => new U32Builder(),\n  /**\n   * Creates a new `I64` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link I64Builder} instance\n   */\n  i64: () => new I64Builder(),\n  /**\n   * Creates a new `U64` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link U64Builder} instance\n   */\n  u64: () => new U64Builder(),\n  /**\n   * Creates a new `I128` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link I128Builder} instance\n   */\n  i128: () => new I128Builder(),\n  /**\n   * Creates a new `U128` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link U128Builder} instance\n   */\n  u128: () => new U128Builder(),\n  /**\n   * Creates a new `I256` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link I256Builder} instance\n   */\n  i256: () => new I256Builder(),\n  /**\n   * Creates a new `U256` {@link AlgebraicType} to be used in table definitions\n   * Represented as `bigint` in TypeScript.\n   * @returns A new {@link U256Builder} instance\n   */\n  u256: () => new U256Builder(),\n  /**\n   * Creates a new `F32` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link F32Builder} instance\n   */\n  f32: () => new F32Builder(),\n  /**\n   * Creates a new `F64` {@link AlgebraicType} to be used in table definitions\n   * Represented as `number` in TypeScript.\n   * @returns A new {@link F64Builder} instance\n   */\n  f64: () => new F64Builder(),\n  /**\n   * Creates a new `Product` {@link AlgebraicType} to be used in table definitions. Product types in SpacetimeDB\n   * are essentially the same as objects in JavaScript/TypeScript.\n   * Properties of the object must also be {@link TypeBuilder}s.\n   * Represented as an object with specific properties in TypeScript.\n   *\n   * @param name (optional) A display name for the product type. If omitted, an anonymous product type is created.\n   * @param obj The object defining the properties of the type, whose property\n   * values must be {@link TypeBuilder}s.\n   * @returns A new {@link ProductBuilder} instance.\n   */\n  object: ((nameOrObj, maybeObj) => {\n    if (typeof nameOrObj === \"string\") {\n      if (!maybeObj) {\n        throw new TypeError(\n          \"When providing a name, you must also provide the object.\"\n        );\n      }\n      return new ProductBuilder(maybeObj, nameOrObj);\n    }\n    return new ProductBuilder(nameOrObj, void 0);\n  }),\n  /**\n   * Creates a new `Row` {@link AlgebraicType} to be used in table definitions. Row types in SpacetimeDB\n   * are similar to `Product` types, but are specifically used to define the schema of a table row.\n   * Properties of the object must also be {@link TypeBuilder} or {@link ColumnBuilder}s.\n   *\n   * You can represent a `Row` as either a {@link RowObj} or an {@link RowBuilder} type when\n   * defining a table schema.\n   *\n   * The {@link RowBuilder} type is useful when you want to create a type which can be used anywhere\n   * a {@link TypeBuilder} is accepted, such as in nested objects or arrays, or as the argument\n   * to a scheduled function.\n   *\n   * @param obj The object defining the properties of the row, whose property\n   * values must be {@link TypeBuilder}s or {@link ColumnBuilder}s.\n   * @returns A new {@link RowBuilder} instance\n   */\n  row: ((nameOrObj, maybeObj) => {\n    const [obj, name] = typeof nameOrObj === \"string\" ? [maybeObj, nameOrObj] : [nameOrObj, void 0];\n    return new RowBuilder(obj, name);\n  }),\n  /**\n   * Creates a new `Array` {@link AlgebraicType} to be used in table definitions.\n   * Represented as an array in TypeScript.\n   * @param element The element type of the array, which must be a `TypeBuilder`.\n   * @returns A new {@link ArrayBuilder} instance\n   */\n  array(e) {\n    return new ArrayBuilder(e);\n  },\n  enum: enumImpl,\n  /**\n   * This is a special helper function for conveniently creating `Product` type columns with no fields.\n   *\n   * @returns A new {@link ProductBuilder} instance with no fields.\n   */\n  unit() {\n    return new UnitBuilder();\n  },\n  /**\n   * Creates a lazily-evaluated {@link TypeBuilder}. This is useful for creating\n   * recursive types, such as a tree or linked list.\n   * @param thunk A function that returns a {@link TypeBuilder}.\n   * @returns A proxy {@link TypeBuilder} that evaluates the thunk on first access.\n   */\n  lazy(thunk) {\n    let cached = null;\n    const get = () => cached ??= thunk();\n    const proxy = new Proxy({}, {\n      get(_t, prop, recv) {\n        const target = get();\n        const val = Reflect.get(target, prop, recv);\n        return typeof val === \"function\" ? val.bind(target) : val;\n      },\n      set(_t, prop, value, recv) {\n        return Reflect.set(get(), prop, value, recv);\n      },\n      has(_t, prop) {\n        return prop in get();\n      },\n      ownKeys() {\n        return Reflect.ownKeys(get());\n      },\n      getOwnPropertyDescriptor(_t, prop) {\n        return Object.getOwnPropertyDescriptor(get(), prop);\n      },\n      getPrototypeOf() {\n        return Object.getPrototypeOf(get());\n      }\n    });\n    return proxy;\n  },\n  /**\n   * This is a special helper function for conveniently creating {@link ScheduleAt} type columns.\n   * @returns A new ColumnBuilder instance with the {@link ScheduleAt} type.\n   */\n  scheduleAt: () => {\n    return new ScheduleAtBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Option} type.\n   * You can create a column of the same type by constructing an enum with a `some` and `none` variant.\n   * @param value The type of the value contained in the `some` variant of the `Option`.\n   * @returns A new {@link OptionBuilder} instance with the {@link Option} type.\n   */\n  option(value) {\n    return new OptionBuilder(value);\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Result} type.\n   * You can create a column of the same type by constructing an enum with an `ok` and `err` variant.\n   * @param ok The type of the value contained in the `ok` variant of the `Result`.\n   * @param err The type of the value contained in the `err` variant of the `Result`.\n   * @returns A new {@link ResultBuilder} instance with the {@link Result} type.\n   */\n  result(ok, err) {\n    return new ResultBuilder(ok, err);\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Identity} type.\n   * You can create a column of the same type by constructing an `object` with a single `__identity__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link Identity} type.\n   */\n  identity: () => {\n    return new IdentityBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link ConnectionId} type.\n   * You can create a column of the same type by constructing an `object` with a single `__connection_id__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link ConnectionId} type.\n   */\n  connectionId: () => {\n    return new ConnectionIdBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Timestamp} type.\n   * You can create a column of the same type by constructing an `object` with a single `__timestamp_micros_since_unix_epoch__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link Timestamp} type.\n   */\n  timestamp: () => {\n    return new TimestampBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link TimeDuration} type.\n   * You can create a column of the same type by constructing an `object` with a single `__time_duration_micros__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link TimeDuration} type.\n   */\n  timeDuration: () => {\n    return new TimeDurationBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the {@link Uuid} type.\n   * You can create a column of the same type by constructing an `object` with a single `__uuid__` element.\n   * @returns A new {@link TypeBuilder} instance with the {@link Uuid} type.\n   */\n  uuid: () => {\n    return new UuidBuilder();\n  },\n  /**\n   * This is a convenience method for creating a column with the `ByteArray` type.\n   * You can create a column of the same type by constructing an `array` of `u8`.\n   * The TypeScript representation is {@link Uint8Array}.\n   * @returns A new {@link ByteArrayBuilder} instance with the `ByteArray` type.\n   */\n  byteArray: () => {\n    return new ByteArrayBuilder();\n  }\n};\n\n// src/lib/autogen/types.ts\nvar AlgebraicType2 = t.enum(\"AlgebraicType\", {\n  Ref: t.u32(),\n  get Sum() {\n    return SumType2;\n  },\n  get Product() {\n    return ProductType2;\n  },\n  get Array() {\n    return AlgebraicType2;\n  },\n  String: t.unit(),\n  Bool: t.unit(),\n  I8: t.unit(),\n  U8: t.unit(),\n  I16: t.unit(),\n  U16: t.unit(),\n  I32: t.unit(),\n  U32: t.unit(),\n  I64: t.unit(),\n  U64: t.unit(),\n  I128: t.unit(),\n  U128: t.unit(),\n  I256: t.unit(),\n  U256: t.unit(),\n  F32: t.unit(),\n  F64: t.unit()\n});\nvar CaseConversionPolicy = t.enum(\"CaseConversionPolicy\", {\n  None: t.unit(),\n  SnakeCase: t.unit()\n});\nvar ExplicitNameEntry = t.enum(\"ExplicitNameEntry\", {\n  get Table() {\n    return NameMapping;\n  },\n  get Function() {\n    return NameMapping;\n  },\n  get Index() {\n    return NameMapping;\n  }\n});\nvar ExplicitNames = t.object(\"ExplicitNames\", {\n  get entries() {\n    return t.array(ExplicitNameEntry);\n  }\n});\nvar FunctionVisibility = t.enum(\"FunctionVisibility\", {\n  Private: t.unit(),\n  ClientCallable: t.unit()\n});\nvar HttpHeaderPair = t.object(\"HttpHeaderPair\", {\n  name: t.string(),\n  value: t.byteArray()\n});\nvar HttpHeaders = t.object(\"HttpHeaders\", {\n  get entries() {\n    return t.array(HttpHeaderPair);\n  }\n});\nvar HttpMethod = t.enum(\"HttpMethod\", {\n  Get: t.unit(),\n  Head: t.unit(),\n  Post: t.unit(),\n  Put: t.unit(),\n  Delete: t.unit(),\n  Connect: t.unit(),\n  Options: t.unit(),\n  Trace: t.unit(),\n  Patch: t.unit(),\n  Extension: t.string()\n});\nvar HttpRequest = t.object(\"HttpRequest\", {\n  get method() {\n    return HttpMethod;\n  },\n  get headers() {\n    return HttpHeaders;\n  },\n  timeout: t.option(t.timeDuration()),\n  uri: t.string(),\n  get version() {\n    return HttpVersion;\n  }\n});\nvar HttpResponse = t.object(\"HttpResponse\", {\n  get headers() {\n    return HttpHeaders;\n  },\n  get version() {\n    return HttpVersion;\n  },\n  code: t.u16()\n});\nvar HttpVersion = t.enum(\"HttpVersion\", {\n  Http09: t.unit(),\n  Http10: t.unit(),\n  Http11: t.unit(),\n  Http2: t.unit(),\n  Http3: t.unit()\n});\nvar IndexType = t.enum(\"IndexType\", {\n  BTree: t.unit(),\n  Hash: t.unit()\n});\nvar Lifecycle = t.enum(\"Lifecycle\", {\n  Init: t.unit(),\n  OnConnect: t.unit(),\n  OnDisconnect: t.unit()\n});\nvar MiscModuleExport = t.enum(\"MiscModuleExport\", {\n  get TypeAlias() {\n    return TypeAlias;\n  }\n});\nvar NameMapping = t.object(\"NameMapping\", {\n  sourceName: t.string(),\n  canonicalName: t.string()\n});\nvar ProductType2 = t.object(\"ProductType\", {\n  get elements() {\n    return t.array(ProductTypeElement);\n  }\n});\nvar ProductTypeElement = t.object(\"ProductTypeElement\", {\n  name: t.option(t.string()),\n  get algebraicType() {\n    return AlgebraicType2;\n  }\n});\nvar RawColumnDefV8 = t.object(\"RawColumnDefV8\", {\n  colName: t.string(),\n  get colType() {\n    return AlgebraicType2;\n  }\n});\nvar RawColumnDefaultValueV10 = t.object(\"RawColumnDefaultValueV10\", {\n  colId: t.u16(),\n  value: t.byteArray()\n});\nvar RawColumnDefaultValueV9 = t.object(\"RawColumnDefaultValueV9\", {\n  table: t.string(),\n  colId: t.u16(),\n  value: t.byteArray()\n});\nvar RawConstraintDataV9 = t.enum(\"RawConstraintDataV9\", {\n  get Unique() {\n    return RawUniqueConstraintDataV9;\n  }\n});\nvar RawConstraintDefV10 = t.object(\"RawConstraintDefV10\", {\n  sourceName: t.option(t.string()),\n  get data() {\n    return RawConstraintDataV9;\n  }\n});\nvar RawConstraintDefV8 = t.object(\"RawConstraintDefV8\", {\n  constraintName: t.string(),\n  constraints: t.u8(),\n  columns: t.array(t.u16())\n});\nvar RawConstraintDefV9 = t.object(\"RawConstraintDefV9\", {\n  name: t.option(t.string()),\n  get data() {\n    return RawConstraintDataV9;\n  }\n});\nvar RawIndexAlgorithm = t.enum(\"RawIndexAlgorithm\", {\n  BTree: t.array(t.u16()),\n  Hash: t.array(t.u16()),\n  Direct: t.u16()\n});\nvar RawIndexDefV10 = t.object(\"RawIndexDefV10\", {\n  sourceName: t.option(t.string()),\n  accessorName: t.option(t.string()),\n  get algorithm() {\n    return RawIndexAlgorithm;\n  }\n});\nvar RawIndexDefV8 = t.object(\"RawIndexDefV8\", {\n  indexName: t.string(),\n  isUnique: t.bool(),\n  get indexType() {\n    return IndexType;\n  },\n  columns: t.array(t.u16())\n});\nvar RawIndexDefV9 = t.object(\"RawIndexDefV9\", {\n  name: t.option(t.string()),\n  accessorName: t.option(t.string()),\n  get algorithm() {\n    return RawIndexAlgorithm;\n  }\n});\nvar RawLifeCycleReducerDefV10 = t.object(\n  \"RawLifeCycleReducerDefV10\",\n  {\n    get lifecycleSpec() {\n      return Lifecycle;\n    },\n    functionName: t.string()\n  }\n);\nvar RawMiscModuleExportV9 = t.enum(\"RawMiscModuleExportV9\", {\n  get ColumnDefaultValue() {\n    return RawColumnDefaultValueV9;\n  },\n  get Procedure() {\n    return RawProcedureDefV9;\n  },\n  get View() {\n    return RawViewDefV9;\n  }\n});\nvar RawModuleDef = t.enum(\"RawModuleDef\", {\n  get V8BackCompat() {\n    return RawModuleDefV8;\n  },\n  get V9() {\n    return RawModuleDefV9;\n  },\n  get V10() {\n    return RawModuleDefV10;\n  }\n});\nvar RawModuleDefV10 = t.object(\"RawModuleDefV10\", {\n  get sections() {\n    return t.array(RawModuleDefV10Section);\n  }\n});\nvar RawModuleDefV10Section = t.enum(\"RawModuleDefV10Section\", {\n  get Typespace() {\n    return Typespace;\n  },\n  get Types() {\n    return t.array(RawTypeDefV10);\n  },\n  get Tables() {\n    return t.array(RawTableDefV10);\n  },\n  get Reducers() {\n    return t.array(RawReducerDefV10);\n  },\n  get Procedures() {\n    return t.array(RawProcedureDefV10);\n  },\n  get Views() {\n    return t.array(RawViewDefV10);\n  },\n  get Schedules() {\n    return t.array(RawScheduleDefV10);\n  },\n  get LifeCycleReducers() {\n    return t.array(RawLifeCycleReducerDefV10);\n  },\n  get RowLevelSecurity() {\n    return t.array(RawRowLevelSecurityDefV9);\n  },\n  get CaseConversionPolicy() {\n    return CaseConversionPolicy;\n  },\n  get ExplicitNames() {\n    return ExplicitNames;\n  }\n});\nvar RawModuleDefV8 = t.object(\"RawModuleDefV8\", {\n  get typespace() {\n    return Typespace;\n  },\n  get tables() {\n    return t.array(TableDesc);\n  },\n  get reducers() {\n    return t.array(ReducerDef);\n  },\n  get miscExports() {\n    return t.array(MiscModuleExport);\n  }\n});\nvar RawModuleDefV9 = t.object(\"RawModuleDefV9\", {\n  get typespace() {\n    return Typespace;\n  },\n  get tables() {\n    return t.array(RawTableDefV9);\n  },\n  get reducers() {\n    return t.array(RawReducerDefV9);\n  },\n  get types() {\n    return t.array(RawTypeDefV9);\n  },\n  get miscExports() {\n    return t.array(RawMiscModuleExportV9);\n  },\n  get rowLevelSecurity() {\n    return t.array(RawRowLevelSecurityDefV9);\n  }\n});\nvar RawProcedureDefV10 = t.object(\"RawProcedureDefV10\", {\n  sourceName: t.string(),\n  get params() {\n    return ProductType2;\n  },\n  get returnType() {\n    return AlgebraicType2;\n  },\n  get visibility() {\n    return FunctionVisibility;\n  }\n});\nvar RawProcedureDefV9 = t.object(\"RawProcedureDefV9\", {\n  name: t.string(),\n  get params() {\n    return ProductType2;\n  },\n  get returnType() {\n    return AlgebraicType2;\n  }\n});\nvar RawReducerDefV10 = t.object(\"RawReducerDefV10\", {\n  sourceName: t.string(),\n  get params() {\n    return ProductType2;\n  },\n  get visibility() {\n    return FunctionVisibility;\n  },\n  get okReturnType() {\n    return AlgebraicType2;\n  },\n  get errReturnType() {\n    return AlgebraicType2;\n  }\n});\nvar RawReducerDefV9 = t.object(\"RawReducerDefV9\", {\n  name: t.string(),\n  get params() {\n    return ProductType2;\n  },\n  get lifecycle() {\n    return t.option(Lifecycle);\n  }\n});\nvar RawRowLevelSecurityDefV9 = t.object(\"RawRowLevelSecurityDefV9\", {\n  sql: t.string()\n});\nvar RawScheduleDefV10 = t.object(\"RawScheduleDefV10\", {\n  sourceName: t.option(t.string()),\n  tableName: t.string(),\n  scheduleAtCol: t.u16(),\n  functionName: t.string()\n});\nvar RawScheduleDefV9 = t.object(\"RawScheduleDefV9\", {\n  name: t.option(t.string()),\n  reducerName: t.string(),\n  scheduledAtColumn: t.u16()\n});\nvar RawScopedTypeNameV10 = t.object(\"RawScopedTypeNameV10\", {\n  scope: t.array(t.string()),\n  sourceName: t.string()\n});\nvar RawScopedTypeNameV9 = t.object(\"RawScopedTypeNameV9\", {\n  scope: t.array(t.string()),\n  name: t.string()\n});\nvar RawSequenceDefV10 = t.object(\"RawSequenceDefV10\", {\n  sourceName: t.option(t.string()),\n  column: t.u16(),\n  start: t.option(t.i128()),\n  minValue: t.option(t.i128()),\n  maxValue: t.option(t.i128()),\n  increment: t.i128()\n});\nvar RawSequenceDefV8 = t.object(\"RawSequenceDefV8\", {\n  sequenceName: t.string(),\n  colPos: t.u16(),\n  increment: t.i128(),\n  start: t.option(t.i128()),\n  minValue: t.option(t.i128()),\n  maxValue: t.option(t.i128()),\n  allocated: t.i128()\n});\nvar RawSequenceDefV9 = t.object(\"RawSequenceDefV9\", {\n  name: t.option(t.string()),\n  column: t.u16(),\n  start: t.option(t.i128()),\n  minValue: t.option(t.i128()),\n  maxValue: t.option(t.i128()),\n  increment: t.i128()\n});\nvar RawTableDefV10 = t.object(\"RawTableDefV10\", {\n  sourceName: t.string(),\n  productTypeRef: t.u32(),\n  primaryKey: t.array(t.u16()),\n  get indexes() {\n    return t.array(RawIndexDefV10);\n  },\n  get constraints() {\n    return t.array(RawConstraintDefV10);\n  },\n  get sequences() {\n    return t.array(RawSequenceDefV10);\n  },\n  get tableType() {\n    return TableType;\n  },\n  get tableAccess() {\n    return TableAccess;\n  },\n  get defaultValues() {\n    return t.array(RawColumnDefaultValueV10);\n  },\n  isEvent: t.bool()\n});\nvar RawTableDefV8 = t.object(\"RawTableDefV8\", {\n  tableName: t.string(),\n  get columns() {\n    return t.array(RawColumnDefV8);\n  },\n  get indexes() {\n    return t.array(RawIndexDefV8);\n  },\n  get constraints() {\n    return t.array(RawConstraintDefV8);\n  },\n  get sequences() {\n    return t.array(RawSequenceDefV8);\n  },\n  tableType: t.string(),\n  tableAccess: t.string(),\n  scheduled: t.option(t.string())\n});\nvar RawTableDefV9 = t.object(\"RawTableDefV9\", {\n  name: t.string(),\n  productTypeRef: t.u32(),\n  primaryKey: t.array(t.u16()),\n  get indexes() {\n    return t.array(RawIndexDefV9);\n  },\n  get constraints() {\n    return t.array(RawConstraintDefV9);\n  },\n  get sequences() {\n    return t.array(RawSequenceDefV9);\n  },\n  get schedule() {\n    return t.option(RawScheduleDefV9);\n  },\n  get tableType() {\n    return TableType;\n  },\n  get tableAccess() {\n    return TableAccess;\n  }\n});\nvar RawTypeDefV10 = t.object(\"RawTypeDefV10\", {\n  get sourceName() {\n    return RawScopedTypeNameV10;\n  },\n  ty: t.u32(),\n  customOrdering: t.bool()\n});\nvar RawTypeDefV9 = t.object(\"RawTypeDefV9\", {\n  get name() {\n    return RawScopedTypeNameV9;\n  },\n  ty: t.u32(),\n  customOrdering: t.bool()\n});\nvar RawUniqueConstraintDataV9 = t.object(\n  \"RawUniqueConstraintDataV9\",\n  {\n    columns: t.array(t.u16())\n  }\n);\nvar RawViewDefV10 = t.object(\"RawViewDefV10\", {\n  sourceName: t.string(),\n  index: t.u32(),\n  isPublic: t.bool(),\n  isAnonymous: t.bool(),\n  get params() {\n    return ProductType2;\n  },\n  get returnType() {\n    return AlgebraicType2;\n  }\n});\nvar RawViewDefV9 = t.object(\"RawViewDefV9\", {\n  name: t.string(),\n  index: t.u32(),\n  isPublic: t.bool(),\n  isAnonymous: t.bool(),\n  get params() {\n    return ProductType2;\n  },\n  get returnType() {\n    return AlgebraicType2;\n  }\n});\nvar ReducerDef = t.object(\"ReducerDef\", {\n  name: t.string(),\n  get args() {\n    return t.array(ProductTypeElement);\n  }\n});\nvar SumType2 = t.object(\"SumType\", {\n  get variants() {\n    return t.array(SumTypeVariant);\n  }\n});\nvar SumTypeVariant = t.object(\"SumTypeVariant\", {\n  name: t.option(t.string()),\n  get algebraicType() {\n    return AlgebraicType2;\n  }\n});\nvar TableAccess = t.enum(\"TableAccess\", {\n  Public: t.unit(),\n  Private: t.unit()\n});\nvar TableDesc = t.object(\"TableDesc\", {\n  get schema() {\n    return RawTableDefV8;\n  },\n  data: t.u32()\n});\nvar TableType = t.enum(\"TableType\", {\n  System: t.unit(),\n  User: t.unit()\n});\nvar TypeAlias = t.object(\"TypeAlias\", {\n  name: t.string(),\n  ty: t.u32()\n});\nvar Typespace = t.object(\"Typespace\", {\n  get types() {\n    return t.array(AlgebraicType2);\n  }\n});\nvar ViewResultHeader = t.enum(\"ViewResultHeader\", {\n  RowData: t.unit(),\n  RawSql: t.string()\n});\n\n// src/lib/schema.ts\nfunction tableToSchema(accName, schema2, tableDef) {\n  const getColName = (i) => schema2.rowType.algebraicType.value.elements[i].name;\n  const resolvedIndexes = tableDef.indexes.map(\n    (idx) => {\n      const accessorName = idx.accessorName;\n      if (typeof accessorName !== \"string\" || accessorName.length === 0) {\n        throw new TypeError(\n          `Index '${idx.sourceName ?? \"<unknown>\"}' on table '${tableDef.sourceName}' is missing accessor name`\n        );\n      }\n      const columnIds = idx.algorithm.tag === \"Direct\" ? [idx.algorithm.value] : idx.algorithm.value;\n      const unique = tableDef.constraints.some(\n        (c) => c.data.tag === \"Unique\" && c.data.value.columns.every((col) => columnIds.includes(col))\n      );\n      const algorithm = {\n        BTree: \"btree\",\n        Hash: \"hash\",\n        Direct: \"direct\"\n      }[idx.algorithm.tag];\n      return {\n        name: accessorName,\n        unique,\n        algorithm,\n        columns: columnIds.map(getColName)\n      };\n    }\n  );\n  return {\n    // For client,`schama.tableName` will always be there as canonical name.\n    // For module, if explicit name is not provided via `name`, accessor name will\n    // be used, it is stored as alias in database, hence works in query builder.\n    sourceName: schema2.tableName || accName,\n    accessorName: accName,\n    columns: schema2.rowType.row,\n    // typed as T[i]['rowType']['row'] under TablesToSchema<T>\n    rowType: schema2.rowSpacetimeType,\n    // Keep declarative indexes in their original shape for type-level consumers.\n    indexes: schema2.idxs,\n    constraints: tableDef.constraints.map((c) => ({\n      name: c.sourceName,\n      constraint: \"unique\",\n      columns: c.data.value.columns.map(getColName)\n    })),\n    // Expose resolved runtime indexes separately so runtime users don't have to\n    // reinterpret `indexes` with unsafe casts.\n    resolvedIndexes,\n    tableDef,\n    ...tableDef.isEvent ? { isEvent: true } : {}\n  };\n}\nvar ModuleContext = class {\n  #compoundTypes = /* @__PURE__ */ new Map();\n  /**\n   * The global module definition that gets populated by calls to `reducer()` and lifecycle hooks.\n   */\n  #moduleDef = {\n    typespace: { types: [] },\n    tables: [],\n    reducers: [],\n    types: [],\n    rowLevelSecurity: [],\n    schedules: [],\n    procedures: [],\n    views: [],\n    lifeCycleReducers: [],\n    caseConversionPolicy: { tag: \"SnakeCase\" },\n    explicitNames: {\n      entries: []\n    }\n  };\n  get moduleDef() {\n    return this.#moduleDef;\n  }\n  rawModuleDefV10() {\n    const sections = [];\n    const push = (s) => {\n      if (s) sections.push(s);\n    };\n    const module = this.#moduleDef;\n    push(module.typespace && { tag: \"Typespace\", value: module.typespace });\n    push(module.types && { tag: \"Types\", value: module.types });\n    push(module.tables && { tag: \"Tables\", value: module.tables });\n    push(module.reducers && { tag: \"Reducers\", value: module.reducers });\n    push(module.procedures && { tag: \"Procedures\", value: module.procedures });\n    push(module.views && { tag: \"Views\", value: module.views });\n    push(module.schedules && { tag: \"Schedules\", value: module.schedules });\n    push(\n      module.lifeCycleReducers && {\n        tag: \"LifeCycleReducers\",\n        value: module.lifeCycleReducers\n      }\n    );\n    push(\n      module.rowLevelSecurity && {\n        tag: \"RowLevelSecurity\",\n        value: module.rowLevelSecurity\n      }\n    );\n    push(\n      module.explicitNames && {\n        tag: \"ExplicitNames\",\n        value: module.explicitNames\n      }\n    );\n    push(\n      module.caseConversionPolicy && {\n        tag: \"CaseConversionPolicy\",\n        value: module.caseConversionPolicy\n      }\n    );\n    return { sections };\n  }\n  /**\n   * Set the case conversion policy for this module.\n   * Called by the settings mechanism.\n   */\n  setCaseConversionPolicy(policy) {\n    this.#moduleDef.caseConversionPolicy = policy;\n  }\n  get typespace() {\n    return this.#moduleDef.typespace;\n  }\n  /**\n   * Resolves the actual type of a TypeBuilder by following its references until it reaches a non-ref type.\n   * @param typespace The typespace to resolve types against.\n   * @param typeBuilder The TypeBuilder to resolve.\n   * @returns The resolved algebraic type.\n   */\n  resolveType(typeBuilder) {\n    let ty = typeBuilder.algebraicType;\n    while (ty.tag === \"Ref\") {\n      ty = this.typespace.types[ty.value];\n    }\n    return ty;\n  }\n  /**\n   * Adds a type to the module definition's typespace as a `Ref` if it is a named compound type (Product or Sum).\n   * Otherwise, returns the type as is.\n   * @param name\n   * @param ty\n   * @returns\n   */\n  registerTypesRecursively(typeBuilder) {\n    if (typeBuilder instanceof ProductBuilder && !isUnit(typeBuilder) || typeBuilder instanceof SumBuilder || typeBuilder instanceof RowBuilder) {\n      return this.#registerCompoundTypeRecursively(typeBuilder);\n    } else if (typeBuilder instanceof OptionBuilder) {\n      return new OptionBuilder(\n        this.registerTypesRecursively(typeBuilder.value)\n      );\n    } else if (typeBuilder instanceof ResultBuilder) {\n      return new ResultBuilder(\n        this.registerTypesRecursively(typeBuilder.ok),\n        this.registerTypesRecursively(typeBuilder.err)\n      );\n    } else if (typeBuilder instanceof ArrayBuilder) {\n      return new ArrayBuilder(\n        this.registerTypesRecursively(typeBuilder.element)\n      );\n    } else {\n      return typeBuilder;\n    }\n  }\n  #registerCompoundTypeRecursively(typeBuilder) {\n    const ty = typeBuilder.algebraicType;\n    const name = typeBuilder.typeName;\n    if (name === void 0) {\n      throw new Error(\n        `Missing type name for ${typeBuilder.constructor.name ?? \"TypeBuilder\"} ${JSON.stringify(typeBuilder)}`\n      );\n    }\n    let r = this.#compoundTypes.get(ty);\n    if (r != null) {\n      return r;\n    }\n    const newTy = typeBuilder instanceof RowBuilder || typeBuilder instanceof ProductBuilder ? {\n      tag: \"Product\",\n      value: { elements: [] }\n    } : {\n      tag: \"Sum\",\n      value: { variants: [] }\n    };\n    r = new RefBuilder(this.#moduleDef.typespace.types.length);\n    this.#moduleDef.typespace.types.push(newTy);\n    this.#compoundTypes.set(ty, r);\n    if (typeBuilder instanceof RowBuilder) {\n      for (const [name2, elem] of Object.entries(typeBuilder.row)) {\n        newTy.value.elements.push({\n          name: name2,\n          algebraicType: this.registerTypesRecursively(elem.typeBuilder).algebraicType\n        });\n      }\n    } else if (typeBuilder instanceof ProductBuilder) {\n      for (const [name2, elem] of Object.entries(typeBuilder.elements)) {\n        newTy.value.elements.push({\n          name: name2,\n          algebraicType: this.registerTypesRecursively(elem).algebraicType\n        });\n      }\n    } else if (typeBuilder instanceof SumBuilder) {\n      for (const [name2, variant] of Object.entries(typeBuilder.variants)) {\n        newTy.value.variants.push({\n          name: name2,\n          algebraicType: this.registerTypesRecursively(variant).algebraicType\n        });\n      }\n    }\n    this.#moduleDef.types.push({\n      sourceName: splitName(name),\n      ty: r.ref,\n      customOrdering: true\n    });\n    return r;\n  }\n};\nfunction isUnit(typeBuilder) {\n  return typeBuilder.typeName == null && typeBuilder.algebraicType.value.elements.length === 0;\n}\nfunction splitName(name) {\n  const scope = name.split(\".\");\n  return { sourceName: scope.pop(), scope };\n}\n\n// src/server/http_internal.ts\nvar import_statuses = __toESM(require_statuses());\n\n// src/server/range.ts\nvar Range = class {\n  #from;\n  #to;\n  constructor(from, to) {\n    this.#from = from ?? { tag: \"unbounded\" };\n    this.#to = to ?? { tag: \"unbounded\" };\n  }\n  get from() {\n    return this.#from;\n  }\n  get to() {\n    return this.#to;\n  }\n};\n\n// src/lib/table.ts\nfunction table(opts, row, ..._) {\n  const {\n    name,\n    public: isPublic = false,\n    indexes: userIndexes = [],\n    scheduled,\n    event: isEvent = false\n  } = opts;\n  const colIds = /* @__PURE__ */ new Map();\n  const colNameList = [];\n  if (!(row instanceof RowBuilder)) {\n    row = new RowBuilder(row);\n  }\n  row.algebraicType.value.elements.forEach((elem, i) => {\n    colIds.set(elem.name, i);\n    colNameList.push(elem.name);\n  });\n  const pk = [];\n  const indexes = [];\n  const constraints = [];\n  const sequences = [];\n  let scheduleAtCol;\n  const defaultValues = [];\n  for (const [name2, builder] of Object.entries(row.row)) {\n    const meta = builder.columnMetadata;\n    if (meta.isPrimaryKey) {\n      pk.push(colIds.get(name2));\n    }\n    const isUnique = meta.isUnique || meta.isPrimaryKey;\n    if (meta.indexType || isUnique) {\n      const algo = meta.indexType ?? \"btree\";\n      const id = colIds.get(name2);\n      let algorithm;\n      switch (algo) {\n        case \"btree\":\n          algorithm = RawIndexAlgorithm.BTree([id]);\n          break;\n        case \"hash\":\n          algorithm = RawIndexAlgorithm.Hash([id]);\n          break;\n        case \"direct\":\n          algorithm = RawIndexAlgorithm.Direct(id);\n          break;\n      }\n      indexes.push({\n        sourceName: void 0,\n        // Unnamed indexes will be assigned a globally unique name\n        accessorName: name2,\n        algorithm\n      });\n    }\n    if (isUnique) {\n      constraints.push({\n        sourceName: void 0,\n        data: { tag: \"Unique\", value: { columns: [colIds.get(name2)] } }\n      });\n    }\n    if (meta.isAutoIncrement) {\n      sequences.push({\n        sourceName: void 0,\n        start: void 0,\n        minValue: void 0,\n        maxValue: void 0,\n        column: colIds.get(name2),\n        increment: 1n\n      });\n    }\n    if (meta.defaultValue) {\n      const writer = new BinaryWriter(16);\n      builder.serialize(writer, meta.defaultValue);\n      defaultValues.push({\n        colId: colIds.get(name2),\n        value: writer.getBuffer()\n      });\n    }\n    if (scheduled) {\n      const algebraicType = builder.typeBuilder.algebraicType;\n      if (schedule_at_default.isScheduleAt(algebraicType)) {\n        scheduleAtCol = colIds.get(name2);\n      }\n    }\n  }\n  for (const indexOpts of userIndexes ?? []) {\n    const accessor = indexOpts.accessor;\n    if (typeof accessor !== \"string\" || accessor.length === 0) {\n      const tableLabel = name ?? \"<unnamed>\";\n      const indexLabel = indexOpts.name ?? \"<unnamed>\";\n      throw new TypeError(\n        `Index '${indexLabel}' on table '${tableLabel}' must define a non-empty 'accessor'`\n      );\n    }\n    let algorithm;\n    switch (indexOpts.algorithm) {\n      case \"btree\":\n        algorithm = {\n          tag: \"BTree\",\n          value: indexOpts.columns.map((c) => colIds.get(c))\n        };\n        break;\n      case \"hash\":\n        algorithm = {\n          tag: \"Hash\",\n          value: indexOpts.columns.map((c) => colIds.get(c))\n        };\n        break;\n      case \"direct\":\n        algorithm = { tag: \"Direct\", value: colIds.get(indexOpts.column) };\n        break;\n    }\n    indexes.push({\n      sourceName: void 0,\n      accessorName: accessor,\n      algorithm,\n      canonicalName: indexOpts.name\n    });\n  }\n  for (const constraintOpts of opts.constraints ?? []) {\n    if (constraintOpts.constraint === \"unique\") {\n      const data = {\n        tag: \"Unique\",\n        value: { columns: constraintOpts.columns.map((c) => colIds.get(c)) }\n      };\n      constraints.push({ sourceName: constraintOpts.name, data });\n      continue;\n    }\n  }\n  const productType = row.algebraicType.value;\n  const schedule = scheduled && scheduleAtCol !== void 0 ? { scheduleAtCol, reducer: scheduled } : void 0;\n  return {\n    rowType: row,\n    tableName: name,\n    rowSpacetimeType: productType,\n    tableDef: (ctx, accName) => {\n      const tableName = name ?? accName;\n      if (row.typeName === void 0) {\n        row.typeName = toPascalCase(tableName);\n      }\n      for (const index of indexes) {\n        const cols = index.algorithm.tag === \"Direct\" ? [index.algorithm.value] : index.algorithm.value;\n        const colS = cols.map((i) => colNameList[i]).join(\"_\");\n        const sourceName = index.sourceName = `${accName}_${colS}_idx_${index.algorithm.tag.toLowerCase()}`;\n        const { canonicalName } = index;\n        if (canonicalName !== void 0) {\n          ctx.moduleDef.explicitNames.entries.push(\n            ExplicitNameEntry.Index({ sourceName, canonicalName })\n          );\n        }\n      }\n      return {\n        sourceName: accName,\n        productTypeRef: ctx.registerTypesRecursively(row).ref,\n        primaryKey: pk,\n        indexes,\n        constraints,\n        sequences,\n        tableType: { tag: \"User\" },\n        tableAccess: { tag: isPublic ? \"Public\" : \"Private\" },\n        defaultValues,\n        isEvent\n      };\n    },\n    // Preserve the declared index options as runtime data so `tableToSchema`\n    // can expose them without type-smuggling.\n    idxs: userIndexes,\n    constraints,\n    schedule\n  };\n}\n\n// src/lib/query.ts\nvar QueryBrand = Symbol(\"QueryBrand\");\nvar isRowTypedQuery = (val) => !!val && typeof val === \"object\" && QueryBrand in val;\nvar isTypedQuery = (val) => !!val && typeof val === \"object\" && QueryBrand in val;\nfunction toSql(q) {\n  return q.toSql();\n}\nvar SemijoinImpl = class _SemijoinImpl {\n  constructor(sourceQuery, filterQuery, joinCondition) {\n    this.sourceQuery = sourceQuery;\n    this.filterQuery = filterQuery;\n    this.joinCondition = joinCondition;\n    if (sourceQuery.table.sourceName === filterQuery.table.sourceName) {\n      throw new Error(\"Cannot semijoin a table to itself\");\n    }\n  }\n  [QueryBrand] = true;\n  type = \"semijoin\";\n  build() {\n    return this;\n  }\n  where(predicate) {\n    const nextSourceQuery = this.sourceQuery.where(predicate);\n    return new _SemijoinImpl(\n      nextSourceQuery,\n      this.filterQuery,\n      this.joinCondition\n    );\n  }\n  toSql() {\n    const left = this.filterQuery;\n    const right = this.sourceQuery;\n    const leftTable = quoteIdentifier(left.table.sourceName);\n    const rightTable = quoteIdentifier(right.table.sourceName);\n    let sql = `SELECT ${rightTable}.* FROM ${leftTable} JOIN ${rightTable} ON ${booleanExprToSql(this.joinCondition)}`;\n    const clauses = [];\n    if (left.whereClause) {\n      clauses.push(booleanExprToSql(left.whereClause));\n    }\n    if (right.whereClause) {\n      clauses.push(booleanExprToSql(right.whereClause));\n    }\n    if (clauses.length > 0) {\n      const whereSql = clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(\" AND \");\n      sql += ` WHERE ${whereSql}`;\n    }\n    return sql;\n  }\n};\nvar FromBuilder = class _FromBuilder {\n  constructor(table2, whereClause) {\n    this.table = table2;\n    this.whereClause = whereClause;\n  }\n  [QueryBrand] = true;\n  where(predicate) {\n    const newCondition = normalizePredicateExpr(predicate(this.table.cols));\n    const nextWhere = this.whereClause ? this.whereClause.and(newCondition) : newCondition;\n    return new _FromBuilder(this.table, nextWhere);\n  }\n  rightSemijoin(right, on) {\n    const sourceQuery = new _FromBuilder(right);\n    const joinCondition = on(\n      this.table.indexedCols,\n      right.indexedCols\n    );\n    return new SemijoinImpl(sourceQuery, this, joinCondition);\n  }\n  leftSemijoin(right, on) {\n    const filterQuery = new _FromBuilder(right);\n    const joinCondition = on(\n      this.table.indexedCols,\n      right.indexedCols\n    );\n    return new SemijoinImpl(this, filterQuery, joinCondition);\n  }\n  toSql() {\n    return renderSelectSqlWithJoins(this.table, this.whereClause);\n  }\n  build() {\n    return this;\n  }\n};\nvar TableRefImpl = class {\n  [QueryBrand] = true;\n  type = \"table\";\n  sourceName;\n  accessorName;\n  cols;\n  indexedCols;\n  tableDef;\n  // Delegate UntypedTableDef properties from tableDef so this can be used as a table def.\n  get columns() {\n    return this.tableDef.columns;\n  }\n  get indexes() {\n    return this.tableDef.indexes;\n  }\n  get rowType() {\n    return this.tableDef.rowType;\n  }\n  get constraints() {\n    return this.tableDef.constraints;\n  }\n  constructor(tableDef) {\n    this.sourceName = tableDef.sourceName;\n    this.accessorName = tableDef.accessorName;\n    this.cols = createRowExpr(tableDef);\n    this.indexedCols = this.cols;\n    this.tableDef = tableDef;\n    Object.freeze(this);\n  }\n  asFrom() {\n    return new FromBuilder(this);\n  }\n  rightSemijoin(other, on) {\n    return this.asFrom().rightSemijoin(other, on);\n  }\n  leftSemijoin(other, on) {\n    return this.asFrom().leftSemijoin(other, on);\n  }\n  build() {\n    return this.asFrom().build();\n  }\n  toSql() {\n    return this.asFrom().toSql();\n  }\n  where(predicate) {\n    return this.asFrom().where(predicate);\n  }\n};\nfunction createTableRefFromDef(tableDef) {\n  return new TableRefImpl(tableDef);\n}\nfunction makeQueryBuilder(schema2) {\n  const qb = /* @__PURE__ */ Object.create(null);\n  for (const table2 of Object.values(schema2.tables)) {\n    const ref = createTableRefFromDef(\n      table2\n    );\n    qb[table2.accessorName] = ref;\n  }\n  return Object.freeze(qb);\n}\nfunction createRowExpr(tableDef) {\n  const row = {};\n  for (const columnName of Object.keys(tableDef.columns)) {\n    const columnBuilder = tableDef.columns[columnName];\n    const column = new ColumnExpression(\n      tableDef.sourceName,\n      columnName,\n      columnBuilder.typeBuilder.algebraicType,\n      columnBuilder.columnMetadata.name\n    );\n    row[columnName] = Object.freeze(column);\n  }\n  return Object.freeze(row);\n}\nfunction renderSelectSqlWithJoins(table2, where, extraClauses = []) {\n  const quotedTable = quoteIdentifier(table2.sourceName);\n  const sql = `SELECT * FROM ${quotedTable}`;\n  const clauses = [];\n  if (where) clauses.push(booleanExprToSql(where));\n  clauses.push(...extraClauses);\n  if (clauses.length === 0) return sql;\n  const whereSql = clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(\" AND \");\n  return `${sql} WHERE ${whereSql}`;\n}\nvar ColumnExpression = class {\n  type = \"column\";\n  // This is the column accessor\n  column;\n  // The name of the column in the database.\n  columnName;\n  table;\n  // phantom: actual runtime value is undefined\n  tsValueType;\n  spacetimeType;\n  constructor(table2, column, spacetimeType, columnName) {\n    this.table = table2;\n    this.column = column;\n    this.columnName = columnName || column;\n    this.spacetimeType = spacetimeType;\n  }\n  eq(x) {\n    return new BooleanExpr({\n      type: \"eq\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  ne(x) {\n    return new BooleanExpr({\n      type: \"ne\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  lt(x) {\n    return new BooleanExpr({\n      type: \"lt\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  lte(x) {\n    return new BooleanExpr({\n      type: \"lte\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  gt(x) {\n    return new BooleanExpr({\n      type: \"gt\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n  gte(x) {\n    return new BooleanExpr({\n      type: \"gte\",\n      left: this,\n      right: normalizeValue(x)\n    });\n  }\n};\nfunction literal(value) {\n  return { type: \"literal\", value };\n}\nfunction normalizeValue(val) {\n  if (val.type === \"literal\")\n    return val;\n  if (typeof val === \"object\" && val != null && \"type\" in val && val.type === \"column\") {\n    return val;\n  }\n  return literal(val);\n}\nfunction normalizePredicateExpr(value) {\n  if (value instanceof BooleanExpr) return value;\n  if (typeof value === \"boolean\") {\n    return new BooleanExpr({\n      type: \"eq\",\n      left: literal(value),\n      right: literal(true)\n    });\n  }\n  return new BooleanExpr({\n    type: \"eq\",\n    left: value,\n    right: literal(true)\n  });\n}\nvar BooleanExpr = class _BooleanExpr {\n  constructor(data) {\n    this.data = data;\n  }\n  and(other) {\n    return new _BooleanExpr({\n      type: \"and\",\n      clauses: [this.data, other.data]\n    });\n  }\n  or(other) {\n    return new _BooleanExpr({\n      type: \"or\",\n      clauses: [this.data, other.data]\n    });\n  }\n  not() {\n    return new _BooleanExpr({ type: \"not\", clause: this.data });\n  }\n};\nfunction not(clause) {\n  return new BooleanExpr({ type: \"not\", clause: clause.data });\n}\nfunction and(first, second, ...rest) {\n  const clauses = [first, second, ...rest];\n  return new BooleanExpr({\n    type: \"and\",\n    clauses: clauses.map((c) => c.data)\n  });\n}\nfunction or(first, second, ...rest) {\n  const clauses = [first, second, ...rest];\n  return new BooleanExpr({\n    type: \"or\",\n    clauses: clauses.map((c) => c.data)\n  });\n}\nfunction booleanExprToSql(expr, tableAlias) {\n  const data = expr instanceof BooleanExpr ? expr.data : expr;\n  switch (data.type) {\n    case \"eq\":\n      return `${valueExprToSql(data.left)} = ${valueExprToSql(data.right)}`;\n    case \"ne\":\n      return `${valueExprToSql(data.left)} <> ${valueExprToSql(data.right)}`;\n    case \"gt\":\n      return `${valueExprToSql(data.left)} > ${valueExprToSql(data.right)}`;\n    case \"gte\":\n      return `${valueExprToSql(data.left)} >= ${valueExprToSql(data.right)}`;\n    case \"lt\":\n      return `${valueExprToSql(data.left)} < ${valueExprToSql(data.right)}`;\n    case \"lte\":\n      return `${valueExprToSql(data.left)} <= ${valueExprToSql(data.right)}`;\n    case \"and\":\n      return data.clauses.map((c) => booleanExprToSql(c)).map(wrapInParens).join(\" AND \");\n    case \"or\":\n      return data.clauses.map((c) => booleanExprToSql(c)).map(wrapInParens).join(\" OR \");\n    case \"not\":\n      return `NOT ${wrapInParens(booleanExprToSql(data.clause))}`;\n  }\n}\nfunction wrapInParens(sql) {\n  return `(${sql})`;\n}\nfunction valueExprToSql(expr, tableAlias) {\n  if (isLiteralExpr(expr)) {\n    return literalValueToSql(expr.value);\n  }\n  const table2 = expr.table;\n  return `${quoteIdentifier(table2)}.${quoteIdentifier(expr.columnName)}`;\n}\nfunction literalValueToSql(value) {\n  if (value === null || value === void 0) {\n    return \"NULL\";\n  }\n  if (value instanceof Identity || value instanceof ConnectionId) {\n    return `0x${value.toHexString()}`;\n  }\n  if (value instanceof Timestamp) {\n    return `'${value.toISOString()}'`;\n  }\n  switch (typeof value) {\n    case \"number\":\n    case \"bigint\":\n      return String(value);\n    case \"boolean\":\n      return value ? \"TRUE\" : \"FALSE\";\n    case \"string\":\n      return `'${value.replace(/'/g, \"''\")}'`;\n    default:\n      return `'${JSON.stringify(value).replace(/'/g, \"''\")}'`;\n  }\n}\nfunction quoteIdentifier(name) {\n  return `\"${name.replace(/\"/g, '\"\"')}\"`;\n}\nfunction isLiteralExpr(expr) {\n  return expr.type === \"literal\";\n}\nfunction evaluateBooleanExpr(expr, row) {\n  return evaluateData(expr.data, row);\n}\nfunction evaluateData(data, row) {\n  switch (data.type) {\n    case \"eq\":\n      return resolveValue(data.left, row) === resolveValue(data.right, row);\n    case \"ne\":\n      return resolveValue(data.left, row) !== resolveValue(data.right, row);\n    case \"gt\":\n      return resolveValue(data.left, row) > resolveValue(data.right, row);\n    case \"gte\":\n      return resolveValue(data.left, row) >= resolveValue(data.right, row);\n    case \"lt\":\n      return resolveValue(data.left, row) < resolveValue(data.right, row);\n    case \"lte\":\n      return resolveValue(data.left, row) <= resolveValue(data.right, row);\n    case \"and\":\n      return data.clauses.every((c) => evaluateData(c, row));\n    case \"or\":\n      return data.clauses.some((c) => evaluateData(c, row));\n    case \"not\":\n      return !evaluateData(data.clause, row);\n  }\n}\nfunction resolveValue(expr, row) {\n  if (isLiteralExpr(expr)) {\n    return toComparableValue(expr.value);\n  }\n  return toComparableValue(row[expr.column]);\n}\nfunction isHexSerializableLike(value) {\n  return !!value && typeof value === \"object\" && typeof value.toHexString === \"function\";\n}\nfunction isTimestampLike(value) {\n  if (!value || typeof value !== \"object\") return false;\n  if (value instanceof Timestamp) return true;\n  const micros = value[\"__timestamp_micros_since_unix_epoch__\"];\n  return typeof micros === \"bigint\";\n}\nfunction toComparableValue(value) {\n  if (isHexSerializableLike(value)) {\n    return value.toHexString();\n  }\n  if (isTimestampLike(value)) {\n    return value.__timestamp_micros_since_unix_epoch__;\n  }\n  return value;\n}\nfunction getQueryTableName(query) {\n  if (query.table) return query.table.name;\n  if (query.name) return query.name;\n  if (query.sourceQuery) return query.sourceQuery.table.name;\n  throw new Error(\"Cannot extract table name from query\");\n}\nfunction getQueryAccessorName(query) {\n  if (query.table) return query.table.accessorName;\n  if (query.accessorName) return query.accessorName;\n  if (query.sourceQuery) return query.sourceQuery.table.accessorName;\n  throw new Error(\"Cannot extract accessor name from query\");\n}\nfunction getQueryWhereClause(query) {\n  if (query.whereClause) return query.whereClause;\n  return void 0;\n}\n\n// src/server/views.ts\nfunction makeViewExport(ctx, opts, params, ret, fn) {\n  const viewExport = (\n    // @ts-expect-error typescript incorrectly says Function#bind requires an argument.\n    fn.bind()\n  );\n  viewExport[exportContext] = ctx;\n  viewExport[registerExport] = (ctx2, exportName) => {\n    registerView(ctx2, opts, exportName, false, params, ret, fn);\n  };\n  return viewExport;\n}\nfunction makeAnonViewExport(ctx, opts, params, ret, fn) {\n  const viewExport = (\n    // @ts-expect-error typescript incorrectly says Function#bind requires an argument.\n    fn.bind()\n  );\n  viewExport[exportContext] = ctx;\n  viewExport[registerExport] = (ctx2, exportName) => {\n    registerView(ctx2, opts, exportName, true, params, ret, fn);\n  };\n  return viewExport;\n}\nfunction registerView(ctx, opts, exportName, anon, params, ret, fn) {\n  const paramsBuilder = new RowBuilder(params, toPascalCase(exportName));\n  let returnType = ctx.registerTypesRecursively(ret).algebraicType;\n  const { typespace } = ctx;\n  const { value: paramType } = ctx.resolveType(\n    ctx.registerTypesRecursively(paramsBuilder)\n  );\n  ctx.moduleDef.views.push({\n    sourceName: exportName,\n    index: (anon ? ctx.anonViews : ctx.views).length,\n    isPublic: opts.public,\n    isAnonymous: anon,\n    params: paramType,\n    returnType\n  });\n  if (opts.name != null) {\n    ctx.moduleDef.explicitNames.entries.push({\n      tag: \"Function\",\n      value: {\n        sourceName: exportName,\n        canonicalName: opts.name\n      }\n    });\n  }\n  if (returnType.tag == \"Sum\") {\n    const originalFn = fn;\n    fn = ((ctx2, args) => {\n      const ret2 = originalFn(ctx2, args);\n      return ret2 == null ? [] : [ret2];\n    });\n    returnType = AlgebraicType.Array(\n      returnType.value.variants[0].algebraicType\n    );\n  }\n  (anon ? ctx.anonViews : ctx.views).push({\n    fn,\n    deserializeParams: ProductType.makeDeserializer(paramType, typespace),\n    serializeReturn: AlgebraicType.makeSerializer(returnType, typespace),\n    returnTypeBaseSize: bsatnBaseSize(typespace, returnType)\n  });\n}\n\n// src/lib/errors.ts\nvar SenderError = class extends Error {\n  constructor(message) {\n    super(message);\n  }\n  get name() {\n    return \"SenderError\";\n  }\n};\n\n// src/server/errors.ts\nvar SpacetimeHostError = class extends Error {\n  constructor(message) {\n    super(message);\n  }\n  get name() {\n    return \"SpacetimeHostError\";\n  }\n};\nvar errorData = {\n  /**\n   * A generic error class for unknown error codes.\n   */\n  HostCallFailure: 1,\n  /**\n   * Error indicating that an ABI call was made outside of a transaction.\n   */\n  NotInTransaction: 2,\n  /**\n   * Error indicating that BSATN decoding failed.\n   * This typically means that the data could not be decoded to the expected type.\n   */\n  BsatnDecodeError: 3,\n  /**\n   * Error indicating that a specified table does not exist.\n   */\n  NoSuchTable: 4,\n  /**\n   * Error indicating that a specified index does not exist.\n   */\n  NoSuchIndex: 5,\n  /**\n   * Error indicating that a specified row iterator is not valid.\n   */\n  NoSuchIter: 6,\n  /**\n   * Error indicating that a specified console timer does not exist.\n   */\n  NoSuchConsoleTimer: 7,\n  /**\n   * Error indicating that a specified bytes source or sink is not valid.\n   */\n  NoSuchBytes: 8,\n  /**\n   * Error indicating that a provided sink has no more space left.\n   */\n  NoSpace: 9,\n  /**\n   * Error indicating that there is no more space in the database.\n   */\n  BufferTooSmall: 11,\n  /**\n   * Error indicating that a value with a given unique identifier already exists.\n   */\n  UniqueAlreadyExists: 12,\n  /**\n   * Error indicating that the specified delay in scheduling a row was too long.\n   */\n  ScheduleAtDelayTooLong: 13,\n  /**\n   * Error indicating that an index was not unique when it was expected to be.\n   */\n  IndexNotUnique: 14,\n  /**\n   * Error indicating that an index was not unique when it was expected to be.\n   */\n  NoSuchRow: 15,\n  /**\n   * Error indicating that an auto-increment sequence has overflowed.\n   */\n  AutoIncOverflow: 16,\n  WouldBlockTransaction: 17,\n  TransactionNotAnonymous: 18,\n  TransactionIsReadOnly: 19,\n  TransactionIsMut: 20,\n  HttpError: 21\n};\nfunction mapEntries(x, f) {\n  return Object.fromEntries(\n    Object.entries(x).map(([k, v]) => [k, f(k, v)])\n  );\n}\nvar errnoToClass = /* @__PURE__ */ new Map();\nvar errors = Object.freeze(\n  mapEntries(errorData, (name, code) => {\n    const cls = Object.defineProperty(\n      class extends SpacetimeHostError {\n        get name() {\n          return name;\n        }\n      },\n      \"name\",\n      { value: name, writable: false }\n    );\n    errnoToClass.set(code, cls);\n    return cls;\n  })\n);\nfunction getErrorConstructor(code) {\n  return errnoToClass.get(code) ?? SpacetimeHostError;\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformBigIntDistribution.js\nvar SBigInt = typeof BigInt !== \"undefined\" ? BigInt : void 0;\nvar One = typeof BigInt !== \"undefined\" ? BigInt(1) : void 0;\nvar ThirtyTwo = typeof BigInt !== \"undefined\" ? BigInt(32) : void 0;\nvar NumValues = typeof BigInt !== \"undefined\" ? BigInt(4294967296) : void 0;\nfunction unsafeUniformBigIntDistribution(from, to, rng) {\n  var diff = to - from + One;\n  var FinalNumValues = NumValues;\n  var NumIterations = 1;\n  while (FinalNumValues < diff) {\n    FinalNumValues <<= ThirtyTwo;\n    ++NumIterations;\n  }\n  var value = generateNext(NumIterations, rng);\n  if (value < diff) {\n    return value + from;\n  }\n  if (value + diff < FinalNumValues) {\n    return value % diff + from;\n  }\n  var MaxAcceptedRandom = FinalNumValues - FinalNumValues % diff;\n  while (value >= MaxAcceptedRandom) {\n    value = generateNext(NumIterations, rng);\n  }\n  return value % diff + from;\n}\nfunction generateNext(NumIterations, rng) {\n  var value = SBigInt(rng.unsafeNext() + 2147483648);\n  for (var num = 1; num < NumIterations; ++num) {\n    var out = rng.unsafeNext();\n    value = (value << ThirtyTwo) + SBigInt(out + 2147483648);\n  }\n  return value;\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformIntDistributionInternal.js\nfunction unsafeUniformIntDistributionInternal(rangeSize, rng) {\n  var MaxAllowed = rangeSize > 2 ? ~~(4294967296 / rangeSize) * rangeSize : 4294967296;\n  var deltaV = rng.unsafeNext() + 2147483648;\n  while (deltaV >= MaxAllowed) {\n    deltaV = rng.unsafeNext() + 2147483648;\n  }\n  return deltaV % rangeSize;\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/internals/ArrayInt64.js\nfunction fromNumberToArrayInt64(out, n) {\n  if (n < 0) {\n    var posN = -n;\n    out.sign = -1;\n    out.data[0] = ~~(posN / 4294967296);\n    out.data[1] = posN >>> 0;\n  } else {\n    out.sign = 1;\n    out.data[0] = ~~(n / 4294967296);\n    out.data[1] = n >>> 0;\n  }\n  return out;\n}\nfunction substractArrayInt64(out, arrayIntA, arrayIntB) {\n  var lowA = arrayIntA.data[1];\n  var highA = arrayIntA.data[0];\n  var signA = arrayIntA.sign;\n  var lowB = arrayIntB.data[1];\n  var highB = arrayIntB.data[0];\n  var signB = arrayIntB.sign;\n  out.sign = 1;\n  if (signA === 1 && signB === -1) {\n    var low_1 = lowA + lowB;\n    var high = highA + highB + (low_1 > 4294967295 ? 1 : 0);\n    out.data[0] = high >>> 0;\n    out.data[1] = low_1 >>> 0;\n    return out;\n  }\n  var lowFirst = lowA;\n  var highFirst = highA;\n  var lowSecond = lowB;\n  var highSecond = highB;\n  if (signA === -1) {\n    lowFirst = lowB;\n    highFirst = highB;\n    lowSecond = lowA;\n    highSecond = highA;\n  }\n  var reminderLow = 0;\n  var low = lowFirst - lowSecond;\n  if (low < 0) {\n    reminderLow = 1;\n    low = low >>> 0;\n  }\n  out.data[0] = highFirst - highSecond - reminderLow;\n  out.data[1] = low;\n  return out;\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/internals/UnsafeUniformArrayIntDistributionInternal.js\nfunction unsafeUniformArrayIntDistributionInternal(out, rangeSize, rng) {\n  var rangeLength = rangeSize.length;\n  while (true) {\n    for (var index = 0; index !== rangeLength; ++index) {\n      var indexRangeSize = index === 0 ? rangeSize[0] + 1 : 4294967296;\n      var g = unsafeUniformIntDistributionInternal(indexRangeSize, rng);\n      out[index] = g;\n    }\n    for (var index = 0; index !== rangeLength; ++index) {\n      var current = out[index];\n      var currentInRange = rangeSize[index];\n      if (current < currentInRange) {\n        return out;\n      } else if (current > currentInRange) {\n        break;\n      }\n    }\n  }\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformIntDistribution.js\nvar safeNumberMaxSafeInteger = Number.MAX_SAFE_INTEGER;\nvar sharedA = { sign: 1, data: [0, 0] };\nvar sharedB = { sign: 1, data: [0, 0] };\nvar sharedC = { sign: 1, data: [0, 0] };\nvar sharedData = [0, 0];\nfunction uniformLargeIntInternal(from, to, rangeSize, rng) {\n  var rangeSizeArrayIntValue = rangeSize <= safeNumberMaxSafeInteger ? fromNumberToArrayInt64(sharedC, rangeSize) : substractArrayInt64(sharedC, fromNumberToArrayInt64(sharedA, to), fromNumberToArrayInt64(sharedB, from));\n  if (rangeSizeArrayIntValue.data[1] === 4294967295) {\n    rangeSizeArrayIntValue.data[0] += 1;\n    rangeSizeArrayIntValue.data[1] = 0;\n  } else {\n    rangeSizeArrayIntValue.data[1] += 1;\n  }\n  unsafeUniformArrayIntDistributionInternal(sharedData, rangeSizeArrayIntValue.data, rng);\n  return sharedData[0] * 4294967296 + sharedData[1] + from;\n}\nfunction unsafeUniformIntDistribution(from, to, rng) {\n  var rangeSize = to - from;\n  if (rangeSize <= 4294967295) {\n    var g = unsafeUniformIntDistributionInternal(rangeSize + 1, rng);\n    return g + from;\n  }\n  return uniformLargeIntInternal(from, to, rangeSize, rng);\n}\n\n// ../../node_modules/.pnpm/pure-rand@7.0.1/node_modules/pure-rand/lib/esm/generator/XoroShiro.js\nvar XoroShiro128Plus = (function() {\n  function XoroShiro128Plus2(s01, s00, s11, s10) {\n    this.s01 = s01;\n    this.s00 = s00;\n    this.s11 = s11;\n    this.s10 = s10;\n  }\n  XoroShiro128Plus2.prototype.clone = function() {\n    return new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);\n  };\n  XoroShiro128Plus2.prototype.next = function() {\n    var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);\n    var out = nextRng.unsafeNext();\n    return [out, nextRng];\n  };\n  XoroShiro128Plus2.prototype.unsafeNext = function() {\n    var out = this.s00 + this.s10 | 0;\n    var a0 = this.s10 ^ this.s00;\n    var a1 = this.s11 ^ this.s01;\n    var s00 = this.s00;\n    var s01 = this.s01;\n    this.s00 = s00 << 24 ^ s01 >>> 8 ^ a0 ^ a0 << 16;\n    this.s01 = s01 << 24 ^ s00 >>> 8 ^ a1 ^ (a1 << 16 | a0 >>> 16);\n    this.s10 = a1 << 5 ^ a0 >>> 27;\n    this.s11 = a0 << 5 ^ a1 >>> 27;\n    return out;\n  };\n  XoroShiro128Plus2.prototype.jump = function() {\n    var nextRng = new XoroShiro128Plus2(this.s01, this.s00, this.s11, this.s10);\n    nextRng.unsafeJump();\n    return nextRng;\n  };\n  XoroShiro128Plus2.prototype.unsafeJump = function() {\n    var ns01 = 0;\n    var ns00 = 0;\n    var ns11 = 0;\n    var ns10 = 0;\n    var jump = [3639956645, 3750757012, 1261568508, 386426335];\n    for (var i = 0; i !== 4; ++i) {\n      for (var mask = 1; mask; mask <<= 1) {\n        if (jump[i] & mask) {\n          ns01 ^= this.s01;\n          ns00 ^= this.s00;\n          ns11 ^= this.s11;\n          ns10 ^= this.s10;\n        }\n        this.unsafeNext();\n      }\n    }\n    this.s01 = ns01;\n    this.s00 = ns00;\n    this.s11 = ns11;\n    this.s10 = ns10;\n  };\n  XoroShiro128Plus2.prototype.getState = function() {\n    return [this.s01, this.s00, this.s11, this.s10];\n  };\n  return XoroShiro128Plus2;\n})();\nfunction fromState(state) {\n  var valid = state.length === 4;\n  if (!valid) {\n    throw new Error(\"The state must have been produced by a xoroshiro128plus RandomGenerator\");\n  }\n  return new XoroShiro128Plus(state[0], state[1], state[2], state[3]);\n}\nvar xoroshiro128plus = Object.assign(function(seed) {\n  return new XoroShiro128Plus(-1, ~seed, seed | 0, 0);\n}, { fromState });\n\n// src/server/rng.ts\nvar { asUintN } = BigInt;\nfunction pcg32(state) {\n  const MUL = 6364136223846793005n;\n  const INC = 11634580027462260723n;\n  state = asUintN(64, state * MUL + INC);\n  const xorshifted = Number(asUintN(32, (state >> 18n ^ state) >> 27n));\n  const rot = Number(asUintN(32, state >> 59n));\n  return xorshifted >> rot | xorshifted << 32 - rot;\n}\nfunction generateFloat64(rng) {\n  const g1 = unsafeUniformIntDistribution(0, (1 << 26) - 1, rng);\n  const g2 = unsafeUniformIntDistribution(0, (1 << 27) - 1, rng);\n  const value = (g1 * Math.pow(2, 27) + g2) * Math.pow(2, -53);\n  return value;\n}\nfunction makeRandom(seed) {\n  const rng = xoroshiro128plus(pcg32(seed.microsSinceUnixEpoch));\n  const random = () => generateFloat64(rng);\n  random.fill = (array) => {\n    const elem = array.at(0);\n    if (typeof elem === \"bigint\") {\n      const upper = (1n << BigInt(array.BYTES_PER_ELEMENT * 8)) - 1n;\n      for (let i = 0; i < array.length; i++) {\n        array[i] = unsafeUniformBigIntDistribution(0n, upper, rng);\n      }\n    } else if (typeof elem === \"number\") {\n      const upper = (1 << array.BYTES_PER_ELEMENT * 8) - 1;\n      for (let i = 0; i < array.length; i++) {\n        array[i] = unsafeUniformIntDistribution(0, upper, rng);\n      }\n    }\n    return array;\n  };\n  random.uint32 = () => rng.unsafeNext();\n  random.integerInRange = (min, max) => unsafeUniformIntDistribution(min, max, rng);\n  random.bigintInRange = (min, max) => unsafeUniformBigIntDistribution(min, max, rng);\n  return random;\n}\n\n// src/server/runtime.ts\nvar { freeze } = Object;\nvar sys = _syscalls2_0;\nfunction parseJsonObject(json) {\n  let value;\n  try {\n    value = JSON.parse(json);\n  } catch {\n    throw new Error(\"Invalid JSON: failed to parse string\");\n  }\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) {\n    throw new Error(\"Expected a JSON object at the top level\");\n  }\n  return value;\n}\nvar JwtClaimsImpl = class {\n  /**\n   * Creates a new JwtClaims instance.\n   * @param rawPayload The JWT payload as a raw JSON string.\n   * @param identity The identity for this JWT. We are only taking this because we don't have a blake3 implementation (which we need to compute it).\n   */\n  constructor(rawPayload, identity) {\n    this.rawPayload = rawPayload;\n    this.fullPayload = parseJsonObject(rawPayload);\n    this._identity = identity;\n  }\n  fullPayload;\n  _identity;\n  get identity() {\n    return this._identity;\n  }\n  get subject() {\n    return this.fullPayload[\"sub\"];\n  }\n  get issuer() {\n    return this.fullPayload[\"iss\"];\n  }\n  get audience() {\n    const aud = this.fullPayload[\"aud\"];\n    if (aud == null) {\n      return [];\n    }\n    return typeof aud === \"string\" ? [aud] : aud;\n  }\n};\nvar AuthCtxImpl = class _AuthCtxImpl {\n  isInternal;\n  // Source of the JWT payload string, if there is one.\n  _jwtSource;\n  // Whether we have initialized the JWT claims.\n  _initializedJWT = false;\n  _jwtClaims;\n  _senderIdentity;\n  constructor(opts) {\n    this.isInternal = opts.isInternal;\n    this._jwtSource = opts.jwtSource;\n    this._senderIdentity = opts.senderIdentity;\n  }\n  _initializeJWT() {\n    if (this._initializedJWT) return;\n    this._initializedJWT = true;\n    const token = this._jwtSource();\n    if (!token) {\n      this._jwtClaims = null;\n    } else {\n      this._jwtClaims = new JwtClaimsImpl(token, this._senderIdentity);\n    }\n    Object.freeze(this);\n  }\n  /** Lazily compute whether a JWT exists and is parseable. */\n  get hasJWT() {\n    this._initializeJWT();\n    return this._jwtClaims !== null;\n  }\n  /** Lazily parse the JwtClaims only when accessed. */\n  get jwt() {\n    this._initializeJWT();\n    return this._jwtClaims;\n  }\n  /** Create a context representing internal (non-user) requests. */\n  static internal() {\n    return new _AuthCtxImpl({\n      isInternal: true,\n      jwtSource: () => null,\n      senderIdentity: Identity.zero()\n    });\n  }\n  /** If there is a connection id, look up the JWT payload from the system tables. */\n  static fromSystemTables(connectionId, sender) {\n    if (connectionId === null) {\n      return new _AuthCtxImpl({\n        isInternal: false,\n        jwtSource: () => null,\n        senderIdentity: sender\n      });\n    }\n    return new _AuthCtxImpl({\n      isInternal: false,\n      jwtSource: () => {\n        const payloadBuf = sys.get_jwt_payload(connectionId.__connection_id__);\n        if (payloadBuf.length === 0) return null;\n        const payloadStr = new TextDecoder().decode(payloadBuf);\n        return payloadStr;\n      },\n      senderIdentity: sender\n    });\n  }\n};\nvar ReducerCtxImpl = class ReducerCtx {\n  #identity;\n  #senderAuth;\n  #uuidCounter;\n  #random;\n  sender;\n  timestamp;\n  connectionId;\n  db;\n  constructor(sender, timestamp, connectionId, dbView) {\n    Object.seal(this);\n    this.sender = sender;\n    this.timestamp = timestamp;\n    this.connectionId = connectionId;\n    this.db = dbView;\n  }\n  /** Reset the `ReducerCtx` to be used for a new transaction */\n  static reset(me, sender, timestamp, connectionId) {\n    me.sender = sender;\n    me.timestamp = timestamp;\n    me.connectionId = connectionId;\n    me.#uuidCounter = void 0;\n    me.#senderAuth = void 0;\n  }\n  get identity() {\n    return this.#identity ??= new Identity(sys.identity());\n  }\n  get senderAuth() {\n    return this.#senderAuth ??= AuthCtxImpl.fromSystemTables(\n      this.connectionId,\n      this.sender\n    );\n  }\n  get random() {\n    return this.#random ??= makeRandom(this.timestamp);\n  }\n  /**\n   * Create a new random {@link Uuid} `v4` using this `ReducerCtx`'s RNG.\n   */\n  newUuidV4() {\n    const bytes = this.random.fill(new Uint8Array(16));\n    return Uuid.fromRandomBytesV4(bytes);\n  }\n  /**\n   * Create a new sortable {@link Uuid} `v7` using this `ReducerCtx`'s RNG, counter,\n   * and timestamp.\n   */\n  newUuidV7() {\n    const bytes = this.random.fill(new Uint8Array(4));\n    const counter = this.#uuidCounter ??= { value: 0 };\n    return Uuid.fromCounterV7(counter, this.timestamp, bytes);\n  }\n};\nvar callUserFunction = function __spacetimedb_end_short_backtrace(fn, ...args) {\n  return fn(...args);\n};\nvar makeHooks = (schema2) => new ModuleHooksImpl(schema2);\nvar ModuleHooksImpl = class {\n  #schema;\n  #dbView_;\n  #reducerArgsDeserializers;\n  /** Cache the `ReducerCtx` object to avoid allocating anew for ever reducer call. */\n  #reducerCtx_;\n  constructor(schema2) {\n    this.#schema = schema2;\n    this.#reducerArgsDeserializers = schema2.moduleDef.reducers.map(\n      ({ params }) => ProductType.makeDeserializer(params, schema2.typespace)\n    );\n  }\n  get #dbView() {\n    return this.#dbView_ ??= freeze(\n      Object.fromEntries(\n        Object.values(this.#schema.schemaType.tables).map((table2) => [\n          table2.accessorName,\n          makeTableView(this.#schema.typespace, table2.tableDef)\n        ])\n      )\n    );\n  }\n  get #reducerCtx() {\n    return this.#reducerCtx_ ??= new ReducerCtxImpl(\n      Identity.zero(),\n      Timestamp.UNIX_EPOCH,\n      null,\n      this.#dbView\n    );\n  }\n  __describe_module__() {\n    const writer = new BinaryWriter(128);\n    RawModuleDef.serialize(\n      writer,\n      RawModuleDef.V10(this.#schema.rawModuleDefV10())\n    );\n    return writer.getBuffer();\n  }\n  __get_error_constructor__(code) {\n    return getErrorConstructor(code);\n  }\n  get __sender_error_class__() {\n    return SenderError;\n  }\n  __call_reducer__(reducerId, sender, connId, timestamp, argsBuf) {\n    const moduleCtx = this.#schema;\n    const deserializeArgs = this.#reducerArgsDeserializers[reducerId];\n    BINARY_READER.reset(argsBuf);\n    const args = deserializeArgs(BINARY_READER);\n    const senderIdentity = new Identity(sender);\n    const ctx = this.#reducerCtx;\n    ReducerCtxImpl.reset(\n      ctx,\n      senderIdentity,\n      new Timestamp(timestamp),\n      ConnectionId.nullIfZero(new ConnectionId(connId))\n    );\n    callUserFunction(moduleCtx.reducers[reducerId], ctx, args);\n  }\n  __call_view__(id, sender, argsBuf) {\n    const moduleCtx = this.#schema;\n    const { fn, deserializeParams, serializeReturn, returnTypeBaseSize } = moduleCtx.views[id];\n    const ctx = freeze({\n      sender: new Identity(sender),\n      // this is the non-readonly DbView, but the typing for the user will be\n      // the readonly one, and if they do call mutating functions it will fail\n      // at runtime\n      db: this.#dbView,\n      from: makeQueryBuilder(moduleCtx.schemaType)\n    });\n    const args = deserializeParams(new BinaryReader(argsBuf));\n    const ret = callUserFunction(fn, ctx, args);\n    const retBuf = new BinaryWriter(returnTypeBaseSize);\n    if (isRowTypedQuery(ret)) {\n      const query = toSql(ret);\n      ViewResultHeader.serialize(retBuf, ViewResultHeader.RawSql(query));\n    } else {\n      ViewResultHeader.serialize(retBuf, ViewResultHeader.RowData);\n      serializeReturn(retBuf, ret);\n    }\n    return { data: retBuf.getBuffer() };\n  }\n  __call_view_anon__(id, argsBuf) {\n    const moduleCtx = this.#schema;\n    const { fn, deserializeParams, serializeReturn, returnTypeBaseSize } = moduleCtx.anonViews[id];\n    const ctx = freeze({\n      // this is the non-readonly DbView, but the typing for the user will be\n      // the readonly one, and if they do call mutating functions it will fail\n      // at runtime\n      db: this.#dbView,\n      from: makeQueryBuilder(moduleCtx.schemaType)\n    });\n    const args = deserializeParams(new BinaryReader(argsBuf));\n    const ret = callUserFunction(fn, ctx, args);\n    const retBuf = new BinaryWriter(returnTypeBaseSize);\n    if (isRowTypedQuery(ret)) {\n      const query = toSql(ret);\n      ViewResultHeader.serialize(retBuf, ViewResultHeader.RawSql(query));\n    } else {\n      ViewResultHeader.serialize(retBuf, ViewResultHeader.RowData);\n      serializeReturn(retBuf, ret);\n    }\n    return { data: retBuf.getBuffer() };\n  }\n  __call_procedure__(id, sender, connection_id, timestamp, args) {\n    return callProcedure(\n      this.#schema,\n      id,\n      new Identity(sender),\n      ConnectionId.nullIfZero(new ConnectionId(connection_id)),\n      new Timestamp(timestamp),\n      args,\n      () => this.#dbView\n    );\n  }\n};\nvar BINARY_WRITER = new BinaryWriter(0);\nvar BINARY_READER = new BinaryReader(new Uint8Array());\nfunction makeTableView(typespace, table2) {\n  const table_id = sys.table_id_from_name(table2.sourceName);\n  const rowType = typespace.types[table2.productTypeRef];\n  if (rowType.tag !== \"Product\") {\n    throw \"impossible\";\n  }\n  const serializeRow = AlgebraicType.makeSerializer(rowType, typespace);\n  const deserializeRow = AlgebraicType.makeDeserializer(rowType, typespace);\n  const sequences = table2.sequences.map((seq) => {\n    const col = rowType.value.elements[seq.column];\n    const colType = col.algebraicType;\n    let sequenceTrigger;\n    switch (colType.tag) {\n      case \"U8\":\n      case \"I8\":\n      case \"U16\":\n      case \"I16\":\n      case \"U32\":\n      case \"I32\":\n        sequenceTrigger = 0;\n        break;\n      case \"U64\":\n      case \"I64\":\n      case \"U128\":\n      case \"I128\":\n      case \"U256\":\n      case \"I256\":\n        sequenceTrigger = 0n;\n        break;\n      default:\n        throw new TypeError(\"invalid sequence type\");\n    }\n    return {\n      colName: col.name,\n      sequenceTrigger,\n      deserialize: AlgebraicType.makeDeserializer(colType, typespace)\n    };\n  });\n  const hasAutoIncrement = sequences.length > 0;\n  const iter = () => tableIterator(sys.datastore_table_scan_bsatn(table_id), deserializeRow);\n  const integrateGeneratedColumns = hasAutoIncrement ? (row, ret_buf) => {\n    BINARY_READER.reset(ret_buf);\n    for (const { colName, deserialize, sequenceTrigger } of sequences) {\n      if (row[colName] === sequenceTrigger) {\n        row[colName] = deserialize(BINARY_READER);\n      }\n    }\n  } : null;\n  const tableMethods = {\n    count: () => sys.datastore_table_row_count(table_id),\n    iter,\n    [Symbol.iterator]: () => iter(),\n    insert: (row) => {\n      const buf = LEAF_BUF;\n      BINARY_WRITER.reset(buf);\n      serializeRow(BINARY_WRITER, row);\n      sys.datastore_insert_bsatn(table_id, buf.buffer, BINARY_WRITER.offset);\n      const ret = { ...row };\n      integrateGeneratedColumns?.(ret, buf.view);\n      return ret;\n    },\n    delete: (row) => {\n      const buf = LEAF_BUF;\n      BINARY_WRITER.reset(buf);\n      BINARY_WRITER.writeU32(1);\n      serializeRow(BINARY_WRITER, row);\n      const count = sys.datastore_delete_all_by_eq_bsatn(\n        table_id,\n        buf.buffer,\n        BINARY_WRITER.offset\n      );\n      return count > 0;\n    }\n  };\n  const tableView = Object.assign(\n    /* @__PURE__ */ Object.create(null),\n    tableMethods\n  );\n  for (const indexDef of table2.indexes) {\n    const accessorName = indexDef.accessorName;\n    const index_id = sys.index_id_from_name(indexDef.sourceName);\n    let column_ids;\n    let isHashIndex = false;\n    switch (indexDef.algorithm.tag) {\n      case \"Hash\":\n        isHashIndex = true;\n        column_ids = indexDef.algorithm.value;\n        break;\n      case \"BTree\":\n        column_ids = indexDef.algorithm.value;\n        break;\n      case \"Direct\":\n        column_ids = [indexDef.algorithm.value];\n        break;\n    }\n    const numColumns = column_ids.length;\n    const columnSet = new Set(column_ids);\n    const isUnique = table2.constraints.filter((x) => x.data.tag === \"Unique\").some((x) => columnSet.isSubsetOf(new Set(x.data.value.columns)));\n    const isPrimaryKey = isUnique && column_ids.length === table2.primaryKey.length && column_ids.every((id, i) => table2.primaryKey[i] === id);\n    const indexSerializers = column_ids.map(\n      (id) => AlgebraicType.makeSerializer(\n        rowType.value.elements[id].algebraicType,\n        typespace\n      )\n    );\n    const serializePoint = (buffer, colVal) => {\n      BINARY_WRITER.reset(buffer);\n      for (let i = 0; i < numColumns; i++) {\n        indexSerializers[i](BINARY_WRITER, colVal[i]);\n      }\n      return BINARY_WRITER.offset;\n    };\n    const serializeSingleElement = numColumns === 1 ? indexSerializers[0] : null;\n    const serializeSinglePoint = serializeSingleElement && ((buffer, colVal) => {\n      BINARY_WRITER.reset(buffer);\n      serializeSingleElement(BINARY_WRITER, colVal);\n      return BINARY_WRITER.offset;\n    });\n    let index;\n    if (isUnique && serializeSinglePoint) {\n      const base = {\n        find: (colVal) => {\n          const buf = LEAF_BUF;\n          const point_len = serializeSinglePoint(buf, colVal);\n          const iter_id = sys.datastore_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return tableIterateOne(iter_id, deserializeRow);\n        },\n        delete: (colVal) => {\n          const buf = LEAF_BUF;\n          const point_len = serializeSinglePoint(buf, colVal);\n          const num = sys.datastore_delete_by_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return num > 0;\n        }\n      };\n      if (isPrimaryKey) {\n        base.update = (row) => {\n          const buf = LEAF_BUF;\n          BINARY_WRITER.reset(buf);\n          serializeRow(BINARY_WRITER, row);\n          sys.datastore_update_bsatn(\n            table_id,\n            index_id,\n            buf.buffer,\n            BINARY_WRITER.offset\n          );\n          integrateGeneratedColumns?.(row, buf.view);\n          return row;\n        };\n      }\n      index = base;\n    } else if (isUnique) {\n      const base = {\n        find: (colVal) => {\n          if (colVal.length !== numColumns) {\n            throw new TypeError(\"wrong number of elements\");\n          }\n          const buf = LEAF_BUF;\n          const point_len = serializePoint(buf, colVal);\n          const iter_id = sys.datastore_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return tableIterateOne(iter_id, deserializeRow);\n        },\n        delete: (colVal) => {\n          if (colVal.length !== numColumns)\n            throw new TypeError(\"wrong number of elements\");\n          const buf = LEAF_BUF;\n          const point_len = serializePoint(buf, colVal);\n          const num = sys.datastore_delete_by_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return num > 0;\n        }\n      };\n      if (isPrimaryKey) {\n        base.update = (row) => {\n          const buf = LEAF_BUF;\n          BINARY_WRITER.reset(buf);\n          serializeRow(BINARY_WRITER, row);\n          sys.datastore_update_bsatn(\n            table_id,\n            index_id,\n            buf.buffer,\n            BINARY_WRITER.offset\n          );\n          integrateGeneratedColumns?.(row, buf.view);\n          return row;\n        };\n      }\n      index = base;\n    } else if (serializeSinglePoint) {\n      const rawIndex = {\n        filter: (range) => {\n          const buf = LEAF_BUF;\n          const point_len = serializeSinglePoint(buf, range);\n          const iter_id = sys.datastore_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return tableIterator(iter_id, deserializeRow);\n        },\n        delete: (range) => {\n          const buf = LEAF_BUF;\n          const point_len = serializeSinglePoint(buf, range);\n          return sys.datastore_delete_by_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n        }\n      };\n      if (isHashIndex) {\n        index = rawIndex;\n      } else {\n        index = rawIndex;\n      }\n    } else if (isHashIndex) {\n      index = {\n        filter: (range) => {\n          const buf = LEAF_BUF;\n          const point_len = serializePoint(buf, range);\n          const iter_id = sys.datastore_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n          return tableIterator(iter_id, deserializeRow);\n        },\n        delete: (range) => {\n          const buf = LEAF_BUF;\n          const point_len = serializePoint(buf, range);\n          return sys.datastore_delete_by_index_scan_point_bsatn(\n            index_id,\n            buf.buffer,\n            point_len\n          );\n        }\n      };\n    } else {\n      const serializeRange = (buffer, range) => {\n        if (range.length > numColumns) throw new TypeError(\"too many elements\");\n        BINARY_WRITER.reset(buffer);\n        const writer = BINARY_WRITER;\n        const prefix_elems = range.length - 1;\n        for (let i = 0; i < prefix_elems; i++) {\n          indexSerializers[i](writer, range[i]);\n        }\n        const rstartOffset = writer.offset;\n        const term = range[range.length - 1];\n        const serializeTerm = indexSerializers[range.length - 1];\n        if (term instanceof Range) {\n          const writeBound = (bound) => {\n            const tags = { included: 0, excluded: 1, unbounded: 2 };\n            writer.writeU8(tags[bound.tag]);\n            if (bound.tag !== \"unbounded\") serializeTerm(writer, bound.value);\n          };\n          writeBound(term.from);\n          const rstartLen = writer.offset - rstartOffset;\n          writeBound(term.to);\n          const rendLen = writer.offset - rstartLen;\n          return [rstartOffset, prefix_elems, rstartLen, rendLen];\n        } else {\n          writer.writeU8(0);\n          serializeTerm(writer, term);\n          const rstartLen = writer.offset;\n          const rendLen = 0;\n          return [rstartOffset, prefix_elems, rstartLen, rendLen];\n        }\n      };\n      index = {\n        filter: (range) => {\n          if (range.length === numColumns) {\n            const buf = LEAF_BUF;\n            const point_len = serializePoint(buf, range);\n            const iter_id = sys.datastore_index_scan_point_bsatn(\n              index_id,\n              buf.buffer,\n              point_len\n            );\n            return tableIterator(iter_id, deserializeRow);\n          } else {\n            const buf = LEAF_BUF;\n            const args = serializeRange(buf, range);\n            const iter_id = sys.datastore_index_scan_range_bsatn(\n              index_id,\n              buf.buffer,\n              ...args\n            );\n            return tableIterator(iter_id, deserializeRow);\n          }\n        },\n        delete: (range) => {\n          if (range.length === numColumns) {\n            const buf = LEAF_BUF;\n            const point_len = serializePoint(buf, range);\n            return sys.datastore_delete_by_index_scan_point_bsatn(\n              index_id,\n              buf.buffer,\n              point_len\n            );\n          } else {\n            const buf = LEAF_BUF;\n            const args = serializeRange(buf, range);\n            return sys.datastore_delete_by_index_scan_range_bsatn(\n              index_id,\n              buf.buffer,\n              ...args\n            );\n          }\n        }\n      };\n    }\n    if (Object.hasOwn(tableView, accessorName)) {\n      freeze(Object.assign(tableView[accessorName], index));\n    } else {\n      tableView[accessorName] = freeze(index);\n    }\n  }\n  return freeze(tableView);\n}\nfunction* tableIterator(id, deserialize) {\n  using iter = new IteratorHandle(id);\n  const iterBuf = takeBuf();\n  try {\n    let amt;\n    while (amt = iter.advance(iterBuf)) {\n      const reader = new BinaryReader(iterBuf.view);\n      while (reader.offset < amt) {\n        yield deserialize(reader);\n      }\n    }\n  } finally {\n    returnBuf(iterBuf);\n  }\n}\nfunction tableIterateOne(id, deserialize) {\n  const buf = LEAF_BUF;\n  const ret = advanceIterRaw(id, buf);\n  if (ret !== 0) {\n    BINARY_READER.reset(buf.view);\n    return deserialize(BINARY_READER);\n  }\n  return null;\n}\nfunction advanceIterRaw(id, buf) {\n  while (true) {\n    try {\n      return 0 | sys.row_iter_bsatn_advance(id, buf.buffer);\n    } catch (e) {\n      if (e && typeof e === \"object\" && hasOwn(e, \"__buffer_too_small__\")) {\n        buf.grow(e.__buffer_too_small__);\n        continue;\n      }\n      throw e;\n    }\n  }\n}\nvar DEFAULT_BUFFER_CAPACITY = 32 * 1024 * 2;\nvar ITER_BUFS = [\n  new ResizableBuffer(DEFAULT_BUFFER_CAPACITY)\n];\nvar ITER_BUF_COUNT = 1;\nfunction takeBuf() {\n  return ITER_BUF_COUNT ? ITER_BUFS[--ITER_BUF_COUNT] : new ResizableBuffer(DEFAULT_BUFFER_CAPACITY);\n}\nfunction returnBuf(buf) {\n  ITER_BUFS[ITER_BUF_COUNT++] = buf;\n}\nvar LEAF_BUF = new ResizableBuffer(DEFAULT_BUFFER_CAPACITY);\nvar IteratorHandle = class _IteratorHandle {\n  #id;\n  static #finalizationRegistry = new FinalizationRegistry(\n    sys.row_iter_bsatn_close\n  );\n  constructor(id) {\n    this.#id = id;\n    _IteratorHandle.#finalizationRegistry.register(this, id, this);\n  }\n  /** Unregister this object with the finalization registry and return the id */\n  #detach() {\n    const id = this.#id;\n    this.#id = -1;\n    _IteratorHandle.#finalizationRegistry.unregister(this);\n    return id;\n  }\n  /** Call `row_iter_bsatn_advance`, returning 0 if this iterator has been exhausted. */\n  advance(buf) {\n    if (this.#id === -1) return 0;\n    const ret = advanceIterRaw(this.#id, buf);\n    if (ret <= 0) this.#detach();\n    return ret < 0 ? -ret : ret;\n  }\n  [Symbol.dispose]() {\n    if (this.#id >= 0) {\n      const id = this.#detach();\n      sys.row_iter_bsatn_close(id);\n    }\n  }\n};\n\n// src/server/http_internal.ts\nvar { freeze: freeze2 } = Object;\nvar textEncoder = new TextEncoder();\nvar textDecoder = new TextDecoder(\n  \"utf-8\"\n  /* { fatal: true } */\n);\nvar makeResponse = Symbol(\"makeResponse\");\nvar SyncResponse = class _SyncResponse {\n  #body;\n  #inner;\n  constructor(body, init) {\n    if (body == null) {\n      this.#body = null;\n    } else if (typeof body === \"string\") {\n      this.#body = body;\n    } else {\n      this.#body = new Uint8Array(body).buffer;\n    }\n    this.#inner = {\n      headers: new Headers(init?.headers),\n      status: init?.status ?? 200,\n      statusText: init?.statusText ?? \"\",\n      type: \"default\",\n      url: null,\n      aborted: false\n    };\n  }\n  static [makeResponse](body, inner) {\n    const me = new _SyncResponse(body);\n    me.#inner = inner;\n    return me;\n  }\n  get headers() {\n    return this.#inner.headers;\n  }\n  get status() {\n    return this.#inner.status;\n  }\n  get statusText() {\n    return this.#inner.statusText;\n  }\n  get ok() {\n    return 200 <= this.#inner.status && this.#inner.status <= 299;\n  }\n  get url() {\n    return this.#inner.url ?? \"\";\n  }\n  get type() {\n    return this.#inner.type;\n  }\n  arrayBuffer() {\n    return this.bytes().buffer;\n  }\n  bytes() {\n    if (this.#body == null) {\n      return new Uint8Array();\n    } else if (typeof this.#body === \"string\") {\n      return textEncoder.encode(this.#body);\n    } else {\n      return new Uint8Array(this.#body);\n    }\n  }\n  json() {\n    return JSON.parse(this.text());\n  }\n  text() {\n    if (this.#body == null) {\n      return \"\";\n    } else if (typeof this.#body === \"string\") {\n      return this.#body;\n    } else {\n      return textDecoder.decode(this.#body);\n    }\n  }\n};\nvar requestBaseSize = bsatnBaseSize({ types: [] }, HttpRequest.algebraicType);\nvar methods = /* @__PURE__ */ new Map([\n  [\"GET\", { tag: \"Get\" }],\n  [\"HEAD\", { tag: \"Head\" }],\n  [\"POST\", { tag: \"Post\" }],\n  [\"PUT\", { tag: \"Put\" }],\n  [\"DELETE\", { tag: \"Delete\" }],\n  [\"CONNECT\", { tag: \"Connect\" }],\n  [\"OPTIONS\", { tag: \"Options\" }],\n  [\"TRACE\", { tag: \"Trace\" }],\n  [\"PATCH\", { tag: \"Patch\" }]\n]);\nfunction fetch(url, init = {}) {\n  const method = methods.get(init.method?.toUpperCase() ?? \"GET\") ?? {\n    tag: \"Extension\",\n    value: init.method\n  };\n  const headers = {\n    // anys because the typings are wonky - see comment in SyncResponse.constructor\n    entries: headersToList(new Headers(init.headers)).flatMap(([k, v]) => Array.isArray(v) ? v.map((v2) => [k, v2]) : [[k, v]]).map(([name, value]) => ({ name, value: textEncoder.encode(value) }))\n  };\n  const uri = \"\" + url;\n  const request = freeze2({\n    method,\n    headers,\n    timeout: init.timeout,\n    uri,\n    version: { tag: \"Http11\" }\n  });\n  const requestBuf = new BinaryWriter(requestBaseSize);\n  HttpRequest.serialize(requestBuf, request);\n  const body = init.body == null ? new Uint8Array() : typeof init.body === \"string\" ? init.body : new Uint8Array(init.body);\n  const [responseBuf, responseBody] = sys.procedure_http_request(\n    requestBuf.getBuffer(),\n    body\n  );\n  const response = HttpResponse.deserialize(new BinaryReader(responseBuf));\n  return SyncResponse[makeResponse](responseBody, {\n    type: \"basic\",\n    url: uri,\n    status: response.code,\n    statusText: (0, import_statuses.default)(response.code),\n    headers: new Headers(),\n    aborted: false\n  });\n}\nfreeze2(fetch);\nvar httpClient = freeze2({ fetch });\n\n// src/server/procedures.ts\nfunction makeProcedureExport(ctx, opts, params, ret, fn) {\n  const name = opts?.name;\n  const procedureExport = (...args) => fn(...args);\n  procedureExport[exportContext] = ctx;\n  procedureExport[registerExport] = (ctx2, exportName) => {\n    registerProcedure(ctx2, name ?? exportName, params, ret, fn);\n    ctx2.functionExports.set(\n      procedureExport,\n      name ?? exportName\n    );\n  };\n  return procedureExport;\n}\nvar TransactionCtxImpl = class TransactionCtx extends ReducerCtxImpl {\n};\nfunction registerProcedure(ctx, exportName, params, ret, fn, opts) {\n  ctx.defineFunction(exportName);\n  const paramsType = {\n    elements: Object.entries(params).map(([n, c]) => ({\n      name: n,\n      algebraicType: ctx.registerTypesRecursively(\n        \"typeBuilder\" in c ? c.typeBuilder : c\n      ).algebraicType\n    }))\n  };\n  const returnType = ctx.registerTypesRecursively(ret).algebraicType;\n  ctx.moduleDef.procedures.push({\n    sourceName: exportName,\n    params: paramsType,\n    returnType,\n    visibility: FunctionVisibility.ClientCallable\n  });\n  const { typespace } = ctx;\n  ctx.procedures.push({\n    fn,\n    deserializeArgs: ProductType.makeDeserializer(paramsType, typespace),\n    serializeReturn: AlgebraicType.makeSerializer(returnType, typespace),\n    returnTypeBaseSize: bsatnBaseSize(typespace, returnType)\n  });\n}\nfunction callProcedure(moduleCtx, id, sender, connectionId, timestamp, argsBuf, dbView) {\n  const { fn, deserializeArgs, serializeReturn, returnTypeBaseSize } = moduleCtx.procedures[id];\n  const args = deserializeArgs(new BinaryReader(argsBuf));\n  const ctx = new ProcedureCtxImpl(\n    sender,\n    timestamp,\n    connectionId,\n    dbView\n  );\n  const ret = callUserFunction(fn, ctx, args);\n  const retBuf = new BinaryWriter(returnTypeBaseSize);\n  serializeReturn(retBuf, ret);\n  return retBuf.getBuffer();\n}\nvar ProcedureCtxImpl = class ProcedureCtx {\n  constructor(sender, timestamp, connectionId, dbView) {\n    this.sender = sender;\n    this.timestamp = timestamp;\n    this.connectionId = connectionId;\n    this.#dbView = dbView;\n  }\n  #identity;\n  #uuidCounter;\n  #random;\n  #dbView;\n  get identity() {\n    return this.#identity ??= new Identity(sys.identity());\n  }\n  get random() {\n    return this.#random ??= makeRandom(this.timestamp);\n  }\n  get http() {\n    return httpClient;\n  }\n  withTx(body) {\n    const run = () => {\n      const timestamp = sys.procedure_start_mut_tx();\n      try {\n        const ctx = new TransactionCtxImpl(\n          this.sender,\n          new Timestamp(timestamp),\n          this.connectionId,\n          this.#dbView()\n        );\n        return body(ctx);\n      } catch (e) {\n        sys.procedure_abort_mut_tx();\n        throw e;\n      }\n    };\n    let res = run();\n    try {\n      sys.procedure_commit_mut_tx();\n      return res;\n    } catch {\n    }\n    console.warn(\"committing anonymous transaction failed\");\n    res = run();\n    try {\n      sys.procedure_commit_mut_tx();\n      return res;\n    } catch (e) {\n      throw new Error(\"transaction retry failed again\", { cause: e });\n    }\n  }\n  newUuidV4() {\n    const bytes = this.random.fill(new Uint8Array(16));\n    return Uuid.fromRandomBytesV4(bytes);\n  }\n  newUuidV7() {\n    const bytes = this.random.fill(new Uint8Array(4));\n    const counter = this.#uuidCounter ??= { value: 0 };\n    return Uuid.fromCounterV7(counter, this.timestamp, bytes);\n  }\n};\n\n// src/server/reducers.ts\nfunction makeReducerExport(ctx, opts, params, fn, lifecycle) {\n  const reducerExport = (...args) => fn(...args);\n  reducerExport[exportContext] = ctx;\n  reducerExport[registerExport] = (ctx2, exportName) => {\n    registerReducer(ctx2, exportName, params, fn, opts, lifecycle);\n    ctx2.functionExports.set(\n      reducerExport,\n      exportName\n    );\n  };\n  return reducerExport;\n}\nfunction registerReducer(ctx, exportName, params, fn, opts, lifecycle) {\n  ctx.defineFunction(exportName);\n  if (!(params instanceof RowBuilder)) {\n    params = new RowBuilder(params);\n  }\n  if (params.typeName === void 0) {\n    params.typeName = toPascalCase(exportName);\n  }\n  const ref = ctx.registerTypesRecursively(params);\n  const paramsType = ctx.resolveType(ref).value;\n  const isLifecycle = lifecycle != null;\n  ctx.moduleDef.reducers.push({\n    sourceName: exportName,\n    params: paramsType,\n    //ModuleDef validation code is responsible to mark private reducers\n    visibility: FunctionVisibility.ClientCallable,\n    //Hardcoded for now - reducers do not return values yet\n    okReturnType: AlgebraicType.Product({ elements: [] }),\n    errReturnType: AlgebraicType.String\n  });\n  if (opts?.name != null) {\n    ctx.moduleDef.explicitNames.entries.push({\n      tag: \"Function\",\n      value: {\n        sourceName: exportName,\n        canonicalName: opts.name\n      }\n    });\n  }\n  if (isLifecycle) {\n    ctx.moduleDef.lifeCycleReducers.push({\n      lifecycleSpec: lifecycle,\n      functionName: exportName\n    });\n  }\n  if (!fn.name) {\n    Object.defineProperty(fn, \"name\", { value: exportName, writable: false });\n  }\n  ctx.reducers.push(fn);\n}\n\n// src/server/schema.ts\nvar SchemaInner = class extends ModuleContext {\n  schemaType;\n  existingFunctions = /* @__PURE__ */ new Set();\n  reducers = [];\n  procedures = [];\n  views = [];\n  anonViews = [];\n  /**\n   * Maps ReducerExport objects to the name of the reducer.\n   * Used for resolving the reducers of scheduled tables.\n   */\n  functionExports = /* @__PURE__ */ new Map();\n  pendingSchedules = [];\n  constructor(getSchemaType) {\n    super();\n    this.schemaType = getSchemaType(this);\n  }\n  defineFunction(name) {\n    if (this.existingFunctions.has(name)) {\n      throw new TypeError(\n        `There is already a reducer or procedure with the name '${name}'`\n      );\n    }\n    this.existingFunctions.add(name);\n  }\n  resolveSchedules() {\n    for (const { reducer, scheduleAtCol, tableName } of this.pendingSchedules) {\n      const functionName = this.functionExports.get(reducer());\n      if (functionName === void 0) {\n        const msg = `Table ${tableName} defines a schedule, but it seems like the associated function was not exported.`;\n        throw new TypeError(msg);\n      }\n      this.moduleDef.schedules.push({\n        sourceName: void 0,\n        tableName,\n        scheduleAtCol,\n        functionName\n      });\n    }\n  }\n};\nvar Schema = class {\n  #ctx;\n  constructor(ctx) {\n    this.#ctx = ctx;\n  }\n  [moduleHooks](exports) {\n    const registeredSchema = this.#ctx;\n    for (const [name, moduleExport] of Object.entries(exports)) {\n      if (name === \"default\") continue;\n      if (!isModuleExport(moduleExport)) {\n        throw new TypeError(\n          \"exporting something that is not a spacetime export\"\n        );\n      }\n      checkExportContext(moduleExport, registeredSchema);\n      moduleExport[registerExport](registeredSchema, name);\n    }\n    registeredSchema.resolveSchedules();\n    return makeHooks(registeredSchema);\n  }\n  get schemaType() {\n    return this.#ctx.schemaType;\n  }\n  get moduleDef() {\n    return this.#ctx.moduleDef;\n  }\n  get typespace() {\n    return this.#ctx.typespace;\n  }\n  reducer(...args) {\n    let opts, params = {}, fn;\n    switch (args.length) {\n      case 1:\n        [fn] = args;\n        break;\n      case 2: {\n        let arg1;\n        [arg1, fn] = args;\n        if (typeof arg1.name === \"string\") opts = arg1;\n        else params = arg1;\n        break;\n      }\n      case 3:\n        [opts, params, fn] = args;\n        break;\n    }\n    return makeReducerExport(this.#ctx, opts, params, fn);\n  }\n  init(...args) {\n    let opts, fn;\n    switch (args.length) {\n      case 1:\n        [fn] = args;\n        break;\n      case 2:\n        [opts, fn] = args;\n        break;\n    }\n    return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.Init);\n  }\n  clientConnected(...args) {\n    let opts, fn;\n    switch (args.length) {\n      case 1:\n        [fn] = args;\n        break;\n      case 2:\n        [opts, fn] = args;\n        break;\n    }\n    return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.OnConnect);\n  }\n  clientDisconnected(...args) {\n    let opts, fn;\n    switch (args.length) {\n      case 1:\n        [fn] = args;\n        break;\n      case 2:\n        [opts, fn] = args;\n        break;\n    }\n    return makeReducerExport(this.#ctx, opts, {}, fn, Lifecycle.OnDisconnect);\n  }\n  view(opts, ret, fn) {\n    return makeViewExport(this.#ctx, opts, {}, ret, fn);\n  }\n  // TODO: re-enable once parameterized views are supported in SQL\n  // view<Ret extends ViewReturnTypeBuilder>(\n  //   opts: ViewOpts,\n  //   ret: Ret,\n  //   fn: ViewFn<S, {}, Ret>\n  // ): void;\n  // view<Params extends ParamsObj, Ret extends ViewReturnTypeBuilder>(\n  //   opts: ViewOpts,\n  //   params: Params,\n  //   ret: Ret,\n  //   fn: ViewFn<S, {}, Ret>\n  // ): void;\n  // view<Params extends ParamsObj, Ret extends ViewReturnTypeBuilder>(\n  //   opts: ViewOpts,\n  //   paramsOrRet: Ret | Params,\n  //   retOrFn: ViewFn<S, {}, Ret> | Ret,\n  //   maybeFn?: ViewFn<S, Params, Ret>\n  // ): void {\n  //   if (typeof retOrFn === 'function') {\n  //     defineView(name, false, {}, paramsOrRet as Ret, retOrFn);\n  //   } else {\n  //     defineView(name, false, paramsOrRet as Params, retOrFn, maybeFn!);\n  //   }\n  // }\n  anonymousView(opts, ret, fn) {\n    return makeAnonViewExport(this.#ctx, opts, {}, ret, fn);\n  }\n  procedure(...args) {\n    let opts, params = {}, ret, fn;\n    switch (args.length) {\n      case 2:\n        [ret, fn] = args;\n        break;\n      case 3: {\n        let arg1;\n        [arg1, ret, fn] = args;\n        if (typeof arg1.name === \"string\") opts = arg1;\n        else params = arg1;\n        break;\n      }\n      case 4:\n        [opts, params, ret, fn] = args;\n        break;\n    }\n    return makeProcedureExport(this.#ctx, opts, params, ret, fn);\n  }\n  /**\n   * Bundle multiple reducers, procedures, etc into one value to export.\n   * The name they will be exported with is their corresponding key in the `exports` argument.\n   */\n  exportGroup(exports) {\n    return {\n      [exportContext]: this.#ctx,\n      [registerExport](ctx, _exportName) {\n        for (const [exportName, moduleExport] of Object.entries(exports)) {\n          checkExportContext(moduleExport, ctx);\n          moduleExport[registerExport](ctx, exportName);\n        }\n      }\n    };\n  }\n  clientVisibilityFilter = {\n    sql: (filter) => ({\n      [exportContext]: this.#ctx,\n      [registerExport](ctx, _exportName) {\n        ctx.moduleDef.rowLevelSecurity.push({ sql: filter });\n      }\n    })\n  };\n};\nvar registerExport = Symbol(\"SpacetimeDB.registerExport\");\nvar exportContext = Symbol(\"SpacetimeDB.exportContext\");\nfunction isModuleExport(x) {\n  return (typeof x === \"function\" || typeof x === \"object\") && x !== null && registerExport in x;\n}\nfunction checkExportContext(exp, schema2) {\n  if (exp[exportContext] != null && exp[exportContext] !== schema2) {\n    throw new TypeError(\"multiple schemas are not supported\");\n  }\n}\nfunction schema(tables, moduleSettings) {\n  const ctx = new SchemaInner((ctx2) => {\n    if (moduleSettings?.CASE_CONVERSION_POLICY != null) {\n      ctx2.setCaseConversionPolicy(moduleSettings.CASE_CONVERSION_POLICY);\n    }\n    const tableSchemas = {};\n    for (const [accName, table2] of Object.entries(tables)) {\n      const tableDef = table2.tableDef(ctx2, accName);\n      tableSchemas[accName] = tableToSchema(accName, table2, tableDef);\n      ctx2.moduleDef.tables.push(tableDef);\n      if (table2.schedule) {\n        ctx2.pendingSchedules.push({\n          ...table2.schedule,\n          tableName: tableDef.sourceName\n        });\n      }\n      if (table2.tableName) {\n        ctx2.moduleDef.explicitNames.entries.push({\n          tag: \"Table\",\n          value: {\n            sourceName: accName,\n            canonicalName: table2.tableName\n          }\n        });\n      }\n    }\n    return { tables: tableSchemas };\n  });\n  return new Schema(ctx);\n}\n\n// src/server/console.ts\nvar import_object_inspect = __toESM(require_object_inspect());\nvar fmtLog = (...data) => data.map((x) => typeof x === \"string\" ? x : (0, import_object_inspect.default)(x)).join(\" \");\nvar console_level_error = 0;\nvar console_level_warn = 1;\nvar console_level_info = 2;\nvar console_level_debug = 3;\nvar console_level_trace = 4;\nvar timerMap = /* @__PURE__ */ new Map();\nvar console2 = {\n  // @ts-expect-error we want a blank prototype, but typescript complains\n  __proto__: {},\n  [Symbol.toStringTag]: \"console\",\n  assert: (condition = false, ...data) => {\n    if (!condition) {\n      sys.console_log(console_level_error, fmtLog(...data));\n    }\n  },\n  clear: () => {\n  },\n  debug: (...data) => {\n    sys.console_log(console_level_debug, fmtLog(...data));\n  },\n  error: (...data) => {\n    sys.console_log(console_level_error, fmtLog(...data));\n  },\n  info: (...data) => {\n    sys.console_log(console_level_info, fmtLog(...data));\n  },\n  log: (...data) => {\n    sys.console_log(console_level_info, fmtLog(...data));\n  },\n  table: (tabularData, _properties) => {\n    sys.console_log(console_level_info, fmtLog(tabularData));\n  },\n  trace: (...data) => {\n    sys.console_log(console_level_trace, fmtLog(...data));\n  },\n  warn: (...data) => {\n    sys.console_log(console_level_warn, fmtLog(...data));\n  },\n  dir: (_item, _options) => {\n  },\n  dirxml: (..._data) => {\n  },\n  // Counting\n  count: (_label = \"default\") => {\n  },\n  countReset: (_label = \"default\") => {\n  },\n  // Grouping\n  group: (..._data) => {\n  },\n  groupCollapsed: (..._data) => {\n  },\n  groupEnd: () => {\n  },\n  // Timing\n  time: (label = \"default\") => {\n    if (timerMap.has(label)) {\n      sys.console_log(console_level_warn, `Timer '${label}' already exists.`);\n      return;\n    }\n    timerMap.set(label, sys.console_timer_start(label));\n  },\n  timeLog: (label = \"default\", ...data) => {\n    sys.console_log(console_level_info, fmtLog(label, ...data));\n  },\n  timeEnd: (label = \"default\") => {\n    const spanId = timerMap.get(label);\n    if (spanId === void 0) {\n      sys.console_log(console_level_warn, `Timer '${label}' does not exist.`);\n      return;\n    }\n    sys.console_timer_end(spanId);\n    timerMap.delete(label);\n  },\n  // Additional console methods to satisfy the Console interface\n  timeStamp: () => {\n  },\n  profile: () => {\n  },\n  profileEnd: () => {\n  }\n};\n\n// src/server/polyfills.ts\nglobalThis.console = console2;\n/*! Bundled license information:\n\nstatuses/index.js:\n  (*!\n   * statuses\n   * Copyright(c) 2014 Jonathan Ong\n   * Copyright(c) 2016 Douglas Christopher Wilson\n   * MIT Licensed\n   *)\n*/\n\nexport { ArrayBuilder, ArrayColumnBuilder, BoolBuilder, BoolColumnBuilder, BooleanExpr, ByteArrayBuilder, ByteArrayColumnBuilder, CaseConversionPolicy, ColumnBuilder, ColumnExpression, ConnectionIdBuilder, ConnectionIdColumnBuilder, F32Builder, F32ColumnBuilder, F64Builder, F64ColumnBuilder, I128Builder, I128ColumnBuilder, I16Builder, I16ColumnBuilder, I256Builder, I256ColumnBuilder, I32Builder, I32ColumnBuilder, I64Builder, I64ColumnBuilder, I8Builder, I8ColumnBuilder, IdentityBuilder, IdentityColumnBuilder, OptionBuilder, OptionColumnBuilder, ProductBuilder, ProductColumnBuilder, Range, RefBuilder, ResultBuilder, ResultColumnBuilder, RowBuilder, ScheduleAtBuilder, ScheduleAtColumnBuilder, SenderError, SimpleSumBuilder, SimpleSumColumnBuilder, SpacetimeHostError, StringBuilder, StringColumnBuilder, SumBuilder, SumColumnBuilder, TimeDurationBuilder, TimeDurationColumnBuilder, TimestampBuilder, TimestampColumnBuilder, TypeBuilder, U128Builder, U128ColumnBuilder, U16Builder, U16ColumnBuilder, U256Builder, U256ColumnBuilder, U32Builder, U32ColumnBuilder, U64Builder, U64ColumnBuilder, U8Builder, U8ColumnBuilder, UuidBuilder, UuidColumnBuilder, and, createTableRefFromDef, errors, evaluateBooleanExpr, getQueryAccessorName, getQueryTableName, getQueryWhereClause, isRowTypedQuery, isTypedQuery, literal, makeQueryBuilder, not, or, schema, t, table, toCamelCase, toComparableValue, toSql };\n//# sourceMappingURL=index.mjs.map\n//# sourceMappingURL=index.mjs.map","import { schema, t, table, SenderError } from 'spacetimedb/server';\n\nconst channel_kind = t.enum('ChannelKind', { text: t.unit(), voice: t.unit() });\n\nconst user = table(\n  {\n    name: 'user',\n    public: true,\n  },\n  {\n    identity: t.identity().primaryKey(),\n    name: t.string().optional(),\n    online: t.bool(),\n    issuer: t.string().optional(),\n    subject: t.string().optional(),\n    username: t.string().optional(), // For creds-based auth\n    password: t.string().optional(), // For creds-based auth (Note: plain text for MVP)\n  }\n);\n\nconst server = table(\n  { name: 'server', public: true },\n  {\n    id: t.u64().primaryKey().autoInc(),\n    name: t.string(),\n    owner: t.identity().optional(),\n  }\n);\n\nconst channel = table(\n  {\n    name: 'channel',\n    public: true,\n    indexes: [\n      { accessor: 'by_server_id', algorithm: 'btree', columns: ['server_id'] }\n    ]\n  },\n  {\n    id: t.u64().primaryKey().autoInc(),\n    server_id: t.u64(),\n    name: t.string(),\n    kind: channel_kind,\n  }\n);\n\nconst voice_state = table(\n  {\n    name: 'voice_state',\n    public: true,\n    indexes: [\n      { accessor: 'by_channel_id', algorithm: 'btree', columns: ['channel_id'] }\n    ]\n  },\n  {\n    identity: t.identity().primaryKey(),\n    channel_id: t.u64(),\n  }\n);\n\nconst sdp_offer = table(\n  {\n    name: 'sdp_offer',\n    public: true,\n    indexes: [\n      { accessor: 'by_receiver', algorithm: 'btree', columns: ['receiver'] }\n    ]\n  },\n  {\n    sender: t.identity(),\n    receiver: t.identity(),\n    sdp: t.string(),\n    channel_id: t.u64(),\n  }\n);\n\nconst sdp_answer = table(\n  {\n    name: 'sdp_answer',\n    public: true,\n    indexes: [\n      { accessor: 'by_receiver', algorithm: 'btree', columns: ['receiver'] }\n    ]\n  },\n  {\n    sender: t.identity(),\n    receiver: t.identity(),\n    sdp: t.string(),\n    channel_id: t.u64(),\n  }\n);\n\nconst ice_candidate = table(\n  {\n    name: 'ice_candidate',\n    public: true,\n    indexes: [\n      { accessor: 'by_receiver', algorithm: 'btree', columns: ['receiver'] }\n    ]\n  },\n  {\n    sender: t.identity(),\n    receiver: t.identity(),\n    candidate: t.string(),\n    channel_id: t.u64(),\n  }\n);\n\nconst thread = table(\n  {\n    name: 'thread',\n    public: true,\n    indexes: [\n      { accessor: 'by_channel_id', algorithm: 'btree', columns: ['channel_id'] }\n    ]\n  },\n  {\n    id: t.u64().primaryKey().autoInc(),\n    channel_id: t.u64(),\n    parent_message_id: t.u64().unique(),\n    name: t.string(),\n  }\n);\n\nconst message = table(\n  {\n    name: 'message',\n    public: true,\n    indexes: [\n      { accessor: 'by_channel_id', algorithm: 'btree', columns: ['channel_id'] },\n      { accessor: 'by_thread_id', algorithm: 'btree', columns: ['thread_id'] }\n    ]\n  },\n  {\n    id: t.u64().primaryKey().autoInc(),\n    sender: t.identity(),\n    sent: t.timestamp(),\n    text: t.string(),\n    channel_id: t.u64(),\n    thread_id: t.u64().optional(),\n  }\n);\n\nconst spacetimedb = schema({ user, server, channel, voice_state, sdp_offer, sdp_answer, ice_candidate, thread, message });\nexport default spacetimedb;\n\nfunction validateName(name: string) {\n  if (!name || name.trim().length === 0) throw new SenderError('Names must not be empty');\n}\n\nexport const set_name = spacetimedb.reducer(\n  { name: t.string() },\n  (ctx, { name }) => {\n    validateName(name);\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user) throw new SenderError('Cannot set name for unknown user');\n    ctx.db.user.identity.update({ ...user, name });\n  }\n);\n\nexport const register = spacetimedb.reducer(\n  { username: t.string(), password: t.string() },\n  (ctx, { username, password }) => {\n    validateName(username);\n    if (!password || password.length < 4) throw new SenderError('Password must be at least 4 characters');\n    \n    for (const u of ctx.db.user.iter()) {\n      if (u.username === username) {\n        throw new SenderError('Username already taken');\n      }\n    }\n\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (user) {\n      ctx.db.user.identity.update({ \n        ...user, \n        username, \n        password,\n        name: user.name || username \n      });\n    } else {\n      ctx.db.user.insert({\n        identity: ctx.sender,\n        username,\n        password,\n        name: username,\n        online: true,\n        issuer: undefined,\n        subject: undefined\n      });\n    }\n  }\n);\n\nexport const login = spacetimedb.reducer(\n  { username: t.string(), password: t.string() },\n  (ctx, { username, password }) => {\n    let foundUser = null;\n    for (const u of ctx.db.user.iter()) {\n      if (u.username === username && u.password === password) {\n        foundUser = u;\n        break;\n      }\n    }\n\n    if (!foundUser) {\n      throw new SenderError('Invalid username or password');\n    }\n\n    const currentIdentityUser = ctx.db.user.identity.find(ctx.sender);\n    if (currentIdentityUser && currentIdentityUser.identity.toHexString() !== foundUser.identity.toHexString()) {\n       ctx.db.user.identity.delete(ctx.sender);\n    }\n\n    if (foundUser.identity.toHexString() !== ctx.sender.toHexString()) {\n      ctx.db.user.identity.delete(foundUser.identity);\n      ctx.db.user.insert({\n        ...foundUser,\n        identity: ctx.sender,\n        online: true\n      });\n    } else {\n      ctx.db.user.identity.update({\n        ...foundUser,\n        online: true\n      });\n    }\n  }\n);\n\nexport const create_server = spacetimedb.reducer(\n  { name: t.string() },\n  (ctx, { name }) => {\n    validateName(name);\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to create a server');\n    }\n    const s = ctx.db.server.insert({ id: 0n, name, owner: ctx.sender });\n    ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'general', kind: { tag: 'text' } });\n    ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'Voice General', kind: { tag: 'voice' } });\n  }\n);\n\nexport const create_channel = spacetimedb.reducer(\n  { name: t.string(), serverId: t.u64(), isVoice: t.bool() },\n  (ctx, { name, serverId, isVoice }) => {\n    validateName(name);\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to create a channel');\n    }\n    const s = ctx.db.server.id.find(serverId);\n    if (!s) throw new SenderError('Server not found');\n    ctx.db.channel.insert({ \n      id: 0n, \n      server_id: serverId, \n      name, \n      kind: isVoice ? { tag: 'voice' } : { tag: 'text' } \n    });\n  }\n);\n\nexport const join_voice = spacetimedb.reducer(\n  { channelId: t.u64() },\n  (ctx, { channelId }) => {\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to join voice');\n    }\n    const chan = ctx.db.channel.id.find(channelId);\n    if (!chan || chan.kind.tag !== 'voice') throw new SenderError('Invalid voice channel');\n    \n    const existing = ctx.db.voice_state.identity.find(ctx.sender);\n    if (existing) {\n      if (existing.channel_id !== channelId) {\n        clearSignalingForUser(ctx, ctx.sender);\n        ctx.db.voice_state.identity.update({ identity: ctx.sender, channel_id: channelId });\n      }\n    } else {\n      ctx.db.voice_state.insert({ identity: ctx.sender, channel_id: channelId });\n    }\n  }\n);\n\nexport const leave_voice = spacetimedb.reducer((ctx) => {\n  ctx.db.voice_state.identity.delete(ctx.sender);\n  clearSignalingForUser(ctx, ctx.sender);\n});\n\nexport const send_sdp_offer = spacetimedb.reducer(\n  { receiver: t.identity(), sdp: t.string(), channelId: t.u64() },\n  (ctx, { receiver, sdp, channelId }) => {\n    ctx.db.sdp_offer.insert({ sender: ctx.sender, receiver, sdp, channel_id: channelId });\n  }\n);\n\nexport const send_sdp_answer = spacetimedb.reducer(\n  { receiver: t.identity(), sdp: t.string(), channelId: t.u64() },\n  (ctx, { receiver, sdp, channelId }) => {\n    ctx.db.sdp_answer.insert({ sender: ctx.sender, receiver, sdp, channel_id: channelId });\n  }\n);\n\nexport const send_ice_candidate = spacetimedb.reducer(\n  { receiver: t.identity(), candidate: t.string(), channelId: t.u64() },\n  (ctx, { receiver, candidate, channelId }) => {\n    ctx.db.ice_candidate.insert({ sender: ctx.sender, receiver, candidate, channel_id: channelId });\n  }\n);\n\nfunction clearSignalingForUser(ctx: any, identity: any) {\n  // Clean up stale signaling messages for the user\n  // Note: Iterating and deleting might not be the most performant for large tables.\n  // In a production scenario, consider TTLs or more targeted deletion strategies.\n\n  const userOffers = ctx.db.sdp_offer.iter().filter((offer: any) => \n    offer.sender.isEqual(identity) || offer.receiver.isEqual(identity)\n  );\n  for (const offer of userOffers) {\n    ctx.db.sdp_offer.delete(offer.id); // Assuming 'id' is the primary key\n  }\n\n  const userAnswers = ctx.db.sdp_answer.iter().filter((answer: any) => \n    answer.sender.isEqual(identity) || answer.receiver.isEqual(identity)\n  );\n  for (const answer of userAnswers) {\n    ctx.db.sdp_answer.delete(answer.id); // Assuming 'id' is the primary key\n  }\n\n  const userCandidates = ctx.db.ice_candidate.iter().filter((candidate: any) => \n    candidate.sender.isEqual(identity) || candidate.receiver.isEqual(identity)\n  );\n  for (const candidate of userCandidates) {\n    ctx.db.ice_candidate.delete(candidate.id); // Assuming 'id' is the primary key\n  }\n}\n\nexport const create_thread = spacetimedb.reducer(\n  { name: t.string(), channelId: t.u64(), parentMessageId: t.u64() },\n  (ctx, { name, channelId, parentMessageId }) => {\n    validateName(name);\n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to create a thread');\n    }\n    const parentMsg = ctx.db.message.id.find(parentMessageId);\n    if (!parentMsg) throw new SenderError('Parent message not found');\n    \n    ctx.db.thread.insert({ id: 0n, channel_id: channelId, parent_message_id: parentMessageId, name });\n  }\n);\n\nexport const send_message = spacetimedb.reducer(\n  { text: t.string(), channelId: t.u64(), threadId: t.u64().optional() },\n  (ctx, { text, channelId, threadId }) => {\n    if (!text || text.trim().length === 0) throw new SenderError('Messages must not be empty');\n    \n    const user = ctx.db.user.identity.find(ctx.sender);\n    if (!user || (!user.username && !user.subject)) {\n      throw new SenderError('You must be logged in to send messages');\n    }\n\n    ctx.db.message.insert({\n      id: 0n,\n      sender: ctx.sender,\n      text,\n      sent: ctx.timestamp,\n      channel_id: channelId,\n      thread_id: threadId,\n    });\n  }\n);\n\nexport const init = spacetimedb.init(ctx => {\n  let hasServers = false;\n  for (const _ of ctx.db.server.iter()) {\n    hasServers = true;\n    break;\n  }\n  if (!hasServers) {\n    const s = ctx.db.server.insert({ id: 0n, name: 'Spacetime Community', owner: undefined });\n    ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'general', kind: { tag: 'text' } });\n    ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'Voice General', kind: { tag: 'voice' } });\n  }\n});\n\nexport const onConnect = spacetimedb.clientConnected(ctx => {\n  const user = ctx.db.user.identity.find(ctx.sender);\n  \n  if (ctx.senderAuth.hasJWT && ctx.senderAuth.jwt) {\n    const jwt = ctx.senderAuth.jwt;\n    const issuer = jwt.issuer;\n    const subject = jwt.subject;\n    const payload = jwt.fullPayload;\n    const name = (payload.name as string) || (payload.nickname as string) || (payload.preferred_username as string) || (payload.email as string);\n\n    if (user) {\n      ctx.db.user.identity.update({ \n        ...user, \n        online: true,\n        name: user.name || name,\n        issuer,\n        subject\n      });\n    } else {\n      ctx.db.user.insert({\n        name,\n        identity: ctx.sender,\n        online: true,\n        issuer,\n        subject,\n        username: undefined,\n        password: undefined\n      });\n    }\n  } else if (user) {\n    ctx.db.user.identity.update({ ...user, online: true });\n  }\n});\n\nexport const onDisconnect = spacetimedb.clientDisconnected(ctx => {\n  const user = ctx.db.user.identity.find(ctx.sender);\n  if (user) {\n    ctx.db.user.identity.update({ ...user, online: false });\n  }\n  // Auto-leave voice on disconnect\n  ctx.db.voice_state.identity.delete(ctx.sender);\n  // Clean up signaling messages associated with the disconnected user\n  clearSignalingForUser(ctx, ctx.sender);\n});\n"],"mappings":"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","debugId":"c9a38ab5-d5c5-4af9-81c8-7086063e3faf"} \ No newline at end of file diff --git a/spacetimedb/node_modules/.bin/tsc b/spacetimedb/node_modules/.bin/tsc new file mode 100755 index 0000000..d8046ac --- /dev/null +++ b/spacetimedb/node_modules/.bin/tsc @@ -0,0 +1,21 @@ +#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") + +case `uname` in + *CYGWIN*|*MINGW*|*MSYS*) + if command -v cygpath > /dev/null 2>&1; then + basedir=`cygpath -w "$basedir"` + fi + ;; +esac + +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/bin/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/node_modules" +else + export NODE_PATH="/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/bin/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/node_modules:$NODE_PATH" +fi +if [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir/../typescript/bin/tsc" "$@" +else + exec node "$basedir/../typescript/bin/tsc" "$@" +fi diff --git a/spacetimedb/node_modules/.bin/tsserver b/spacetimedb/node_modules/.bin/tsserver new file mode 100755 index 0000000..061b8ce --- /dev/null +++ b/spacetimedb/node_modules/.bin/tsserver @@ -0,0 +1,21 @@ +#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") + +case `uname` in + *CYGWIN*|*MINGW*|*MSYS*) + if command -v cygpath > /dev/null 2>&1; then + basedir=`cygpath -w "$basedir"` + fi + ;; +esac + +if [ -z "$NODE_PATH" ]; then + export NODE_PATH="/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/bin/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/node_modules" +else + export NODE_PATH="/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/bin/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/typescript@5.9.3/node_modules:/Users/alamers/git/my-spacetime-app/spacetimedb/node_modules/.pnpm/node_modules:$NODE_PATH" +fi +if [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir/../typescript/bin/tsserver" "$@" +else + exec node "$basedir/../typescript/bin/tsserver" "$@" +fi diff --git a/spacetimedb/node_modules/.modules.yaml b/spacetimedb/node_modules/.modules.yaml new file mode 100644 index 0000000..63dde22 --- /dev/null +++ b/spacetimedb/node_modules/.modules.yaml @@ -0,0 +1,51 @@ +{ + "hoistedDependencies": { + "headers-polyfill@4.0.3": { + "headers-polyfill": "private" + }, + "base64-js@1.5.1": { + "base64-js": "private" + }, + "url-polyfill@1.1.14": { + "url-polyfill": "private" + }, + "object-inspect@1.13.4": { + "object-inspect": "private" + }, + "pure-rand@7.0.1": { + "pure-rand": "private" + }, + "statuses@2.0.2": { + "statuses": "private" + }, + "safe-stable-stringify@2.5.0": { + "safe-stable-stringify": "private" + }, + "prettier@3.8.1": { + "prettier": "private" + } + }, + "hoistPattern": [ + "*" + ], + "included": { + "dependencies": true, + "devDependencies": true, + "optionalDependencies": true + }, + "injectedDeps": {}, + "layoutVersion": 5, + "nodeLinker": "isolated", + "packageManager": "pnpm@10.29.3", + "pendingBuilds": [], + "publicHoistPattern": [], + "prunedAt": "Sat, 28 Mar 2026 23:54:58 GMT", + "registries": { + "default": "https://registry.npmjs.org/", + "@jsr": "https://npm.jsr.io/" + }, + "skipped": [], + "storeDir": "/Users/alamers/Library/pnpm/store/v10", + "virtualStoreDir": ".pnpm", + "virtualStoreDirMaxLength": 120 +} \ No newline at end of file diff --git a/spacetimedb/node_modules/.pnpm-workspace-state-v1.json b/spacetimedb/node_modules/.pnpm-workspace-state-v1.json new file mode 100644 index 0000000..96e245d --- /dev/null +++ b/spacetimedb/node_modules/.pnpm-workspace-state-v1.json @@ -0,0 +1,25 @@ +{ + "lastValidatedTimestamp": 1774742098032, + "projects": {}, + "pnpmfiles": [], + "settings": { + "autoInstallPeers": true, + "dedupeDirectDeps": false, + "dedupeInjectedDeps": true, + "dedupePeerDependents": true, + "dev": true, + "excludeLinksFromLockfile": false, + "hoistPattern": [ + "*" + ], + "hoistWorkspacePackages": true, + "injectWorkspacePackages": false, + "linkWorkspacePackages": false, + "nodeLinker": "isolated", + "optional": true, + "preferWorkspacePackages": false, + "production": true, + "publicHoistPattern": [] + }, + "filteredInstall": false +} diff --git a/spacetimedb/node_modules/spacetimedb b/spacetimedb/node_modules/spacetimedb new file mode 120000 index 0000000..dc7e627 --- /dev/null +++ b/spacetimedb/node_modules/spacetimedb @@ -0,0 +1 @@ +.pnpm/spacetimedb@2.1.0/node_modules/spacetimedb \ No newline at end of file diff --git a/spacetimedb/node_modules/typescript b/spacetimedb/node_modules/typescript new file mode 120000 index 0000000..e5bbb7f --- /dev/null +++ b/spacetimedb/node_modules/typescript @@ -0,0 +1 @@ +.pnpm/typescript@5.9.3/node_modules/typescript \ No newline at end of file diff --git a/spacetimedb/package-lock.json b/spacetimedb/package-lock.json new file mode 100644 index 0000000..69a1f0a --- /dev/null +++ b/spacetimedb/package-lock.json @@ -0,0 +1,113 @@ +{ + "name": "sdk-test-module", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "sdk-test-module", + "license": "ISC", + "dependencies": { + "fast-text-encoding": "^1.0.0" + }, + "devDependencies": { + "@types/fast-text-encoding": "^1.0.3", + "tsup": "^8.1.0" + } + }, + "../../node_modules/.pnpm/fast-text-encoding@1.0.6/node_modules/fast-text-encoding": { + "version": "1.0.6", + "license": "Apache-2.0" + }, + "../../node_modules/.pnpm/tsup@8.5.0_jiti@2.5.1_postcss@8.5.6_tsx@4.20.4_typescript@5.9.2/node_modules/tsup": { + "version": "8.5.0", + "dev": true, + "license": "MIT", + "dependencies": { + "bundle-require": "^5.1.0", + "cac": "^6.7.14", + "chokidar": "^4.0.3", + "consola": "^3.4.0", + "debug": "^4.4.0", + "esbuild": "^0.25.0", + "fix-dts-default-cjs-exports": "^1.0.0", + "joycon": "^3.1.1", + "picocolors": "^1.1.1", + "postcss-load-config": "^6.0.1", + "resolve-from": "^5.0.0", + "rollup": "^4.34.8", + "source-map": "0.8.0-beta.0", + "sucrase": "^3.35.0", + "tinyexec": "^0.3.2", + "tinyglobby": "^0.2.11", + "tree-kill": "^1.2.2" + }, + "bin": { + "tsup": "dist/cli-default.js", + "tsup-node": "dist/cli-node.js" + }, + "devDependencies": { + "@microsoft/api-extractor": "^7.50.0", + "@rollup/plugin-json": "6.1.0", + "@swc/core": "1.10.18", + "@types/debug": "4.1.12", + "@types/node": "22.13.4", + "@types/resolve": "1.20.6", + "bumpp": "^10.0.3", + "flat": "6.0.1", + "postcss": "8.5.2", + "postcss-simple-vars": "7.0.1", + "prettier": "3.5.1", + "resolve": "1.22.10", + "rollup-plugin-dts": "6.1.1", + "sass": "1.85.0", + "strip-json-comments": "5.0.1", + "svelte": "5.19.9", + "svelte-preprocess": "6.0.3", + "terser": "^5.39.0", + "ts-essentials": "10.0.4", + "tsup": "8.3.6", + "typescript": "5.7.3", + "vitest": "3.0.6", + "wait-for-expect": "3.0.2" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@microsoft/api-extractor": "^7.36.0", + "@swc/core": "^1", + "postcss": "^8.4.12", + "typescript": ">=4.5.0" + }, + "peerDependenciesMeta": { + "@microsoft/api-extractor": { + "optional": true + }, + "@swc/core": { + "optional": true + }, + "postcss": { + "optional": true + }, + "typescript": { + "optional": true + } + } + }, + "node_modules/@types/fast-text-encoding": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@types/fast-text-encoding/-/fast-text-encoding-1.0.3.tgz", + "integrity": "sha512-bbGJt6IyiuyAhPOX7htQDDzv2bDGJdWyd6X+e1BcdPzU3e5jyjOdB86LoTSoE80faY9v8Wt7/ix3Sp+coRJ03Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-text-encoding": { + "resolved": "../../node_modules/.pnpm/fast-text-encoding@1.0.6/node_modules/fast-text-encoding", + "link": true + }, + "node_modules/tsup": { + "resolved": "../../node_modules/.pnpm/tsup@8.5.0_jiti@2.5.1_postcss@8.5.6_tsx@4.20.4_typescript@5.9.2/node_modules/tsup", + "link": true + } + } +} diff --git a/spacetimedb/package.json b/spacetimedb/package.json new file mode 100644 index 0000000..3adcce6 --- /dev/null +++ b/spacetimedb/package.json @@ -0,0 +1,16 @@ +{ + "name": "my-spacetime-app", + "license": "ISC", + "type": "module", + "scripts": { + "build": "cargo build -p spacetimedb-standalone && cargo run -p spacetimedb-cli -- build", + "generate-ts": "cargo build -p spacetimedb-standalone && cargo run -p spacetimedb-cli -- generate --lang typescript --out-dir ts-codegen", + "publish": "cargo run -p spacetimedb-cli -- publish" + }, + "dependencies": { + "spacetimedb": "^2.1.0" + }, + "devDependencies": { + "typescript": "^5.9.3" + } +} \ No newline at end of file diff --git a/spacetimedb/pnpm-lock.yaml b/spacetimedb/pnpm-lock.yaml new file mode 100644 index 0000000..ce33884 --- /dev/null +++ b/spacetimedb/pnpm-lock.yaml @@ -0,0 +1,107 @@ +lockfileVersion: '9.0' + +settings: + autoInstallPeers: true + excludeLinksFromLockfile: false + +importers: + + .: + dependencies: + spacetimedb: + specifier: ^2.1.0 + version: 2.1.0 + devDependencies: + typescript: + specifier: ^5.9.3 + version: 5.9.3 + +packages: + + base64-js@1.5.1: + resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} + + headers-polyfill@4.0.3: + resolution: {integrity: sha512-IScLbePpkvO846sIwOtOTDjutRMWdXdJmXdMvk6gCBHxFO8d+QKOQedyZSxFTTFYRSmlgSTDtXqqq4pcenBXLQ==} + + object-inspect@1.13.4: + resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==} + engines: {node: '>= 0.4'} + + prettier@3.8.1: + resolution: {integrity: sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg==} + engines: {node: '>=14'} + hasBin: true + + pure-rand@7.0.1: + resolution: {integrity: sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ==} + + safe-stable-stringify@2.5.0: + resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==} + engines: {node: '>=10'} + + spacetimedb@2.1.0: + resolution: {integrity: sha512-Kzs+HXCRj15ryld03ztU4a2uQg0M8ivV/9Bk/gvMpb59lLc/A2/r7UkGCYBePsBL7Zwqgr8gE8FeufoZVXtPnA==} + peerDependencies: + '@angular/core': '>=17.0.0' + '@tanstack/react-query': ^5.0.0 + react: ^18.0.0 || ^19.0.0-0 || ^19.0.0 + svelte: ^4.0.0 || ^5.0.0 + undici: ^6.19.2 + vue: ^3.3.0 + peerDependenciesMeta: + '@angular/core': + optional: true + '@tanstack/react-query': + optional: true + react: + optional: true + svelte: + optional: true + undici: + optional: true + vue: + optional: true + + statuses@2.0.2: + resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==} + engines: {node: '>= 0.8'} + + typescript@5.9.3: + resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==} + engines: {node: '>=14.17'} + hasBin: true + + url-polyfill@1.1.14: + resolution: {integrity: sha512-p4f3TTAG6ADVF3mwbXw7hGw+QJyw5CnNGvYh5fCuQQZIiuKUswqcznyV3pGDP9j0TSmC4UvRKm8kl1QsX1diiQ==} + +snapshots: + + base64-js@1.5.1: {} + + headers-polyfill@4.0.3: {} + + object-inspect@1.13.4: {} + + prettier@3.8.1: {} + + pure-rand@7.0.1: {} + + safe-stable-stringify@2.5.0: {} + + spacetimedb@2.1.0: + dependencies: + base64-js: 1.5.1 + headers-polyfill: 4.0.3 + object-inspect: 1.13.4 + prettier: 3.8.1 + pure-rand: 7.0.1 + safe-stable-stringify: 2.5.0 + statuses: 2.0.2 + url-polyfill: 1.1.14 + + statuses@2.0.2: {} + + typescript@5.9.3: {} + + url-polyfill@1.1.14: {} diff --git a/spacetimedb/src/index.ts b/spacetimedb/src/index.ts new file mode 100644 index 0000000..1428544 --- /dev/null +++ b/spacetimedb/src/index.ts @@ -0,0 +1,430 @@ +import { schema, t, table, SenderError } from 'spacetimedb/server'; + +const channel_kind = t.enum('ChannelKind', { text: t.unit(), voice: t.unit() }); + +const user = table( + { + name: 'user', + public: true, + }, + { + identity: t.identity().primaryKey(), + name: t.string().optional(), + online: t.bool(), + issuer: t.string().optional(), + subject: t.string().optional(), + username: t.string().optional(), // For creds-based auth + password: t.string().optional(), // For creds-based auth (Note: plain text for MVP) + } +); + +const server = table( + { name: 'server', public: true }, + { + id: t.u64().primaryKey().autoInc(), + name: t.string(), + owner: t.identity().optional(), + } +); + +const channel = table( + { + name: 'channel', + public: true, + indexes: [ + { accessor: 'by_server_id', algorithm: 'btree', columns: ['server_id'] } + ] + }, + { + id: t.u64().primaryKey().autoInc(), + server_id: t.u64(), + name: t.string(), + kind: channel_kind, + } +); + +const voice_state = table( + { + name: 'voice_state', + public: true, + indexes: [ + { accessor: 'by_channel_id', algorithm: 'btree', columns: ['channel_id'] } + ] + }, + { + identity: t.identity().primaryKey(), + channel_id: t.u64(), + } +); + +const sdp_offer = table( + { + name: 'sdp_offer', + public: true, + indexes: [ + { accessor: 'by_receiver', algorithm: 'btree', columns: ['receiver'] } + ] + }, + { + sender: t.identity(), + receiver: t.identity(), + sdp: t.string(), + channel_id: t.u64(), + } +); + +const sdp_answer = table( + { + name: 'sdp_answer', + public: true, + indexes: [ + { accessor: 'by_receiver', algorithm: 'btree', columns: ['receiver'] } + ] + }, + { + sender: t.identity(), + receiver: t.identity(), + sdp: t.string(), + channel_id: t.u64(), + } +); + +const ice_candidate = table( + { + name: 'ice_candidate', + public: true, + indexes: [ + { accessor: 'by_receiver', algorithm: 'btree', columns: ['receiver'] } + ] + }, + { + sender: t.identity(), + receiver: t.identity(), + candidate: t.string(), + channel_id: t.u64(), + } +); + +const thread = table( + { + name: 'thread', + public: true, + indexes: [ + { accessor: 'by_channel_id', algorithm: 'btree', columns: ['channel_id'] } + ] + }, + { + id: t.u64().primaryKey().autoInc(), + channel_id: t.u64(), + parent_message_id: t.u64().unique(), + name: t.string(), + } +); + +const message = table( + { + name: 'message', + public: true, + indexes: [ + { accessor: 'by_channel_id', algorithm: 'btree', columns: ['channel_id'] }, + { accessor: 'by_thread_id', algorithm: 'btree', columns: ['thread_id'] } + ] + }, + { + id: t.u64().primaryKey().autoInc(), + sender: t.identity(), + sent: t.timestamp(), + text: t.string(), + channel_id: t.u64(), + thread_id: t.u64().optional(), + } +); + +const spacetimedb = schema({ user, server, channel, voice_state, sdp_offer, sdp_answer, ice_candidate, thread, message }); +export default spacetimedb; + +function validateName(name: string) { + if (!name || name.trim().length === 0) throw new SenderError('Names must not be empty'); +} + +export const set_name = spacetimedb.reducer( + { name: t.string() }, + (ctx, { name }) => { + validateName(name); + const user = ctx.db.user.identity.find(ctx.sender); + if (!user) throw new SenderError('Cannot set name for unknown user'); + ctx.db.user.identity.update({ ...user, name }); + } +); + +export const register = spacetimedb.reducer( + { username: t.string(), password: t.string() }, + (ctx, { username, password }) => { + validateName(username); + if (!password || password.length < 4) throw new SenderError('Password must be at least 4 characters'); + + for (const u of ctx.db.user.iter()) { + if (u.username === username) { + throw new SenderError('Username already taken'); + } + } + + const user = ctx.db.user.identity.find(ctx.sender); + if (user) { + ctx.db.user.identity.update({ + ...user, + username, + password, + name: user.name || username + }); + } else { + ctx.db.user.insert({ + identity: ctx.sender, + username, + password, + name: username, + online: true, + issuer: undefined, + subject: undefined + }); + } + } +); + +export const login = spacetimedb.reducer( + { username: t.string(), password: t.string() }, + (ctx, { username, password }) => { + let foundUser = null; + for (const u of ctx.db.user.iter()) { + if (u.username === username && u.password === password) { + foundUser = u; + break; + } + } + + if (!foundUser) { + throw new SenderError('Invalid username or password'); + } + + const currentIdentityUser = ctx.db.user.identity.find(ctx.sender); + if (currentIdentityUser && currentIdentityUser.identity.toHexString() !== foundUser.identity.toHexString()) { + ctx.db.user.identity.delete(ctx.sender); + } + + if (foundUser.identity.toHexString() !== ctx.sender.toHexString()) { + ctx.db.user.identity.delete(foundUser.identity); + ctx.db.user.insert({ + ...foundUser, + identity: ctx.sender, + online: true + }); + } else { + ctx.db.user.identity.update({ + ...foundUser, + online: true + }); + } + } +); + +export const create_server = spacetimedb.reducer( + { name: t.string() }, + (ctx, { name }) => { + validateName(name); + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || (!user.username && !user.subject)) { + throw new SenderError('You must be logged in to create a server'); + } + const s = ctx.db.server.insert({ id: 0n, name, owner: ctx.sender }); + ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'general', kind: { tag: 'text' } }); + ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'Voice General', kind: { tag: 'voice' } }); + } +); + +export const create_channel = spacetimedb.reducer( + { name: t.string(), serverId: t.u64(), isVoice: t.bool() }, + (ctx, { name, serverId, isVoice }) => { + validateName(name); + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || (!user.username && !user.subject)) { + throw new SenderError('You must be logged in to create a channel'); + } + const s = ctx.db.server.id.find(serverId); + if (!s) throw new SenderError('Server not found'); + ctx.db.channel.insert({ + id: 0n, + server_id: serverId, + name, + kind: isVoice ? { tag: 'voice' } : { tag: 'text' } + }); + } +); + +export const join_voice = spacetimedb.reducer( + { channelId: t.u64() }, + (ctx, { channelId }) => { + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || (!user.username && !user.subject)) { + throw new SenderError('You must be logged in to join voice'); + } + const chan = ctx.db.channel.id.find(channelId); + if (!chan || chan.kind.tag !== 'voice') throw new SenderError('Invalid voice channel'); + + const existing = ctx.db.voice_state.identity.find(ctx.sender); + if (existing) { + if (existing.channel_id !== channelId) { + clearSignalingForUser(ctx, ctx.sender); + ctx.db.voice_state.identity.update({ identity: ctx.sender, channel_id: channelId }); + } + } else { + ctx.db.voice_state.insert({ identity: ctx.sender, channel_id: channelId }); + } + } +); + +export const leave_voice = spacetimedb.reducer((ctx) => { + ctx.db.voice_state.identity.delete(ctx.sender); + clearSignalingForUser(ctx, ctx.sender); +}); + +export const send_sdp_offer = spacetimedb.reducer( + { receiver: t.identity(), sdp: t.string(), channelId: t.u64() }, + (ctx, { receiver, sdp, channelId }) => { + ctx.db.sdp_offer.insert({ sender: ctx.sender, receiver, sdp, channel_id: channelId }); + } +); + +export const send_sdp_answer = spacetimedb.reducer( + { receiver: t.identity(), sdp: t.string(), channelId: t.u64() }, + (ctx, { receiver, sdp, channelId }) => { + ctx.db.sdp_answer.insert({ sender: ctx.sender, receiver, sdp, channel_id: channelId }); + } +); + +export const send_ice_candidate = spacetimedb.reducer( + { receiver: t.identity(), candidate: t.string(), channelId: t.u64() }, + (ctx, { receiver, candidate, channelId }) => { + ctx.db.ice_candidate.insert({ sender: ctx.sender, receiver, candidate, channel_id: channelId }); + } +); + +function clearSignalingForUser(ctx: any, identity: any) { + // Clean up stale signaling messages for the user + // Note: Iterating and deleting might not be the most performant for large tables. + // In a production scenario, consider TTLs or more targeted deletion strategies. + + const userOffers = ctx.db.sdp_offer.iter().filter((offer: any) => + offer.sender.isEqual(identity) || offer.receiver.isEqual(identity) + ); + for (const offer of userOffers) { + ctx.db.sdp_offer.delete(offer.id); // Assuming 'id' is the primary key + } + + const userAnswers = ctx.db.sdp_answer.iter().filter((answer: any) => + answer.sender.isEqual(identity) || answer.receiver.isEqual(identity) + ); + for (const answer of userAnswers) { + ctx.db.sdp_answer.delete(answer.id); // Assuming 'id' is the primary key + } + + const userCandidates = ctx.db.ice_candidate.iter().filter((candidate: any) => + candidate.sender.isEqual(identity) || candidate.receiver.isEqual(identity) + ); + for (const candidate of userCandidates) { + ctx.db.ice_candidate.delete(candidate.id); // Assuming 'id' is the primary key + } +} + +export const create_thread = spacetimedb.reducer( + { name: t.string(), channelId: t.u64(), parentMessageId: t.u64() }, + (ctx, { name, channelId, parentMessageId }) => { + validateName(name); + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || (!user.username && !user.subject)) { + throw new SenderError('You must be logged in to create a thread'); + } + const parentMsg = ctx.db.message.id.find(parentMessageId); + if (!parentMsg) throw new SenderError('Parent message not found'); + + ctx.db.thread.insert({ id: 0n, channel_id: channelId, parent_message_id: parentMessageId, name }); + } +); + +export const send_message = spacetimedb.reducer( + { text: t.string(), channelId: t.u64(), threadId: t.u64().optional() }, + (ctx, { text, channelId, threadId }) => { + if (!text || text.trim().length === 0) throw new SenderError('Messages must not be empty'); + + const user = ctx.db.user.identity.find(ctx.sender); + if (!user || (!user.username && !user.subject)) { + throw new SenderError('You must be logged in to send messages'); + } + + ctx.db.message.insert({ + id: 0n, + sender: ctx.sender, + text, + sent: ctx.timestamp, + channel_id: channelId, + thread_id: threadId, + }); + } +); + +export const init = spacetimedb.init(ctx => { + let hasServers = false; + for (const _ of ctx.db.server.iter()) { + hasServers = true; + break; + } + if (!hasServers) { + const s = ctx.db.server.insert({ id: 0n, name: 'Spacetime Community', owner: undefined }); + ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'general', kind: { tag: 'text' } }); + ctx.db.channel.insert({ id: 0n, server_id: s.id, name: 'Voice General', kind: { tag: 'voice' } }); + } +}); + +export const onConnect = spacetimedb.clientConnected(ctx => { + const user = ctx.db.user.identity.find(ctx.sender); + + if (ctx.senderAuth.hasJWT && ctx.senderAuth.jwt) { + const jwt = ctx.senderAuth.jwt; + const issuer = jwt.issuer; + const subject = jwt.subject; + const payload = jwt.fullPayload; + const name = (payload.name as string) || (payload.nickname as string) || (payload.preferred_username as string) || (payload.email as string); + + if (user) { + ctx.db.user.identity.update({ + ...user, + online: true, + name: user.name || name, + issuer, + subject + }); + } else { + ctx.db.user.insert({ + name, + identity: ctx.sender, + online: true, + issuer, + subject, + username: undefined, + password: undefined + }); + } + } else if (user) { + ctx.db.user.identity.update({ ...user, online: true }); + } +}); + +export const onDisconnect = spacetimedb.clientDisconnected(ctx => { + const user = ctx.db.user.identity.find(ctx.sender); + if (user) { + ctx.db.user.identity.update({ ...user, online: false }); + } + // Auto-leave voice on disconnect + ctx.db.voice_state.identity.delete(ctx.sender); + // Clean up signaling messages associated with the disconnected user + clearSignalingForUser(ctx, ctx.sender); +}); diff --git a/spacetimedb/tsconfig.json b/spacetimedb/tsconfig.json new file mode 100644 index 0000000..9446cbd --- /dev/null +++ b/spacetimedb/tsconfig.json @@ -0,0 +1,28 @@ +{ + "compilerOptions": { + "target": "ESNext", + "module": "ESNext", + + "strict": true, + "declaration": false, + "emitDeclarationOnly": false, + "noEmit": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "allowImportingTsExtensions": true, + "noImplicitAny": true, + "moduleResolution": "bundler", + "isolatedDeclarations": false, + + // This library is ESM-only, do not import commonjs modules + "esModuleInterop": false, + "allowSyntheticDefaultImports": false, + "useDefineForClassFields": true, + + // Crucial when using esbuild/swc/babel instead of tsc emit: + "verbatimModuleSyntax": true, + "isolatedModules": true + }, + "include": ["src/index.ts", "tests/**/*"], + "exclude": ["node_modules", "**/__tests__/*", "dist/**/*"] +} diff --git a/src/.gitattributes b/src/.gitattributes new file mode 100644 index 0000000..f4d6534 --- /dev/null +++ b/src/.gitattributes @@ -0,0 +1 @@ +/module_bindings/** linguist-generated=true diff --git a/src/App.css b/src/App.css new file mode 100644 index 0000000..57990a7 --- /dev/null +++ b/src/App.css @@ -0,0 +1,455 @@ +:root { + --background-primary: #313338; + --background-secondary: #2b2d31; + --background-tertiary: #1e1f22; + --background-accent: #404249; + --channel-sidebar-width: 240px; + --server-sidebar-width: 72px; + --text-normal: #dbdee1; + --text-muted: #949ba4; + --header-primary: #ffffff; + --interactive-normal: #b5bac1; + --interactive-hover: #dbdee1; + --interactive-active: #ffffff; + --brand: #5865f2; + --brand-hover: #4752c4; +} + +body { + margin: 0; + padding: 0; + background-color: var(--background-tertiary); + color: var(--text-normal); + font-family: 'gg sans', 'Noto Sans', 'Helvetica Neue', Helvetica, Arial, sans-serif; + overflow: hidden; +} + +.app-container { + display: flex; + height: 100vh; + width: 100vw; +} + +/* Login Screen */ +.login-screen { + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; + height: 100vh; + width: 100vw; + background-color: var(--background-tertiary); + gap: 20px; +} + +.login-card { + background-color: var(--background-primary); + padding: 32px; + border-radius: 8px; + box-shadow: 0 2px 10px 0 rgba(0,0,0,0.2); + display: flex; + flex-direction: column; + align-items: center; + gap: 24px; + width: 400px; +} + +.login-card h1 { + margin: 0; + color: var(--header-primary); +} + +.login-card p { + color: var(--text-muted); + text-align: center; + margin: 0; +} + +/* Sidebar for Servers (simplified icons) */ +.server-sidebar { + width: var(--server-sidebar-width); + background-color: var(--background-tertiary); + display: flex; + flex-direction: column; + align-items: center; + padding-top: 12px; + gap: 8px; +} + +.server-icon { + width: 48px; + height: 48px; + background-color: var(--background-accent); + border-radius: 50%; + display: flex; + align-items: center; + justify-content: center; + cursor: pointer; + transition: border-radius 0.2s, background-color 0.2s; + color: var(--text-normal); +} + +.server-icon:hover { + border-radius: 16px; + background-color: var(--brand); +} + +.server-icon.active { + border-radius: 16px; + background-color: var(--brand); +} + +/* Sidebar for Channels */ +.channel-sidebar { + width: var(--channel-sidebar-width); + background-color: var(--background-secondary); + display: flex; + flex-direction: column; +} + +.channel-header { + height: 48px; + padding: 0 16px; + display: flex; + align-items: center; + box-shadow: 0 1px 0 rgba(0,0,0,0.2); + font-weight: bold; + color: var(--header-primary); +} + +.channel-list { + flex: 1; + padding: 8px; + overflow-y: auto; +} + +.channel-item { + padding: 6px 8px; + border-radius: 4px; + cursor: pointer; + display: flex; + align-items: center; + color: var(--interactive-normal); + margin-bottom: 2px; +} + +.channel-item:hover { + background-color: var(--background-accent); + color: var(--interactive-hover); +} + +.channel-item.active { + background-color: var(--background-accent); + color: var(--interactive-active); +} + +.channel-item-hash { + margin-right: 6px; + color: var(--text-muted); + font-size: 1.2rem; +} + +/* User Profile at bottom of sidebar */ +.user-profile { + height: 52px; + background-color: #232428; + display: flex; + align-items: center; + padding: 0 8px; + gap: 8px; +} + +.avatar { + width: 32px; + height: 32px; + background-color: #5865f2; + border-radius: 50%; + display: flex; + align-items: center; + justify-content: center; + font-size: 0.8rem; + color: white; +} + +.user-info { + flex: 1; + overflow: hidden; +} + +.username { + font-size: 0.85rem; + font-weight: 600; + color: var(--header-primary); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.user-status { + font-size: 0.75rem; + color: var(--text-muted); +} + +/* Main Chat Area */ +.main-content { + flex: 1; + display: flex; + flex-direction: column; + background-color: var(--background-primary); +} + +.chat-header { + height: 48px; + padding: 0 16px; + display: flex; + align-items: center; + box-shadow: 0 1px 0 rgba(0,0,0,0.2); + color: var(--header-primary); + font-weight: bold; +} + +.messages-container { + flex: 1; + overflow-y: auto; + padding: 16px; + display: flex; + flex-direction: column; + gap: 16px; +} + +.message { + display: flex; + gap: 16px; +} + +.message-avatar { + width: 40px; + height: 40px; + background-color: #5865f2; + border-radius: 50%; + margin-top: 2px; + flex-shrink: 0; + display: flex; + align-items: center; + justify-content: center; + color: white; +} + +.message-content { + flex: 1; +} + +.message-meta { + display: flex; + align-items: baseline; + gap: 8px; + margin-bottom: 4px; +} + +.message-sender { + font-weight: 500; + color: var(--header-primary); +} + +.message-timestamp { + font-size: 0.75rem; + color: var(--text-muted); +} + +.message-text { + color: var(--text-normal); + line-height: 1.375rem; + word-wrap: break-word; +} + +.message-thread-btn { + font-size: 0.75rem; + color: var(--brand); + background: none; + border: none; + cursor: pointer; + padding: 0; + margin-top: 4px; +} + +.message-thread-btn:hover { + text-decoration: underline; +} + +/* Chat Input */ +.chat-input-container { + padding: 0 16px 24px 16px; +} + +.chat-input-wrapper { + background-color: #383a40; + border-radius: 8px; + padding: 11px 16px; + display: flex; + align-items: center; +} + +.chat-input { + flex: 1; + background: none; + border: none; + color: var(--text-normal); + font-family: inherit; + font-size: 1rem; + outline: none; +} + +.chat-input::placeholder { + color: var(--text-muted); +} + +/* Right Sidebar (Users/Thread) */ +.right-sidebar { + width: 240px; + background-color: var(--background-secondary); + display: flex; + flex-direction: column; + border-left: 1px solid rgba(255,255,255,0.05); +} + +.thread-view { + display: flex; + flex-direction: column; + height: 100%; +} + +.thread-header { + height: 48px; + padding: 0 16px; + display: flex; + align-items: center; + justify-content: space-between; + box-shadow: 0 1px 0 rgba(0,0,0,0.2); + font-weight: bold; +} + +.close-btn { + background: none; + border: none; + color: var(--interactive-normal); + cursor: pointer; + font-size: 1.2rem; +} + +.thread-messages { + flex: 1; + overflow-y: auto; + padding: 8px; +} + +.member-list { + padding: 16px 8px; +} + +.member-item { + display: flex; + align-items: center; + gap: 8px; + padding: 6px 8px; + border-radius: 4px; + color: var(--text-muted); +} + +.member-item:hover { + background-color: var(--background-accent); + color: var(--interactive-hover); +} + +.member-avatar { + width: 32px; + height: 32px; + background-color: #5865f2; + border-radius: 50%; +} + +.member-name { + font-size: 0.9rem; + font-weight: 500; +} + +/* Modals/Dialogs */ +.modal-overlay { + position: fixed; + top: 0; + left: 0; + right: 0; + bottom: 0; + background-color: rgba(0,0,0,0.85); + display: flex; + align-items: center; + justify-content: center; + z-index: 1000; +} + +.modal-content { + background-color: var(--background-primary); + padding: 24px; + border-radius: 8px; + width: 400px; + display: flex; + flex-direction: column; + gap: 16px; +} + +.modal-content h2 { + margin: 0; + color: var(--header-primary); +} + +.modal-content input { + background-color: var(--background-tertiary); + border: none; + padding: 12px; + border-radius: 4px; + color: var(--text-normal); + outline: none; +} + +.modal-buttons { + display: flex; + justify-content: flex-end; + gap: 8px; +} + +.btn-primary { + background-color: var(--brand); + color: white; + border: none; + padding: 10px 20px; + border-radius: 4px; + cursor: pointer; +} + +.btn-secondary { + background-color: transparent; + color: white; + border: none; + padding: 10px 20px; + cursor: pointer; +} + +.btn-danger { + background-color: #da373c; + color: white; + border: none; + padding: 10px 20px; + border-radius: 4px; + cursor: pointer; +} + +.btn-danger:hover { + background-color: #a12829; +} + +.add-btn { + background: none; + border: none; + color: var(--interactive-normal); + cursor: pointer; + font-size: 1.2rem; +} diff --git a/src/App.integration.test.tsx b/src/App.integration.test.tsx new file mode 100644 index 0000000..6e2bcd7 --- /dev/null +++ b/src/App.integration.test.tsx @@ -0,0 +1,76 @@ +import { render, screen, waitFor } from '@testing-library/react'; +import userEvent from '@testing-library/user-event'; +import { describe, it, expect } from 'vitest'; +import App from './App'; +import { SpacetimeDBProvider } from 'spacetimedb/react'; +import { DbConnection } from './module_bindings'; + +describe('App Integration Test', () => { + it('connects to the DB, allows name change and message sending', async () => { + const connectionBuilder = DbConnection.builder() + .withUri('ws://localhost:3000') + .withDatabaseName('quickstart-chat') + .withToken( + localStorage.getItem( + 'ws://localhost:3000/quickstart-chat/auth_token' + ) || '' + ); + render( + + + + ); + + // Initially, we should see "Connecting..." + expect(screen.getByText(/Connecting.../i)).toBeInTheDocument(); + + // Wait until "Connecting..." is gone (meaning we've connected) + // This might require the actual DB to accept the connection + await waitFor( + () => + expect(screen.queryByText(/Connecting.../i)).not.toBeInTheDocument(), + { timeout: 10000 } + ); + + // The profile section should show the default name or truncated identity + // For example, you can check if the text is rendered. + // If your default identity is something like 'abcdef12' or 'Unknown' + // we do a generic check: + expect( + screen.getByRole('heading', { name: /profile/i }) + ).toBeInTheDocument(); + + // Let's change the user's name + const editNameButton = screen.getByText(/Edit Name/i); + await userEvent.click(editNameButton); + + const nameInput = screen.getByRole('textbox', { name: /name input/i }); + await userEvent.clear(nameInput); + await userEvent.type(nameInput, 'TestUser'); + const submitNameButton = screen.getByRole('button', { name: /submit/i }); + await userEvent.click(submitNameButton); + + // If your DB or UI updates instantly, we can check that the new name shows up + await waitFor( + () => { + expect(screen.getByText('TestUser')).toBeInTheDocument(); + }, + { timeout: 10000 } + ); + + // Now let's send a message + const textarea = screen.getByRole('textbox', { name: /message input/i }); + await userEvent.type(textarea, 'Hello from GH Actions!'); + + const sendButton = screen.getByRole('button', { name: /send/i }); + await userEvent.click(sendButton); + + // Wait for message to appear in the UI + await waitFor( + () => { + expect(screen.getByText('Hello from GH Actions!')).toBeInTheDocument(); + }, + { timeout: 10000 } + ); + }); +}); diff --git a/src/App.tsx b/src/App.tsx new file mode 100644 index 0000000..3dfc635 --- /dev/null +++ b/src/App.tsx @@ -0,0 +1,653 @@ +import React, { useState, useMemo, useEffect, useCallback, useRef } from 'react'; +import './App.css'; +import { tables, reducers } from './module_bindings'; +import type * as Types from './module_bindings/types'; +import { useSpacetimeDB, useTable, useReducer } from 'spacetimedb/react'; +import { Identity } from 'spacetimedb'; +import { useAuth } from "react-oidc-context"; +import { TOKEN_KEY } from './main'; + +const VoiceAudio = ({ stream }: { stream?: MediaStream }) => { + const audioRef = React.useRef(null); + useEffect(() => { + if (audioRef.current && stream) { + audioRef.current.srcObject = stream; + } + }, [stream]); + return