From b33fce53ddc381dba5266d9fc4895a5eed662b52 Mon Sep 17 00:00:00 2001 From: Adam Lamers Date: Sat, 28 Mar 2026 22:05:24 -0400 Subject: [PATCH] initial commit --- .cursor/rules/spacetimedb-typescript.mdc | 659 ++ .cursor/rules/spacetimedb.mdc | 116 + .env.local | 23 + .github/copilot-instructions.md | 766 ++ .gitignore | 47 + .windsurfrules | 766 ++ AGENTS.md | 766 ++ CHANGELOG.md | 29 + CLAUDE.md | 766 ++ LICENSE | 202 + README.md | 67 + dist/assets/index-DnMf931V.js | 86 + dist/assets/index-a-MKc3No.css | 1 + dist/index.html | 14 + dist/vite.svg | 1 + index.html | 13 + package.json | 45 + pnpm-lock.yaml | 2993 ++++++++ public/vite.svg | 1 + spacetime.json | 8 + spacetime.local.json | 3 + spacetimedb/dist/bundle.js | 6385 +++++++++++++++++ spacetimedb/node_modules/.bin/tsc | 21 + spacetimedb/node_modules/.bin/tsserver | 21 + spacetimedb/node_modules/.modules.yaml | 51 + .../.pnpm-workspace-state-v1.json | 25 + spacetimedb/node_modules/spacetimedb | 1 + spacetimedb/node_modules/typescript | 1 + spacetimedb/package-lock.json | 113 + spacetimedb/package.json | 16 + spacetimedb/pnpm-lock.yaml | 107 + spacetimedb/src/index.ts | 430 ++ spacetimedb/tsconfig.json | 28 + src/.gitattributes | 1 + src/App.css | 455 ++ src/App.integration.test.tsx | 76 + src/App.tsx | 653 ++ src/assets/react.svg | 1 + src/index.css | 76 + src/main.tsx | 81 + src/module_bindings/channel_table.ts | 24 + src/module_bindings/create_channel_reducer.ts | 17 + src/module_bindings/create_server_reducer.ts | 15 + src/module_bindings/create_thread_reducer.ts | 17 + src/module_bindings/ice_candidate_table.ts | 18 + src/module_bindings/index.ts | 253 + src/module_bindings/join_voice_reducer.ts | 15 + src/module_bindings/leave_voice_reducer.ts | 13 + src/module_bindings/login_reducer.ts | 16 + src/module_bindings/message_table.ts | 20 + src/module_bindings/register_reducer.ts | 16 + src/module_bindings/sdp_answer_table.ts | 18 + src/module_bindings/sdp_offer_table.ts | 18 + .../send_ice_candidate_reducer.ts | 17 + src/module_bindings/send_message_reducer.ts | 17 + .../send_sdp_answer_reducer.ts | 17 + src/module_bindings/send_sdp_offer_reducer.ts | 17 + src/module_bindings/server_table.ts | 17 + src/module_bindings/set_name_reducer.ts | 15 + src/module_bindings/thread_table.ts | 18 + src/module_bindings/types.ts | 95 + src/module_bindings/types/procedures.ts | 10 + src/module_bindings/types/reducers.ts | 34 + src/module_bindings/user_table.ts | 21 + src/module_bindings/voice_state_table.ts | 16 + src/setupTests.ts | 1 + src/useWebRTC.ts | 205 + tsconfig.app.json | 25 + tsconfig.json | 7 + tsconfig.node.json | 24 + vite.config.ts | 14 + vitest.config.ts | 13 + 72 files changed, 16957 insertions(+) create mode 100644 .cursor/rules/spacetimedb-typescript.mdc create mode 100644 .cursor/rules/spacetimedb.mdc create mode 100644 .env.local create mode 100644 .github/copilot-instructions.md create mode 100644 .gitignore create mode 100644 .windsurfrules create mode 100644 AGENTS.md create mode 100644 CHANGELOG.md create mode 100644 CLAUDE.md create mode 100644 LICENSE create mode 100644 README.md create mode 100644 dist/assets/index-DnMf931V.js create mode 100644 dist/assets/index-a-MKc3No.css create mode 100644 dist/index.html create mode 100644 dist/vite.svg create mode 100644 index.html create mode 100644 package.json create mode 100644 pnpm-lock.yaml create mode 100644 public/vite.svg create mode 100644 spacetime.json create mode 100644 spacetime.local.json create mode 100644 spacetimedb/dist/bundle.js create mode 100755 spacetimedb/node_modules/.bin/tsc create mode 100755 spacetimedb/node_modules/.bin/tsserver create mode 100644 spacetimedb/node_modules/.modules.yaml create mode 100644 spacetimedb/node_modules/.pnpm-workspace-state-v1.json create mode 120000 spacetimedb/node_modules/spacetimedb create mode 120000 spacetimedb/node_modules/typescript create mode 100644 spacetimedb/package-lock.json create mode 100644 spacetimedb/package.json create mode 100644 spacetimedb/pnpm-lock.yaml create mode 100644 spacetimedb/src/index.ts create mode 100644 spacetimedb/tsconfig.json create mode 100644 src/.gitattributes create mode 100644 src/App.css create mode 100644 src/App.integration.test.tsx create mode 100644 src/App.tsx create mode 100644 src/assets/react.svg create mode 100644 src/index.css create mode 100644 src/main.tsx create mode 100644 src/module_bindings/channel_table.ts create mode 100644 src/module_bindings/create_channel_reducer.ts create mode 100644 src/module_bindings/create_server_reducer.ts create mode 100644 src/module_bindings/create_thread_reducer.ts create mode 100644 src/module_bindings/ice_candidate_table.ts create mode 100644 src/module_bindings/index.ts create mode 100644 src/module_bindings/join_voice_reducer.ts create mode 100644 src/module_bindings/leave_voice_reducer.ts create mode 100644 src/module_bindings/login_reducer.ts create mode 100644 src/module_bindings/message_table.ts create mode 100644 src/module_bindings/register_reducer.ts create mode 100644 src/module_bindings/sdp_answer_table.ts create mode 100644 src/module_bindings/sdp_offer_table.ts create mode 100644 src/module_bindings/send_ice_candidate_reducer.ts create mode 100644 src/module_bindings/send_message_reducer.ts create mode 100644 src/module_bindings/send_sdp_answer_reducer.ts create mode 100644 src/module_bindings/send_sdp_offer_reducer.ts create mode 100644 src/module_bindings/server_table.ts create mode 100644 src/module_bindings/set_name_reducer.ts create mode 100644 src/module_bindings/thread_table.ts create mode 100644 src/module_bindings/types.ts create mode 100644 src/module_bindings/types/procedures.ts create mode 100644 src/module_bindings/types/reducers.ts create mode 100644 src/module_bindings/user_table.ts create mode 100644 src/module_bindings/voice_state_table.ts create mode 100644 src/setupTests.ts create mode 100644 src/useWebRTC.ts create mode 100644 tsconfig.app.json create mode 100644 tsconfig.json create mode 100644 tsconfig.node.json create mode 100644 vite.config.ts create mode 100644 vitest.config.ts 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