[{"_1":2,"_473":-5,"_474":-5},"loaderData",{"_3":4,"_14":15,"_26":27,"_472":-5},"root",{"_5":6,"_7":8,"_9":10,"_11":-7,"_12":13},"hasLegacySpacetimeAuthProject",false,"stargazersCount",25095,"isAnnouncementVisible",true,"sessionUserInfo","latestRelease","v2.10","routes/_marketing.llm-benchmarks",{"_16":17,"_21":22,"_24":20,"_25":23},"languages",[18,19,20],"csharp","rust","typescript","modes",[23],"guidelines","lang","mode","routes/_marketing.llm-benchmarks.evals",{"_28":29},"categories",{"_30":31,"_112":113,"_164":165,"_206":207,"_238":239,"_285":286,"_327":328,"_359":360,"_396":397,"_413":414,"_455":456},"basics",[32,42,47,52,57,62,67,72,77,82,87,92,97,102,107],{"_33":34,"_35":30,"_36":37,"_38":39,"_40":41},"id","t_000_empty_reducers","category","title","Empty Reducers","description","Write a SpacetimeDB backend module in TypeScript that defines a table and these five empty reducers.\n\nTABLES\n- empty_table (private)\n - Fields:\n - id: number (i32, primary key)\n\nREDUCERS\n- emptyReducerNoArgs: no arguments\n- emptyReducerWithInt: count:number (i32)\n- emptyReducerWithString: name:string\n- emptyReducerWithTwoArgs: count:number (i32), name:string\n- emptyReducerWithThreeArgs: active:boolean, ratio:number (f32), label:string","goldenAnswer","import { schema, table, t } from 'spacetimedb/server';\n\nconst empty_table = table({ name: 'empty_table' }, { id: t.i32().primaryKey() });\n\nconst spacetimedb = schema({ empty_table });\nexport default spacetimedb;\n\nexport const emptyReducerNoArgs = spacetimedb.reducer({}, ctx => {\n});\n\nexport const emptyReducerWithInt = spacetimedb.reducer({ count: t.i32() }, (ctx, { count }) => {\n});\n\nexport const emptyReducerWithString = spacetimedb.reducer({ name: t.string() }, (ctx, { name }) => {\n});\n\nexport const emptyReducerWithTwoArgs = spacetimedb.reducer({ count: t.i32(), name: t.string() }, (ctx, { count, name }) => {\n});\n\nexport const emptyReducerWithThreeArgs = spacetimedb.reducer({ active: t.bool(), ratio: t.f32(), label: t.string() }, (ctx, { active, ratio, label }) => {\n});\n",{"_33":43,"_35":30,"_36":44,"_38":45,"_40":46},"t_001_basic_tables","Basic Tables","Write a SpacetimeDB backend module in TypeScript that defines three tables with basic columns.\n\nTABLES\n- user (private)\n - Fields:\n - id: number (i32, primary key)\n - name: string\n - age: number (i32)\n - active: boolean\n\n- product (private)\n - Fields:\n - id: number (i32, primary key)\n - title: string\n - price: number (f32)\n - inStock: boolean\n\n- note (private)\n - Fields:\n - id: number (i32, primary key)\n - body: string\n - rating: bigint (i64)\n - pinned: boolean","import { table, schema, t } from 'spacetimedb/server';\n\nconst user = table({\n name: 'user',\n}, {\n id: t.i32().primaryKey(),\n name: t.string(),\n age: t.i32(),\n active: t.bool(),\n});\n\nconst product = table({\n name: 'product',\n}, {\n id: t.i32().primaryKey(),\n title: t.string(),\n price: t.f32(),\n inStock: t.bool(),\n});\n\nconst note = table({\n name: 'note',\n}, {\n id: t.i32().primaryKey(),\n body: t.string(),\n rating: t.i64(),\n pinned: t.bool(),\n});\n\nconst spacetimedb = schema({ user, product, note });\nexport default spacetimedb;\n",{"_33":48,"_35":30,"_36":49,"_38":50,"_40":51},"t_002_scheduled_table","Scheduled Table","Write a SpacetimeDB backend module in TypeScript that defines a scheduled table and a scheduled reducer.\n\nTABLE\n- tick_timer\n - Fields:\n - scheduledId: bigint (u64, primary key, auto-increment)\n - scheduledAt: ScheduleAt\n - Scheduled: tick reducer, interval of 50ms\n\nREDUCERS\n- tick: scheduled reducer that receives the tick_timer row\n- init: insert initial scheduled row with 50ms interval","import { ScheduleAt } from 'spacetimedb';\nimport { table, schema, t } from 'spacetimedb/server';\n\nconst tick_timer = table({\n name: 'tick_timer',\n scheduled: (): any => tick,\n}, {\n scheduledId: t.u64().primaryKey().autoInc(),\n scheduledAt: t.scheduleAt(),\n});\n\nconst spacetimedb = schema({ tick_timer });\nexport default spacetimedb;\n\nexport const tick = spacetimedb.reducer({ timer: tick_timer.rowType }, (ctx, { timer }) => {\n});\n\nexport const init = spacetimedb.init(ctx => {\n ctx.db.tick_timer.insert({\n scheduledId: 0n,\n scheduledAt: ScheduleAt.interval(50_000n),\n });\n});\n",{"_33":53,"_35":30,"_36":54,"_38":55,"_40":56},"t_003_struct_in_table","Struct In Table","Write a SpacetimeDB backend module in TypeScript that defines a struct type and uses it in a table.\n\nTYPES\n- Position\n - x: number (i32)\n - y: number (i32)\n\nTABLE\n- entity\n - Fields:\n - id: number (i32, primary key)\n - pos: Position","import { table, schema, t } from 'spacetimedb/server';\n\nconst Position = t.object('Position', {\n x: t.i32(),\n y: t.i32(),\n});\n\nconst entity = table({\n name: 'entity',\n}, {\n id: t.i32().primaryKey(),\n pos: Position,\n});\n\nconst spacetimedb = schema({ entity });\nexport default spacetimedb;\n",{"_33":58,"_35":30,"_36":59,"_38":60,"_40":61},"t_004_insert","Insert","Write a SpacetimeDB backend module in TypeScript that defines one table and a reducer that inserts a row.\n\nTABLE\n- user (public)\n - Fields:\n - id: number (i32, primary key)\n - name: string\n - age: number (i32)\n - active: boolean\n\nREDUCERS\n- insertUser: given id:number, name:string, age:number, active:boolean, insert exactly one row into user\n - (id=id, name=name, age=age, active=active)","import { table, schema, t } from 'spacetimedb/server';\n\nconst user = table(\n {\n name: 'user',\n public: true,\n },\n {\n id: t.i32().primaryKey(),\n name: t.string(),\n age: t.i32(),\n active: t.bool(),\n }\n);\n\nconst spacetimedb = schema({ user });\nexport default spacetimedb;\n\nexport const insertUser = spacetimedb.reducer(\n { id: t.i32(), name: t.string(), age: t.i32(), active: t.bool() },\n (ctx, { id, name, age, active }) => {\n ctx.db.user.insert({ id, name, age, active });\n }\n);\n",{"_33":63,"_35":30,"_36":64,"_38":65,"_40":66},"t_005_update","Update","Write a SpacetimeDB backend module in TypeScript that defines one table and two reducers: one that inserts a row and one that updates a row.\n\nTABLE\n- user (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - age: number (i32)\n - active: boolean\n\nREDUCERS\n- insertUser: given name:string, age:number, active:boolean, insert a new row (id is auto-assigned)\n- updateUser: given id:number, name:string, age:number, active:boolean, update the row with matching id\n - (id=id, name=name, age=age, active=active)","import { table, schema, t } from 'spacetimedb/server';\n\nconst user = table(\n {\n name: 'user',\n public: true,\n },\n {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n age: t.i32(),\n active: t.bool(),\n }\n);\n\nconst spacetimedb = schema({ user });\nexport default spacetimedb;\n\nexport const insertUser = spacetimedb.reducer(\n { name: t.string(), age: t.i32(), active: t.bool() },\n (ctx, { name, age, active }) => {\n ctx.db.user.insert({ id: 0n, name, age, active });\n }\n);\n\nexport const updateUser = spacetimedb.reducer(\n { id: t.u64(), name: t.string(), age: t.i32(), active: t.bool() },\n (ctx, { id, name, age, active }) => {\n ctx.db.user.id.update({ id, name, age, active });\n }\n);\n",{"_33":68,"_35":30,"_36":69,"_38":70,"_40":71},"t_006_delete","Delete","Write a SpacetimeDB backend module in TypeScript that defines one table and two reducers: one that inserts a row and one that deletes a row.\n\nTABLE\n- user (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - age: number (i32)\n - active: boolean\n\nREDUCERS\n- insertUser: given name:string, age:number, active:boolean, insert a new row (id is auto-assigned)\n- deleteUser: given id:number, delete the row with matching id","import { table, schema, t } from 'spacetimedb/server';\n\nconst user = table(\n {\n name: 'user',\n public: true,\n },\n {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n age: t.i32(),\n active: t.bool(),\n }\n);\n\nconst spacetimedb = schema({ user });\nexport default spacetimedb;\n\nexport const insertUser = spacetimedb.reducer(\n { name: t.string(), age: t.i32(), active: t.bool() },\n (ctx, { name, age, active }) => {\n ctx.db.user.insert({ id: 0n, name, age, active });\n }\n);\n\nexport const deleteUser = spacetimedb.reducer(\n { id: t.u64() },\n (ctx, { id }) => {\n ctx.db.user.id.delete(id);\n }\n);\n",{"_33":73,"_35":30,"_36":74,"_38":75,"_40":76},"t_007_crud","Crud","Write a SpacetimeDB backend module in TypeScript that defines one table and a reducer that performs insert, update, and delete in one call.\n\nTABLE\n- user (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - age: number (i32)\n - active: boolean\n\nREDUCERS\n- crud: no arguments, performs the following operations in order:\n 1. Insert (name=\"Alice\", age=30, active=true) — id is auto-assigned\n 2. Insert (name=\"Bob\", age=22, active=false) — id is auto-assigned\n 3. Update row with id=1 to (name=\"Alice2\", age=31, active=false)\n 4. Delete row with id=2","import { table, schema, t } from 'spacetimedb/server';\n\nconst user = table(\n {\n name: 'user',\n public: true,\n },\n {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n age: t.i32(),\n active: t.bool(),\n }\n);\n\nconst spacetimedb = schema({ user });\nexport default spacetimedb;\n\nexport const crud = spacetimedb.reducer(ctx => {\n ctx.db.user.insert({ id: 0n, name: 'Alice', age: 30, active: true });\n ctx.db.user.insert({ id: 0n, name: 'Bob', age: 22, active: false });\n ctx.db.user.id.update({ id: 1n, name: 'Alice2', age: 31, active: false });\n ctx.db.user.id.delete(2n);\n});\n",{"_33":78,"_35":30,"_36":79,"_38":80,"_40":81},"t_008_index_lookup","Index Lookup","Write a SpacetimeDB backend module in TypeScript that defines two tables and two reducers: one that inserts a user row, and one that looks up a row by primary-key index and writes a projection to another table.\n\nTABLES\n- user\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - age: number (i32)\n - active: boolean\n\n- result (public)\n - Fields:\n - id: number (u64, primary key)\n - name: string\n\nREDUCERS\n- insertUser: given name:string, age:number, active:boolean, insert a new row into user (id is auto-assigned)\n- lookupUserName: given id:number, find user by id, insert projection (id, name) into result table","import { table, schema, t } from 'spacetimedb/server';\n\nconst user = table(\n {\n name: 'user',\n },\n {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n age: t.i32(),\n active: t.bool(),\n }\n);\n\nconst result = table(\n {\n name: 'result',\n public: true,\n },\n {\n id: t.u64().primaryKey(),\n name: t.string(),\n }\n);\n\nconst spacetimedb = schema({ user, result });\nexport default spacetimedb;\n\nexport const insertUser = spacetimedb.reducer(\n { name: t.string(), age: t.i32(), active: t.bool() },\n (ctx, { name, age, active }) => {\n ctx.db.user.insert({ id: 0n, name, age, active });\n }\n);\n\nexport const lookupUserName = spacetimedb.reducer(\n { id: t.u64() },\n (ctx, { id }) => {\n const u = ctx.db.user.id.find(id);\n if (u) {\n ctx.db.result.insert({ id: u.id, name: u.name });\n }\n }\n);\n",{"_33":83,"_35":30,"_36":84,"_38":85,"_40":86},"t_009_init","Init","Write a SpacetimeDB backend module in TypeScript that defines one table and an init reducer that seeds rows on database initialization.\n\nTABLE\n- user (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - age: number (i32)\n - active: boolean\n\nREDUCERS\n- init: insert exactly two rows on database initialization (IDs are auto-assigned):\n 1. (name=\"Alice\", age=30, active=true)\n 2. (name=\"Bob\", age=22, active=false)","import { table, schema, t } from 'spacetimedb/server';\n\nconst user = table(\n {\n name: 'user',\n public: true,\n },\n {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n age: t.i32(),\n active: t.bool(),\n }\n);\n\nconst spacetimedb = schema({ user });\nexport default spacetimedb;\n\nexport const init = spacetimedb.init(ctx => {\n ctx.db.user.insert({ id: 0n, name: 'Alice', age: 30, active: true });\n ctx.db.user.insert({ id: 0n, name: 'Bob', age: 22, active: false });\n});\n",{"_33":88,"_35":30,"_36":89,"_38":90,"_40":91},"t_010_connect","Connect","Write a SpacetimeDB backend module in TypeScript that defines one table and two reducers for client lifecycle events.\n\nTABLE\n- event (private)\n - Fields:\n - id: bigint (u64, primary key, auto-increment)\n - kind: string\n\nLIFECYCLE HOOKS (use spacetimedb.clientConnected / spacetimedb.clientDisconnected)\n- onConnect: insert event with kind=\"connected\"\n- onDisconnect: insert event with kind=\"disconnected\"","import { table, schema, t } from 'spacetimedb/server';\n\nconst event = table(\n {\n name: 'event',\n },\n {\n id: t.u64().primaryKey().autoInc(),\n kind: t.string(),\n }\n);\n\nconst spacetimedb = schema({ event });\nexport default spacetimedb;\n\nexport const onConnect = spacetimedb.clientConnected(ctx => {\n ctx.db.event.insert({ id: 0n, kind: 'connected' });\n});\n\nexport const onDisconnect = spacetimedb.clientDisconnected(ctx => {\n ctx.db.event.insert({ id: 0n, kind: 'disconnected' });\n});\n",{"_33":93,"_35":30,"_36":94,"_38":95,"_40":96},"t_011_helper_function","Helper Function","Write a SpacetimeDB backend module in TypeScript that defines a table, a non-reducer helper function, and a reducer that uses the helper.\n\nTABLE\n- result (public)\n - Fields:\n - id: number (i32, primary key)\n - sum: number (i32)\n\nHELPER FUNCTION\n- add(a: number, b: number): number - returns a + b\n\nREDUCERS\n- computeSum: given id:number, a:number, b:number, insert row with sum=add(a,b)","import { table, schema, t } from 'spacetimedb/server';\n\nconst result = table({\n name: 'result',\n public: true,\n}, {\n id: t.i32().primaryKey(),\n sum: t.i32(),\n});\n\nconst spacetimedb = schema({ result });\nexport default spacetimedb;\n\nfunction add(a: number, b: number): number {\n return a + b;\n}\n\nexport const computeSum = spacetimedb.reducer({ id: t.i32(), a: t.i32(), b: t.i32() },\n (ctx, { id, a, b }) => {\n ctx.db.result.insert({ id, sum: add(a, b) });\n }\n);\n",{"_33":98,"_35":30,"_36":99,"_38":100,"_40":101},"t_038_schedule_at_time","Schedule At Time","Write a SpacetimeDB backend module in TypeScript that schedules a one-shot reducer to fire at a specific future time.\n\nTABLE\n- reminder\n - Fields:\n - scheduledId: u64 (primary key, auto-increment)\n - scheduledAt: scheduleAt\n - message: string\n - Scheduling: scheduled to call the send_reminder reducer\n\nREDUCERS\n- send_reminder: scheduled reducer triggered by reminder (receives a reminder row argument, does nothing)\n- init: inserts one row into reminder scheduling send_reminder to fire 60 seconds in the future using ScheduleAt.time\n - Use ctx.timestamp + 60_000_000n microseconds to compute the fire time as a BigInt","import { ScheduleAt } from 'spacetimedb';\nimport { schema, table, t } from 'spacetimedb/server';\n\nconst reminder = table({\n name: 'reminder',\n scheduled: (): any => sendReminder,\n}, {\n scheduledId: t.u64().primaryKey().autoInc(),\n scheduledAt: t.scheduleAt(),\n message: t.string(),\n});\n\nconst spacetimedb = schema({ reminder });\nexport default spacetimedb;\n\nexport const sendReminder = spacetimedb.reducer(\n { timer: reminder.rowType },\n (_ctx, _args) => {}\n);\n\nexport const init = spacetimedb.init(ctx => {\n const fireAt = ctx.timestamp.microsSinceUnixEpoch + 60_000_000n;\n ctx.db.reminder.insert({\n scheduledId: 0n,\n scheduledAt: ScheduleAt.time(fireAt),\n message: 'Hello!',\n });\n});\n",{"_33":103,"_35":30,"_36":104,"_38":105,"_40":106},"t_039_cancel_schedule","Cancel Schedule","Write a SpacetimeDB backend module in TypeScript that schedules a reducer and allows canceling it before it fires.\n\nTABLE\n- cleanup_job\n - Fields:\n - scheduledId: u64 (primary key, auto-increment)\n - scheduledAt: scheduleAt\n - Scheduling: scheduled to call the run_cleanup reducer\n\nREDUCERS\n- run_cleanup: scheduled reducer triggered by cleanup_job (receives a cleanup_job row argument, does nothing)\n- init: inserts one row into cleanup_job with a 60-second interval (60_000_000n microseconds)\n- cancel_cleanup(ctx, { scheduledId: u64 }): deletes the cleanup_job row with the given scheduledId, canceling the pending scheduled call","import { ScheduleAt } from 'spacetimedb';\nimport { schema, table, t } from 'spacetimedb/server';\n\nconst cleanup_job = table({\n name: 'cleanup_job',\n scheduled: (): any => runCleanup,\n}, {\n scheduledId: t.u64().primaryKey().autoInc(),\n scheduledAt: t.scheduleAt(),\n});\n\nconst spacetimedb = schema({ cleanup_job });\nexport default spacetimedb;\n\nexport const runCleanup = spacetimedb.reducer(\n { timer: cleanup_job.rowType },\n (_ctx, _args) => {}\n);\n\nexport const init = spacetimedb.init(ctx => {\n ctx.db.cleanup_job.insert({\n scheduledId: 0n,\n scheduledAt: ScheduleAt.interval(60_000_000n),\n });\n});\n\nexport const cancelCleanup = spacetimedb.reducer(\n { scheduledId: t.u64() },\n (ctx, { scheduledId }) => {\n ctx.db.cleanup_job.scheduledId.delete(scheduledId);\n }\n);\n",{"_33":108,"_35":30,"_36":109,"_38":110,"_40":111},"t_040_lifecycle_player","Lifecycle Player","Write a SpacetimeDB backend module in TypeScript that maintains a table of currently connected players using lifecycle reducers.\n\nTABLE\n- online_player (public)\n - Fields:\n - identity: identity (primary key)\n - connectedAt: timestamp\n\nREDUCERS\n- clientConnected: lifecycle reducer (spacetimedb.clientConnected) that inserts an online_player row using ctx.sender as the identity and ctx.timestamp as connectedAt\n- clientDisconnected: lifecycle reducer (spacetimedb.clientDisconnected) that deletes the online_player row for ctx.sender","import { schema, table, t } from 'spacetimedb/server';\n\nconst online_player = table({\n name: 'online_player',\n public: true,\n}, {\n identity: t.identity().primaryKey(),\n connectedAt: t.timestamp(),\n});\n\nconst spacetimedb = schema({ online_player });\nexport default spacetimedb;\n\nexport const clientConnected = spacetimedb.clientConnected(ctx => {\n ctx.db.online_player.insert({\n identity: ctx.sender,\n connectedAt: ctx.timestamp,\n });\n});\n\nexport const clientDisconnected = spacetimedb.clientDisconnected(ctx => {\n ctx.db.online_player.identity.delete(ctx.sender);\n});\n","schema",[114,119,124,129,134,139,144,149,154,159],{"_33":115,"_35":112,"_36":116,"_38":117,"_40":118},"t_012_spacetime_product_type","Spacetime Product Type","Write a SpacetimeDB backend module in TypeScript that defines a product type and uses it in a table.\n\nTYPES\n- Score\n - left: number (i32)\n - right: number (i32)\n\nTABLE\n- result (public)\n - Fields:\n - id: number (i32, primary key)\n - value: Score\n\nREDUCERS\n- setScore: given id:number, left:number, right:number, insert row with value=Score{left, right}","import { table, schema, t } from 'spacetimedb/server';\n\nconst Score = t.object('Score', {\n left: t.i32(),\n right: t.i32(),\n});\n\nconst result = table({\n name: 'result',\n public: true,\n}, {\n id: t.i32().primaryKey(),\n value: Score,\n});\n\nconst spacetimedb = schema({ result });\nexport default spacetimedb;\n\nexport const setScore = spacetimedb.reducer({ id: t.i32(), left: t.i32(), right: t.i32() },\n (ctx, { id, left, right }) => {\n ctx.db.result.insert({ id, value: { left, right } });\n }\n);\n",{"_33":120,"_35":112,"_36":121,"_38":122,"_40":123},"t_013_spacetime_sum_type","Spacetime Sum Type","Write a SpacetimeDB backend module in TypeScript that defines a new sum type and uses it in a table.\n\nTYPES\n- Rect\n - width: number (i32)\n - height: number (i32)\n- Shape (sum type / enum)\n - circle: number (i32 radius)\n - rectangle: Rect\n\nTABLE\n- result (public)\n - Fields:\n - id: number (i32, primary key)\n - value: Shape\n\nREDUCERS\n- setCircle: given id:number, radius:number, insert row with value=Shape.circle(radius)","import { table, schema, t } from 'spacetimedb/server';\n\nconst Rect = t.object('Rect', {\n width: t.i32(),\n height: t.i32(),\n});\n\nconst Shape = t.enum('Shape', {\n circle: t.i32(),\n rectangle: Rect,\n});\n\nconst result = table(\n {\n name: 'result',\n public: true,\n },\n {\n id: t.i32().primaryKey(),\n value: Shape,\n }\n);\n\nconst spacetimedb = schema({ result });\nexport default spacetimedb;\n\nexport const setCircle = spacetimedb.reducer(\n { id: t.i32(), radius: t.i32() },\n (ctx, { id, radius }) => {\n ctx.db.result.insert({ id, value: { tag: 'circle', value: radius } });\n }\n);\n",{"_33":125,"_35":112,"_36":126,"_38":127,"_40":128},"t_014_elementary_columns","Elementary Columns","Write a SpacetimeDB backend module in TypeScript that defines one table and seeds one row.\n\nTABLE\n- primitive (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - count: number (i32)\n - total: bigint (i64)\n - price: number (f32)\n - ratio: number (f64)\n - active: boolean\n - name: string\n\nREDUCERS\n- seed: insert one row with all field types (id is auto-assigned):\n - (count=2, total=3000000000, price=1.5, ratio=2.25, active=true, name=\"Alice\")","import { table, schema, t } from 'spacetimedb/server';\n\nconst primitive = table(\n {\n name: 'primitive',\n public: true,\n },\n {\n id: t.u64().primaryKey().autoInc(),\n count: t.i32(),\n total: t.i64(),\n price: t.f32(),\n ratio: t.f64(),\n active: t.bool(),\n name: t.string(),\n }\n);\n\nconst spacetimedb = schema({ primitive });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.primitive.insert({\n id: 0n,\n count: 2,\n total: 3000000000n,\n price: 1.5,\n ratio: 2.25,\n active: true,\n name: 'Alice',\n });\n});\n",{"_33":130,"_35":112,"_36":131,"_38":132,"_40":133},"t_015_product_type_columns","Product Type Columns","Write a SpacetimeDB backend module in TypeScript that defines product types and uses them as columns in a table.\n\nTYPES\n- Address\n - street: string\n - zip: number (i32)\n- Position\n - x: number (i32)\n - y: number (i32)\n\nTABLE\n- profile (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - home: Address\n - work: Address\n - pos: Position\n\nREDUCERS\n- seed: insert one row with all nested types (id is auto-assigned):\n - home: { street: \"1 Main\", zip: 11111 }\n - work: { street: \"2 Broad\", zip: 22222 }\n - pos: { x: 7, y: 9 }","import { table, schema, t } from 'spacetimedb/server';\n\nconst Address = t.object('Address', {\n street: t.string(),\n zip: t.i32(),\n});\n\nconst Position = t.object('Position', {\n x: t.i32(),\n y: t.i32(),\n});\n\nconst profile = table(\n {\n name: 'profile',\n public: true,\n },\n {\n id: t.u64().primaryKey().autoInc(),\n home: Address,\n work: Address,\n pos: Position,\n }\n);\n\nconst spacetimedb = schema({ profile });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.profile.insert({\n id: 0n,\n home: { street: '1 Main', zip: 11111 },\n work: { street: '2 Broad', zip: 22222 },\n pos: { x: 7, y: 9 },\n });\n});\n",{"_33":135,"_35":112,"_36":136,"_38":137,"_40":138},"t_016_sum_type_columns","Sum Type Columns","Write a SpacetimeDB backend module in TypeScript that defines a sum type and uses it in multiple table columns.\n\nTYPES\n- Rect\n - width: number (i32)\n - height: number (i32)\n- Shape (sum type / enum)\n - circle: number (i32 radius)\n - rectangle: Rect\n\nTABLE\n- drawing (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - a: Shape\n - b: Shape\n\nREDUCERS\n- seed: insert one row with two Shape values (id is auto-assigned):\n - a: Shape.circle(10)\n - b: Shape.rectangle({ width: 4, height: 6 })","import { table, schema, t } from 'spacetimedb/server';\n\nconst Rect = t.object('Rect', {\n width: t.i32(),\n height: t.i32(),\n});\n\nconst Shape = t.enum('Shape', {\n circle: t.i32(),\n rectangle: Rect,\n});\n\nconst drawing = table({\n name: 'drawing',\n public: true,\n}, {\n id: t.u64().primaryKey().autoInc(),\n a: Shape,\n b: Shape,\n});\n\nconst spacetimedb = schema({ drawing });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(\n ctx => {\n ctx.db.drawing.insert({\n id: 0n,\n a: { tag: 'circle', value: 10 },\n b: { tag: 'rectangle', value: { width: 4, height: 6 } },\n });\n }\n);\n",{"_33":140,"_35":112,"_36":141,"_38":142,"_40":143},"t_017_scheduled_columns","Scheduled Columns","Write a SpacetimeDB backend module in TypeScript that defines a scheduled table and seeds one schedule entry.\n\nTABLE\n- tick_timer (public)\n - Fields:\n - scheduledId: bigint (u64, primary key, auto-increment)\n - scheduledAt: ScheduleAt\n - Scheduled: tick reducer, interval of 50ms\n\nREDUCERS\n- tick: scheduled reducer that receives the tick_timer row\n- init: insert initial scheduled row with 50ms interval","import { ScheduleAt } from 'spacetimedb';\nimport { table, schema, t } from 'spacetimedb/server';\n\nconst tick_timer = table(\n {\n name: 'tick_timer',\n public: true,\n scheduled: (): any => tick,\n },\n {\n scheduledId: t.u64().primaryKey().autoInc(),\n scheduledAt: t.scheduleAt(),\n }\n);\n\nconst spacetimedb = schema({ tick_timer });\nexport default spacetimedb;\n\nexport const tick = spacetimedb.reducer(\n { schedule: tick_timer.rowType },\n (ctx, { schedule }) => {}\n);\n\nexport const init = spacetimedb.init(ctx => {\n ctx.db.tick_timer.insert({\n scheduledId: 0n,\n scheduledAt: ScheduleAt.interval(50_000n),\n });\n});\n",{"_33":145,"_35":112,"_36":146,"_38":147,"_40":148},"t_018_constraints","Constraints","Write a SpacetimeDB backend module in TypeScript that defines one table and seeds two rows.\n\nTABLE\n- account (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - email: string (unique)\n - name: string\n - Index: byName (btree on name)\n\nREDUCERS\n- seed: insert two rows (IDs are auto-assigned):\n - (email=\"a@example.com\", name=\"Alice\")\n - (email=\"b@example.com\", name=\"Bob\")","import { table, schema, t } from 'spacetimedb/server';\n\nconst account = table({\n name: 'account',\n public: true,\n indexes: [{ accessor: 'byName', algorithm: 'btree', columns: ['name'] }],\n}, {\n id: t.u64().primaryKey().autoInc(),\n email: t.string().unique(),\n name: t.string(),\n});\n\nconst spacetimedb = schema({ account });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(\n ctx => {\n ctx.db.account.insert({ id: 0n, email: \"a@example.com\", name: \"Alice\" });\n ctx.db.account.insert({ id: 0n, email: \"b@example.com\", name: \"Bob\" });\n }\n);\n",{"_33":150,"_35":112,"_36":151,"_38":152,"_40":153},"t_019_many_to_many","Many To Many","Write a SpacetimeDB backend module in TypeScript that defines three tables modeling a many-to-many relationship and seeds rows.\n\nTABLES\n- user\n - Fields:\n - userId: number (u64, primary key, autoInc)\n - name: string\n\n- group\n - Fields:\n - groupId: number (u64, primary key, autoInc)\n - title: string\n\n- membership (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - userId: number (u64)\n - groupId: number (u64)\n - Indexes:\n - byUser (btree on userId)\n - byGroup (btree on groupId)\n\nREDUCERS\n- seed: insert users, groups, and memberships (IDs are auto-assigned):\n - user: (\"Alice\"), (\"Bob\")\n - group: (\"Admin\"), (\"Dev\")\n - membership: (userId=1, groupId=1), (userId=1, groupId=2), (userId=2, groupId=2)","import { table, schema, t } from 'spacetimedb/server';\n\nconst user = table(\n {\n name: 'user',\n },\n {\n userId: t.u64().primaryKey().autoInc(),\n name: t.string(),\n }\n);\n\nconst group = table(\n {\n name: 'group',\n },\n {\n groupId: t.u64().primaryKey().autoInc(),\n title: t.string(),\n }\n);\n\nconst membership = table(\n {\n name: 'membership',\n public: true,\n indexes: [\n { accessor: 'byUser', algorithm: 'btree', columns: ['userId'] },\n { accessor: 'byGroup', algorithm: 'btree', columns: ['groupId'] },\n ],\n },\n {\n id: t.u64().primaryKey().autoInc(),\n userId: t.u64(),\n groupId: t.u64(),\n }\n);\n\nconst spacetimedb = schema({ user, group, membership });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.user.insert({ userId: 0n, name: 'Alice' });\n ctx.db.user.insert({ userId: 0n, name: 'Bob' });\n\n ctx.db.group.insert({ groupId: 0n, title: 'Admin' });\n ctx.db.group.insert({ groupId: 0n, title: 'Dev' });\n\n ctx.db.membership.insert({ id: 0n, userId: 1n, groupId: 1n });\n ctx.db.membership.insert({ id: 0n, userId: 1n, groupId: 2n });\n ctx.db.membership.insert({ id: 0n, userId: 2n, groupId: 2n });\n});\n",{"_33":155,"_35":112,"_36":156,"_38":157,"_40":158},"t_020_ecs","Ecs","Write a SpacetimeDB backend module in TypeScript that models a minimal ECS and computes next positions.\n\nTABLES\n- entity\n - Fields:\n - id: number (u64, primary key, autoInc)\n\n- position (public)\n - Fields:\n - entityId: number (i32, primary key) — NOT autoInc, this is a foreign key to entity\n - x: number (i32)\n - y: number (i32)\n\n- velocity\n - Fields:\n - entityId: number (i32, primary key) — NOT autoInc, this is a foreign key to entity\n - vx: number (i32)\n - vy: number (i32)\n\n- next_position (public)\n - Fields:\n - entityId: number (i32, primary key) — NOT autoInc, this is a foreign key to entity\n - x: number (i32)\n - y: number (i32)\n\nREDUCERS\n- seed: insert 2 entities with positions and velocities (entity IDs are auto-assigned):\n - Entity 1: position(0,0), velocity(1,0)\n - Entity 2: position(10,0), velocity(-2,3)\n\n- step: for each position, find velocity, compute next position (x+vx, y+vy), upsert to next_position","import { table, schema, t } from 'spacetimedb/server';\n\nconst entity = table(\n {\n name: 'entity',\n },\n {\n id: t.u64().primaryKey().autoInc(),\n }\n);\n\nconst position = table(\n {\n name: 'position',\n public: true,\n },\n {\n entityId: t.i32().primaryKey(),\n x: t.i32(),\n y: t.i32(),\n }\n);\n\nconst velocity = table(\n {\n name: 'velocity',\n },\n {\n entityId: t.i32().primaryKey(),\n vx: t.i32(),\n vy: t.i32(),\n }\n);\n\nconst next_position = table(\n {\n name: 'next_position',\n public: true,\n },\n {\n entityId: t.i32().primaryKey(),\n x: t.i32(),\n y: t.i32(),\n }\n);\n\nconst spacetimedb = schema({ entity, position, velocity, next_position });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.entity.insert({ id: 0n });\n ctx.db.entity.insert({ id: 0n });\n\n ctx.db.position.insert({ entityId: 1, x: 0, y: 0 });\n ctx.db.position.insert({ entityId: 2, x: 10, y: 0 });\n\n ctx.db.velocity.insert({ entityId: 1, vx: 1, vy: 0 });\n ctx.db.velocity.insert({ entityId: 2, vx: -2, vy: 3 });\n});\n\nexport const step = spacetimedb.reducer(ctx => {\n for (const p of ctx.db.position.iter()) {\n const v = ctx.db.velocity.entityId.find(p.entityId);\n if (v) {\n const np = {\n entityId: p.entityId,\n x: p.x + v.vx,\n y: p.y + v.vy,\n };\n\n if (ctx.db.next_position.entityId.find(p.entityId)) {\n ctx.db.next_position.entityId.update(np);\n } else {\n ctx.db.next_position.insert(np);\n }\n }\n }\n});\n",{"_33":160,"_35":112,"_36":161,"_38":162,"_40":163},"t_021_multi_column_index","Multi Column Index","Write a SpacetimeDB backend module in TypeScript that defines one table with a multi-column B-Tree index and seeds rows.\n\nTABLE\n- log (public)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - userId: number (i32)\n - day: number (i32)\n - message: string\n - Index: byUserDay (btree on userId, day)\n\nREDUCERS\n- seed: insert three rows (IDs are auto-assigned):\n - (userId=7, day=1, message=\"a\")\n - (userId=7, day=2, message=\"b\")\n - (userId=9, day=1, message=\"c\")","import { table, schema, t } from 'spacetimedb/server';\n\nconst log = table({\n name: 'log',\n public: true,\n indexes: [{ accessor: 'byUserDay', algorithm: 'btree', columns: ['userId', 'day'] }],\n}, {\n id: t.u64().primaryKey().autoInc(),\n userId: t.i32(),\n day: t.i32(),\n message: t.string(),\n});\n\nconst spacetimedb = schema({ log });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(\n ctx => {\n ctx.db.log.insert({ id: 0n, userId: 7, day: 1, message: \"a\" });\n ctx.db.log.insert({ id: 0n, userId: 7, day: 2, message: \"b\" });\n ctx.db.log.insert({ id: 0n, userId: 9, day: 1, message: \"c\" });\n }\n);\n","queries",[166,171,176,181,186,191,196,201],{"_33":167,"_35":164,"_36":168,"_38":169,"_40":170},"t_022_view_basic","View Basic","Write a SpacetimeDB backend module in TypeScript that defines a public anonymous view over a table.\n\nTABLE\n- announcement (public)\n - Fields:\n - id: u64 (primary key, auto-increment)\n - message: string\n - active: bool (btree index)\n\nVIEW\n- activeAnnouncements (anonymousView, public)\n - Returns: array of announcement rows\n - Body: return all rows where active == true using the btree index filter","import { schema, table, t } from 'spacetimedb/server';\n\nconst announcement = table({\n name: 'announcement',\n public: true,\n}, {\n id: t.u64().primaryKey().autoInc(),\n message: t.string(),\n active: t.bool().index('btree'),\n});\n\nconst spacetimedb = schema({ announcement });\nexport default spacetimedb;\n\nexport const activeAnnouncements = spacetimedb.anonymousView(\n { name: 'active_announcements', public: true },\n t.array(announcement.rowType),\n (ctx) => {\n return Array.from(ctx.db.announcement.active.filter(true));\n }\n);\n",{"_33":172,"_35":164,"_36":173,"_38":174,"_40":175},"t_023_view_per_user","View Per User","Write a SpacetimeDB backend module in TypeScript that defines a table of user profiles and a per-user view that returns only the calling user's profile.\n\nTABLES\n- profile\n - public table\n - Fields:\n - id: number (u64, primary key, autoInc)\n - identity: Identity (unique)\n - name: string\n - bio: string\n\nVIEWS\n- my_profile\n - per-user view (uses spacetimedb.view, not spacetimedb.anonymousView)\n - public\n - Returns: option of profile row (the single profile matching ctx.sender(), or undefined)\n - Logic: find the profile by the identity column matching ctx.sender()","import { schema, table, t } from 'spacetimedb/server';\n\nconst profile = table({\n name: 'profile',\n public: true,\n}, {\n id: t.u64().primaryKey().autoInc(),\n identity: t.identity().unique(),\n name: t.string(),\n bio: t.string(),\n});\n\nconst spacetimedb = schema({ profile });\nexport default spacetimedb;\n\nexport const my_profile = spacetimedb.view(\n { name: 'my_profile', public: true },\n t.option(profile.rowType),\n (ctx) => {\n return ctx.db.profile.identity.find(ctx.sender) ?? undefined;\n }\n);\n",{"_33":177,"_35":164,"_36":178,"_38":179,"_40":180},"t_032_range_query","Range Query","Write a SpacetimeDB backend module in TypeScript that defines a product table with a BTree-indexed price column, a result table, and a reducer that filters products within a price range and writes matches to the result table.\n\nTABLES\n- product (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - price: number (u32, index btree)\n\n- price_range_result (private)\n - Fields:\n - productId: number (u64, primary key)\n - name: string\n - price: number (u32)\n\nREDUCERS\n- find_in_price_range(ctx, { minPrice: number (u32), maxPrice: number (u32) })\n - Iterate all products\n - For each product where price >= minPrice AND price <= maxPrice, insert a price_range_result row","import { schema, table, t } from 'spacetimedb/server';\n\nconst product = table({\n name: 'product',\n}, {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n price: t.u32().index('btree'),\n});\n\nconst price_range_result = table({\n name: 'price_range_result',\n}, {\n productId: t.u64().primaryKey(),\n name: t.string(),\n price: t.u32(),\n});\n\nconst spacetimedb = schema({ product, price_range_result });\nexport default spacetimedb;\n\nexport const find_in_price_range = spacetimedb.reducer(\n { minPrice: t.u32(), maxPrice: t.u32() },\n (ctx, { minPrice, maxPrice }) => {\n for (const p of ctx.db.product.iter()) {\n if (p.price >= minPrice && p.price <= maxPrice) {\n ctx.db.price_range_result.insert({\n productId: p.id,\n name: p.name,\n price: p.price,\n });\n }\n }\n }\n);\n",{"_33":182,"_35":164,"_36":183,"_38":184,"_40":185},"t_033_sort_and_limit","Sort And Limit","Write a SpacetimeDB backend module in TypeScript that defines a player table with scores, a leaderboard result table, and a reducer that finds the top N players by score (descending) and writes them to the result table.\n\nTABLES\n- player (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - score: number (u64)\n\n- leaderboard (private)\n - Fields:\n - rank: number (u32, primary key)\n - playerName: string\n - score: number (u64)\n\nREDUCERS\n- build_leaderboard(ctx, { limit: number (u32) })\n - Collect all players into an array, sort by score descending\n - Take the first `limit` entries\n - Insert each into leaderboard with rank starting at 1","import { schema, table, t } from 'spacetimedb/server';\n\nconst player = table({\n name: 'player',\n}, {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n score: t.u64(),\n});\n\nconst leaderboard = table({\n name: 'leaderboard',\n}, {\n rank: t.u32().primaryKey(),\n playerName: t.string(),\n score: t.u64(),\n});\n\nconst spacetimedb = schema({ player, leaderboard });\nexport default spacetimedb;\n\nexport const build_leaderboard = spacetimedb.reducer(\n { limit: t.u32() },\n (ctx, { limit }) => {\n const players = Array.from(ctx.db.player.iter());\n players.sort((a, b) => (b.score > a.score ? 1 : b.score < a.score ? -1 : 0));\n\n for (let i = 0; i < Math.min(limit, players.length); i++) {\n const p = players[i];\n ctx.db.leaderboard.insert({\n rank: i + 1,\n playerName: p.name,\n score: p.score,\n });\n }\n }\n);\n",{"_33":187,"_35":164,"_36":188,"_38":189,"_40":190},"t_034_find_first","Find First","Write a SpacetimeDB backend module in TypeScript that defines a task table and a result table, with a reducer that finds the first incomplete task and writes it to the result table.\n\nTABLES\n- task (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - title: string\n - completed: boolean\n\n- first_incomplete (private)\n - Fields:\n - taskId: number (u64, primary key)\n - title: string\n\nREDUCERS\n- find_first_incomplete(ctx)\n - Iterate through the task table\n - Find the first task where completed is false\n - If found, insert it into first_incomplete","import { schema, table, t } from 'spacetimedb/server';\n\nconst task = table({\n name: 'task',\n}, {\n id: t.u64().primaryKey().autoInc(),\n title: t.string(),\n completed: t.bool(),\n});\n\nconst first_incomplete = table({\n name: 'first_incomplete',\n}, {\n taskId: t.u64().primaryKey(),\n title: t.string(),\n});\n\nconst spacetimedb = schema({ task, first_incomplete });\nexport default spacetimedb;\n\nexport const find_first_incomplete = spacetimedb.reducer(\n (ctx) => {\n for (const t of ctx.db.task.iter()) {\n if (!t.completed) {\n ctx.db.first_incomplete.insert({\n taskId: t.id,\n title: t.title,\n });\n return;\n }\n }\n }\n);\n",{"_33":192,"_35":164,"_36":193,"_38":194,"_40":195},"t_035_select_distinct","Select Distinct","Write a SpacetimeDB backend module in TypeScript that defines an order table and a result table, with a reducer that collects all distinct category values from orders into the result table.\n\nTABLES\n- order (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - category: string\n - amount: number (u32)\n\n- distinct_category (private)\n - Fields:\n - category: string (primary key)\n\nREDUCERS\n- collect_distinct_categories(ctx)\n - Iterate all orders\n - Collect unique category values (use a Set)\n - Insert each unique category into distinct_category","import { schema, table, t } from 'spacetimedb/server';\n\nconst order = table({\n name: 'order',\n}, {\n id: t.u64().primaryKey().autoInc(),\n category: t.string(),\n amount: t.u32(),\n});\n\nconst distinct_category = table({\n name: 'distinct_category',\n}, {\n category: t.string().primaryKey(),\n});\n\nconst spacetimedb = schema({ order, distinct_category });\nexport default spacetimedb;\n\nexport const collect_distinct_categories = spacetimedb.reducer(\n (ctx) => {\n const categories = new Set();\n for (const o of ctx.db.order.iter()) {\n categories.add(o.category);\n }\n for (const category of categories) {\n ctx.db.distinct_category.insert({ category });\n }\n }\n);\n",{"_33":197,"_35":164,"_36":198,"_38":199,"_40":200},"t_036_count_without_collect","Count Without Collect","Write a SpacetimeDB backend module in TypeScript that defines a user table and a stats table, with a reducer that counts total users and active users without collecting into an array.\n\nTABLES\n- user (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - active: boolean\n\n- user_stats (private)\n - Fields:\n - key: string (primary key)\n - count: number (u64)\n\nREDUCERS\n- compute_user_counts(ctx)\n - Count total users by iterating (do not collect into an array first)\n - Count active users by iterating and checking active === true\n - Insert a user_stats row with key=\"total\" and the total count\n - Insert a user_stats row with key=\"active\" and the active count","import { schema, table, t } from 'spacetimedb/server';\n\nconst user = table({\n name: 'user',\n}, {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n active: t.bool(),\n});\n\nconst user_stats = table({\n name: 'user_stats',\n}, {\n key: t.string().primaryKey(),\n count: t.u64(),\n});\n\nconst spacetimedb = schema({ user, user_stats });\nexport default spacetimedb;\n\nexport const compute_user_counts = spacetimedb.reducer(\n (ctx) => {\n let total = 0n;\n let active = 0n;\n for (const u of ctx.db.user.iter()) {\n total += 1n;\n if (u.active) {\n active += 1n;\n }\n }\n\n ctx.db.user_stats.insert({ key: 'total', count: total });\n ctx.db.user_stats.insert({ key: 'active', count: active });\n }\n);\n",{"_33":202,"_35":164,"_36":203,"_38":204,"_40":205},"t_037_multi_column_filter","Multi Column Filter","Write a SpacetimeDB backend module in TypeScript that defines an event log table with a multi-column BTree index and a result table, with a reducer that filters events by both category and severity level.\n\nTABLES\n- event_log (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - category: string\n - severity: number (u32)\n - message: string\n - Index: multi-column btree index on (category, severity)\n\n- filtered_event (private)\n - Fields:\n - eventId: number (u64, primary key)\n - message: string\n\nREDUCERS\n- filter_events(ctx, { category: string, severity: number (u32) })\n - Iterate all event_log rows\n - For each row where category matches AND severity matches, insert into filtered_event","import { schema, table, t } from 'spacetimedb/server';\n\nconst event_log = table({\n name: 'event_log',\n indexes: [{ accessor: 'byCategorySeverity', algorithm: 'btree', columns: ['category', 'severity'] }],\n}, {\n id: t.u64().primaryKey().autoInc(),\n category: t.string(),\n severity: t.u32(),\n message: t.string(),\n});\n\nconst filtered_event = table({\n name: 'filtered_event',\n}, {\n eventId: t.u64().primaryKey(),\n message: t.string(),\n});\n\nconst spacetimedb = schema({ event_log, filtered_event });\nexport default spacetimedb;\n\nexport const filter_events = spacetimedb.reducer(\n { category: t.string(), severity: t.u32() },\n (ctx, { category, severity }) => {\n for (const e of ctx.db.event_log.iter()) {\n if (e.category === category && e.severity === severity) {\n ctx.db.filtered_event.insert({\n eventId: e.id,\n message: e.message,\n });\n }\n }\n }\n);\n","data_modeling",[208,213,218,223,228,233],{"_33":209,"_35":206,"_36":210,"_38":211,"_40":212},"t_024_event_table","Event Table","Write a SpacetimeDB backend module in TypeScript that defines an event table for damage notifications and a reducer that publishes events to it.\n\nTABLES\n- damage_event\n - public event table (rows exist only for the duration of the transaction, set event: true)\n - Fields:\n - entityId: number (u64)\n - damage: number (u32)\n - source: string\n\nREDUCERS\n- deal_damage(ctx, { entityId: number (u64), damage: number (u32), source: string })\n - Insert a row into the damage_event event table","import { schema, table, t } from 'spacetimedb/server';\n\nconst damage_event = table({\n name: 'damage_event',\n public: true,\n event: true,\n}, {\n entityId: t.u64(),\n damage: t.u32(),\n source: t.string(),\n});\n\nconst spacetimedb = schema({ damage_event });\nexport default spacetimedb;\n\nexport const deal_damage = spacetimedb.reducer(\n { entityId: t.u64(), damage: t.u32(), source: t.string() },\n (ctx, { entityId, damage, source }) => {\n ctx.db.damage_event.insert({ entityId, damage, source });\n }\n);\n",{"_33":214,"_35":206,"_36":215,"_38":216,"_40":217},"t_025_optional_fields","Optional Fields","Write a SpacetimeDB backend module in TypeScript that defines a table with optional (nullable) fields and a reducer that inserts rows with and without optional values.\n\nTABLES\n- player (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - nickname: optional string (use t.option(t.string()))\n - highScore: optional number (use t.option(t.u32()))\n\nREDUCERS\n- create_player(ctx, { name: string, nickname: optional string, highScore: optional number (u32) })\n - Insert a player row, passing through the optional fields as-is\n - Use id: 0n for autoInc","import { schema, table, t } from 'spacetimedb/server';\n\nconst player = table({\n name: 'player',\n}, {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n nickname: t.option(t.string()),\n highScore: t.option(t.u32()),\n});\n\nconst spacetimedb = schema({ player });\nexport default spacetimedb;\n\nexport const create_player = spacetimedb.reducer(\n { name: t.string(), nickname: t.option(t.string()), highScore: t.option(t.u32()) },\n (ctx, { name, nickname, highScore }) => {\n ctx.db.player.insert({\n id: 0n,\n name,\n nickname,\n highScore,\n });\n }\n);\n",{"_33":219,"_35":206,"_36":220,"_38":221,"_40":222},"t_028_cascade_delete","Cascade Delete","Write a SpacetimeDB backend module in TypeScript that defines an author table and a post table with a foreign key, and a reducer that deletes an author along with all their posts.\n\nTABLES\n- author (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n\n- post (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - authorId: number (u64, index btree)\n - title: string\n\nREDUCERS\n- delete_author(ctx, { authorId: number (u64) })\n - First, iterate all posts with matching authorId and delete each one\n - Then delete the author by id","import { schema, table, t } from 'spacetimedb/server';\n\nconst author = table({\n name: 'author',\n}, {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n});\n\nconst post = table({\n name: 'post',\n}, {\n id: t.u64().primaryKey().autoInc(),\n authorId: t.u64().index('btree'),\n title: t.string(),\n});\n\nconst spacetimedb = schema({ author, post });\nexport default spacetimedb;\n\nexport const delete_author = spacetimedb.reducer(\n { authorId: t.u64() },\n (ctx, { authorId }) => {\n // Delete all posts by this author\n for (const p of ctx.db.post.authorId.filter(authorId)) {\n ctx.db.post.id.delete(p.id);\n }\n // Delete the author\n ctx.db.author.id.delete(authorId);\n }\n);\n",{"_33":224,"_35":206,"_36":225,"_38":226,"_40":227},"t_029_filter_and_aggregate","Filter And Aggregate","Write a SpacetimeDB backend module in TypeScript that defines an order table and a stats table, with a reducer that computes aggregate statistics from filtered orders.\n\nTABLES\n- order (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - category: string (index btree)\n - amount: number (u64)\n - fulfilled: boolean\n\n- category_stats (private)\n - Fields:\n - category: string (primary key)\n - totalAmount: number (u64)\n - orderCount: number (u32)\n\nREDUCERS\n- compute_stats(ctx, { category: string })\n - Filter all orders matching the given category\n - Count the number of matching orders and sum their amounts\n - Insert (or update if exists) a category_stats row with the results","import { schema, table, t } from 'spacetimedb/server';\n\nconst order = table({\n name: 'order',\n}, {\n id: t.u64().primaryKey().autoInc(),\n category: t.string().index('btree'),\n amount: t.u64(),\n fulfilled: t.bool(),\n});\n\nconst category_stats = table({\n name: 'category_stats',\n}, {\n category: t.string().primaryKey(),\n totalAmount: t.u64(),\n orderCount: t.u32(),\n});\n\nconst spacetimedb = schema({ order, category_stats });\nexport default spacetimedb;\n\nexport const compute_stats = spacetimedb.reducer(\n { category: t.string() },\n (ctx, { category }) => {\n let totalAmount = 0n;\n let orderCount = 0;\n\n for (const o of ctx.db.order.category.filter(category)) {\n totalAmount += o.amount;\n orderCount += 1;\n }\n\n // Upsert: delete existing then insert\n ctx.db.category_stats.category.delete(category);\n ctx.db.category_stats.insert({\n category,\n totalAmount,\n orderCount,\n });\n }\n);\n",{"_33":229,"_35":206,"_36":230,"_38":231,"_40":232},"t_030_two_table_join","Wo Table Join","Write a SpacetimeDB backend module in TypeScript that defines a customer table, an order table with a foreign key to customer, and a denormalized result table. Include a reducer that joins the two tables and writes results.\n\nTABLES\n- customer (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n\n- order (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - customerId: number (u64, index btree)\n - product: string\n - amount: number (u32)\n\n- order_detail (private)\n - Fields:\n - orderId: number (u64, primary key)\n - customerName: string\n - product: string\n - amount: number (u32)\n\nREDUCERS\n- build_order_details(ctx)\n - Iterate all orders\n - For each order, look up the customer by customerId\n - If the customer is found, insert an order_detail row with the joined data","import { schema, table, t } from 'spacetimedb/server';\n\nconst customer = table({\n name: 'customer',\n}, {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n});\n\nconst order = table({\n name: 'order',\n}, {\n id: t.u64().primaryKey().autoInc(),\n customerId: t.u64().index('btree'),\n product: t.string(),\n amount: t.u32(),\n});\n\nconst order_detail = table({\n name: 'order_detail',\n}, {\n orderId: t.u64().primaryKey(),\n customerName: t.string(),\n product: t.string(),\n amount: t.u32(),\n});\n\nconst spacetimedb = schema({ customer, order, order_detail });\nexport default spacetimedb;\n\nexport const build_order_details = spacetimedb.reducer(\n (ctx) => {\n for (const o of ctx.db.order.iter()) {\n const c = ctx.db.customer.id.find(o.customerId);\n if (c) {\n ctx.db.order_detail.insert({\n orderId: o.id,\n customerName: c.name,\n product: o.product,\n amount: o.amount,\n });\n }\n }\n }\n);\n",{"_33":234,"_35":206,"_36":235,"_38":236,"_40":237},"t_031_unique_constraint","Unique Constraint","Write a SpacetimeDB backend module in TypeScript that defines a table with a unique constraint on a non-primary-key column and a reducer that inserts rows.\n\nTABLES\n- account (private)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - email: string (unique)\n - displayName: string\n\nREDUCERS\n- create_account(ctx, { email: string, displayName: string })\n - Insert an account row with the given email and displayName\n - Use id: 0n for autoInc","import { schema, table, t } from 'spacetimedb/server';\n\nconst account = table({\n name: 'account',\n}, {\n id: t.u64().primaryKey().autoInc(),\n email: t.string().unique(),\n displayName: t.string(),\n});\n\nconst spacetimedb = schema({ account });\nexport default spacetimedb;\n\nexport const create_account = spacetimedb.reducer(\n { email: t.string(), displayName: t.string() },\n (ctx, { email, displayName }) => {\n ctx.db.account.insert({\n id: 0n,\n email,\n displayName,\n });\n }\n);\n","auth",[240,245,250,255,260,265,270,275,280],{"_33":241,"_35":238,"_36":242,"_38":243,"_40":244},"t_026_auth_identity_check","Auth Identity Check","Write a SpacetimeDB backend module in TypeScript that defines a table of messages owned by users, and reducers that enforce ownership using ctx.sender.\n\nTABLES\n- message\n - public table\n - Fields:\n - id: number (u64, primary key, autoInc)\n - owner: Identity (index btree)\n - text: string\n\nREDUCERS\n- create_message(ctx, { text: string })\n - Insert a new message with owner set to ctx.sender()\n - Use id: 0n for autoInc\n\n- delete_message(ctx, { id: number (u64) })\n - Find the message by id\n - If not found, throw \"not found\"\n - If the message's owner does not equal ctx.sender(), throw \"unauthorized\"\n - Otherwise, delete the message","import { schema, table, t } from 'spacetimedb/server';\n\nconst message = table({\n name: 'message',\n public: true,\n}, {\n id: t.u64().primaryKey().autoInc(),\n owner: t.identity().index('btree'),\n text: t.string(),\n});\n\nconst spacetimedb = schema({ message });\nexport default spacetimedb;\n\nexport const create_message = spacetimedb.reducer(\n { text: t.string() },\n (ctx, { text }) => {\n ctx.db.message.insert({\n id: 0n,\n owner: ctx.sender,\n text,\n });\n }\n);\n\nexport const delete_message = spacetimedb.reducer(\n { id: t.u64() },\n (ctx, { id }) => {\n const msg = ctx.db.message.id.find(id);\n if (!msg) {\n throw new Error(\"not found\");\n }\n if (!msg.owner.equals(ctx.sender)) {\n throw new Error(\"unauthorized\");\n }\n ctx.db.message.id.delete(id);\n }\n);\n",{"_33":246,"_35":238,"_36":247,"_38":248,"_40":249},"t_027_private_vs_public_table","Private Vs Public Table","Write a SpacetimeDB backend module in TypeScript that defines a private table for sensitive data and a public table for client-visible data, with a reducer that copies safe fields from private to public.\n\nTABLES\n- user_internal\n - private table (do not set public: true)\n - Fields:\n - id: number (u64, primary key, autoInc)\n - name: string\n - email: string\n - passwordHash: string\n\n- user_public\n - public table (set public: true)\n - Fields:\n - id: number (u64, primary key)\n - name: string\n\nREDUCERS\n- register_user(ctx, { name: string, email: string, passwordHash: string })\n - Insert into user_internal (id: 0n for autoInc)\n - Also insert into user_public with just the id and name (safe fields only)","import { schema, table, t } from 'spacetimedb/server';\n\nconst user_internal = table({\n name: 'user_internal',\n}, {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n email: t.string(),\n passwordHash: t.string(),\n});\n\nconst user_public = table({\n name: 'user_public',\n public: true,\n}, {\n id: t.u64().primaryKey(),\n name: t.string(),\n});\n\nconst spacetimedb = schema({ user_internal, user_public });\nexport default spacetimedb;\n\nexport const register_user = spacetimedb.reducer(\n { name: t.string(), email: t.string(), passwordHash: t.string() },\n (ctx, { name, email, passwordHash }) => {\n const internal = ctx.db.user_internal.insert({\n id: 0n,\n name,\n email,\n passwordHash,\n });\n ctx.db.user_public.insert({\n id: internal.id,\n name,\n });\n }\n);\n",{"_33":251,"_35":238,"_36":252,"_38":253,"_40":254},"t_041_registered_user_gate","Registered User Gate","Write a SpacetimeDB backend module in TypeScript that gates actions behind a registration check.\n\nTABLES\n- user\n - private table\n - Fields:\n - identity: Identity (primary key)\n - name: string\n\n- message\n - public table\n - Fields:\n - id: number (u64, primary key, autoInc)\n - sender: Identity (index btree)\n - text: string\n\nREDUCERS\n- register(ctx, { name: string })\n - If a user row already exists for ctx.sender, throw \"already registered\"\n - Otherwise insert a new user with identity = ctx.sender and the given name\n\n- post_message(ctx, { text: string })\n - If no user row exists for ctx.sender, throw \"not registered\"\n - Otherwise insert a message with sender = ctx.sender and the given text, id = 0n for autoInc","import { schema, table, t } from 'spacetimedb/server';\n\nconst user = table({\n name: 'user',\n}, {\n identity: t.identity().primaryKey(),\n name: t.string(),\n});\n\nconst message = table({\n name: 'message',\n public: true,\n}, {\n id: t.u64().primaryKey().autoInc(),\n sender: t.identity().index('btree'),\n text: t.string(),\n});\n\nconst spacetimedb = schema({ user, message });\nexport default spacetimedb;\n\nexport const register = spacetimedb.reducer(\n { name: t.string() },\n (ctx, { name }) => {\n if (ctx.db.user.identity.find(ctx.sender)) {\n throw new Error('already registered');\n }\n ctx.db.user.insert({ identity: ctx.sender, name });\n }\n);\n\nexport const post_message = spacetimedb.reducer(\n { text: t.string() },\n (ctx, { text }) => {\n if (!ctx.db.user.identity.find(ctx.sender)) {\n throw new Error('not registered');\n }\n ctx.db.message.insert({ id: 0n, sender: ctx.sender, text });\n }\n);\n",{"_33":256,"_35":238,"_36":257,"_38":258,"_40":259},"t_042_admin_bootstrap","Admin Bootstrap","Write a SpacetimeDB backend module in TypeScript that implements a one-time admin bootstrap pattern.\n\nTABLES\n- config\n - private table\n - Fields:\n - id: number (u32, primary key)\n - admin: Identity\n\n- admin_log\n - public table\n - Fields:\n - id: number (u64, primary key, autoInc)\n - action: string\n\nREDUCERS\n- bootstrap_admin(ctx)\n - If a config row already exists (id = 0), throw \"already bootstrapped\"\n - Otherwise insert config { id: 0, admin: ctx.sender }\n\n- admin_action(ctx, { action: string })\n - Load the config row with id = 0; if missing, throw \"not bootstrapped\"\n - If ctx.sender does not equal config.admin, throw \"not admin\"\n - Insert an admin_log row with the given action, id = 0n for autoInc","import { schema, table, t } from 'spacetimedb/server';\n\nconst config = table({\n name: 'config',\n}, {\n id: t.u32().primaryKey(),\n admin: t.identity(),\n});\n\nconst admin_log = table({\n name: 'admin_log',\n public: true,\n}, {\n id: t.u64().primaryKey().autoInc(),\n action: t.string(),\n});\n\nconst spacetimedb = schema({ config, admin_log });\nexport default spacetimedb;\n\nexport const bootstrap_admin = spacetimedb.reducer(\n {},\n (ctx) => {\n if (ctx.db.config.id.find(0)) {\n throw new Error('already bootstrapped');\n }\n ctx.db.config.insert({ id: 0, admin: ctx.sender });\n }\n);\n\nexport const admin_action = spacetimedb.reducer(\n { action: t.string() },\n (ctx, { action }) => {\n const config = ctx.db.config.id.find(0);\n if (!config) throw new Error('not bootstrapped');\n if (!config.admin.equals(ctx.sender)) throw new Error('not admin');\n ctx.db.admin_log.insert({ id: 0n, action });\n }\n);\n",{"_33":261,"_35":238,"_36":262,"_38":263,"_40":264},"t_043_role_based_access","Role Based Access","Write a SpacetimeDB backend module in TypeScript that implements role-based access control.\n\nTABLES\n- user\n - private table\n - Fields:\n - identity: Identity (primary key)\n - role: string (\"admin\" or \"member\")\n\nREDUCERS\n- register(ctx)\n - If a user row already exists for ctx.sender, throw \"already registered\"\n - Insert user { identity: ctx.sender, role: \"member\" }\n\n- promote(ctx, { target: Identity })\n - Load the user row for ctx.sender; if missing, throw \"not registered\"\n - If the caller's role is not \"admin\", throw \"not admin\"\n - Load the user row for target; if missing, throw \"target not registered\"\n - Update that row's role to \"admin\"\n\n- member_action(ctx)\n - Load the user row for ctx.sender; if missing, throw \"not registered\"\n\n- admin_action(ctx)\n - Load the user row for ctx.sender; if missing, throw \"not registered\"\n - If the role is not \"admin\", throw \"not admin\"","import { schema, table, t } from 'spacetimedb/server';\n\nconst user = table({\n name: 'user',\n}, {\n identity: t.identity().primaryKey(),\n role: t.string(),\n});\n\nconst spacetimedb = schema({ user });\nexport default spacetimedb;\n\nexport const register = spacetimedb.reducer(\n {},\n (ctx) => {\n if (ctx.db.user.identity.find(ctx.sender)) {\n throw new Error('already registered');\n }\n ctx.db.user.insert({ identity: ctx.sender, role: 'member' });\n }\n);\n\nexport const promote = spacetimedb.reducer(\n { target: t.identity() },\n (ctx, { target }) => {\n const caller = ctx.db.user.identity.find(ctx.sender);\n if (!caller) throw new Error('not registered');\n if (caller.role !== 'admin') throw new Error('not admin');\n const targetUser = ctx.db.user.identity.find(target);\n if (!targetUser) throw new Error('target not registered');\n ctx.db.user.identity.update({ ...targetUser, role: 'admin' });\n }\n);\n\nexport const member_action = spacetimedb.reducer(\n {},\n (ctx) => {\n if (!ctx.db.user.identity.find(ctx.sender)) throw new Error('not registered');\n }\n);\n\nexport const admin_action = spacetimedb.reducer(\n {},\n (ctx) => {\n const user = ctx.db.user.identity.find(ctx.sender);\n if (!user) throw new Error('not registered');\n if (user.role !== 'admin') throw new Error('not admin');\n }\n);\n",{"_33":266,"_35":238,"_36":267,"_38":268,"_40":269},"t_044_ban_list","Ban List","Write a SpacetimeDB backend module in TypeScript that implements a ban list enforced on game entry.\n\nTABLES\n- admin\n - private table\n - Fields:\n - identity: Identity (primary key)\n\n- banned\n - private table\n - Fields:\n - identity: Identity (primary key)\n\n- player\n - public table\n - Fields:\n - identity: Identity (primary key)\n - name: string\n\nREDUCERS\n- add_admin(ctx, { target: Identity })\n - If ctx.sender is not in the admin table, throw \"not admin\"\n - Insert { identity: target } into admin (ignore if already present)\n\n- ban_player(ctx, { target: Identity })\n - If ctx.sender is not in the admin table, throw \"not admin\"\n - Insert { identity: target } into banned\n - Remove the player row for target if one exists\n\n- join_game(ctx, { name: string })\n - If ctx.sender is in the banned table, throw \"banned\"\n - If a player row already exists for ctx.sender, throw \"already in game\"\n - Insert player { identity: ctx.sender, name }","import { schema, table, t } from 'spacetimedb/server';\n\nconst admin = table({\n name: 'admin',\n}, {\n identity: t.identity().primaryKey(),\n});\n\nconst banned = table({\n name: 'banned',\n}, {\n identity: t.identity().primaryKey(),\n});\n\nconst player = table({\n name: 'player',\n public: true,\n}, {\n identity: t.identity().primaryKey(),\n name: t.string(),\n});\n\nconst spacetimedb = schema({ admin, banned, player });\nexport default spacetimedb;\n\nexport const add_admin = spacetimedb.reducer(\n { target: t.identity() },\n (ctx, { target }) => {\n if (!ctx.db.admin.identity.find(ctx.sender)) throw new Error('not admin');\n try { ctx.db.admin.insert({ identity: target }); } catch {}\n }\n);\n\nexport const ban_player = spacetimedb.reducer(\n { target: t.identity() },\n (ctx, { target }) => {\n if (!ctx.db.admin.identity.find(ctx.sender)) throw new Error('not admin');\n ctx.db.banned.insert({ identity: target });\n if (ctx.db.player.identity.find(target)) {\n ctx.db.player.identity.delete(target);\n }\n }\n);\n\nexport const join_game = spacetimedb.reducer(\n { name: t.string() },\n (ctx, { name }) => {\n if (ctx.db.banned.identity.find(ctx.sender)) throw new Error('banned');\n if (ctx.db.player.identity.find(ctx.sender)) throw new Error('already in game');\n ctx.db.player.insert({ identity: ctx.sender, name });\n }\n);\n",{"_33":271,"_35":238,"_36":272,"_38":273,"_40":274},"t_045_rate_limit","Rate Limit","Write a SpacetimeDB backend module in TypeScript that enforces per-identity rate limiting.\n\nTABLES\n- rate_limit\n - private table\n - Fields:\n - identity: Identity (primary key)\n - last_call_us: number (u64, microsecond timestamp of the last allowed call)\n\n- action_log\n - public table\n - Fields:\n - id: number (u64, primary key, autoInc)\n - identity: Identity\n - payload: string\n\nREDUCERS\n- limited_action(ctx, { payload: string })\n - Get the current time in microseconds: ctx.timestamp.microsSinceUnixEpoch (a BigInt)\n - Look up the rate_limit row for ctx.sender\n - If a row exists and (now - last_call_us) < 1_000_000n, throw \"rate limited\"\n - Insert or update the rate_limit row with last_call_us = now\n - Insert an action_log row with identity = ctx.sender and the given payload, id = 0n for autoInc","import { schema, table, t } from 'spacetimedb/server';\n\nconst rate_limit = table({\n name: 'rate_limit',\n}, {\n identity: t.identity().primaryKey(),\n last_call_us: t.u64(),\n});\n\nconst action_log = table({\n name: 'action_log',\n public: true,\n}, {\n id: t.u64().primaryKey().autoInc(),\n identity: t.identity(),\n payload: t.string(),\n});\n\nconst spacetimedb = schema({ rate_limit, action_log });\nexport default spacetimedb;\n\nexport const limited_action = spacetimedb.reducer(\n { payload: t.string() },\n (ctx, { payload }) => {\n const now = BigInt(ctx.timestamp.microsSinceUnixEpoch);\n const entry = ctx.db.rate_limit.identity.find(ctx.sender);\n if (entry) {\n if (now - entry.last_call_us < 1_000_000n) throw new Error('rate limited');\n ctx.db.rate_limit.identity.update({ ...entry, last_call_us: now });\n } else {\n ctx.db.rate_limit.insert({ identity: ctx.sender, last_call_us: now });\n }\n ctx.db.action_log.insert({ id: 0n, identity: ctx.sender, payload });\n }\n);\n",{"_33":276,"_35":238,"_36":277,"_38":278,"_40":279},"t_046_shared_document","Shared Document","Write a SpacetimeDB backend module in TypeScript that implements document ownership and explicit sharing.\n\nTABLES\n- document\n - public table\n - Fields:\n - id: number (u64, primary key, autoInc)\n - owner: Identity (index btree)\n - title: string\n\n- document_share\n - public table\n - Fields:\n - document_id: number (u64, index btree)\n - shared_with: Identity (index btree)\n\nREDUCERS\n- create_document(ctx, { title: string })\n - Insert a document with owner = ctx.sender and the given title, id = 0n for autoInc\n\n- share_document(ctx, { document_id: number (u64), target: Identity })\n - Load the document by id; if missing, throw \"not found\"\n - If document.owner != ctx.sender, throw \"not owner\"\n - Insert a document_share { document_id, shared_with: target }\n\n- edit_document(ctx, { document_id: number (u64), new_title: string })\n - Load the document by id; if missing, throw \"not found\"\n - The caller is authorized if they are the owner OR if a document_share row exists\n with matching document_id and shared_with == ctx.sender\n - If neither condition is true, throw \"unauthorized\"\n - Update the document's title to new_title","import { schema, table, t } from 'spacetimedb/server';\n\nconst document = table({\n name: 'document',\n public: true,\n}, {\n id: t.u64().primaryKey().autoInc(),\n owner: t.identity().index('btree'),\n title: t.string(),\n});\n\nconst document_share = table({\n name: 'document_share',\n public: true,\n}, {\n document_id: t.u64().index('btree'),\n shared_with: t.identity().index('btree'),\n});\n\nconst spacetimedb = schema({ document, document_share });\nexport default spacetimedb;\n\nexport const create_document = spacetimedb.reducer(\n { title: t.string() },\n (ctx, { title }) => {\n ctx.db.document.insert({ id: 0n, owner: ctx.sender, title });\n }\n);\n\nexport const share_document = spacetimedb.reducer(\n { document_id: t.u64(), target: t.identity() },\n (ctx, { document_id, target }) => {\n const doc = ctx.db.document.id.find(document_id);\n if (!doc) throw new Error('not found');\n if (!doc.owner.equals(ctx.sender)) throw new Error('not owner');\n ctx.db.document_share.insert({ document_id, shared_with: target });\n }\n);\n\nexport const edit_document = spacetimedb.reducer(\n { document_id: t.u64(), new_title: t.string() },\n (ctx, { document_id, new_title }) => {\n const doc = ctx.db.document.id.find(document_id);\n if (!doc) throw new Error('not found');\n const isOwner = doc.owner.equals(ctx.sender);\n const isShared = [...ctx.db.document_share.document_id.filter(document_id)]\n .some(s => s.shared_with.equals(ctx.sender));\n if (!isOwner && !isShared) throw new Error('unauthorized');\n ctx.db.document.id.update({ ...doc, title: new_title });\n }\n);\n",{"_33":281,"_35":238,"_36":282,"_38":283,"_40":284},"t_068_secure_projection","Secure Projection","Write a SpacetimeDB backend module in TypeScript that exposes a safe per-user projection of private rows.\n\nTYPES\n- SafeNote\n - id: u64\n - title: string\n\nTABLE\n- secret_note (private)\n - Fields:\n - id: u64 (primary key)\n - owner: Identity (btree index)\n - title: string\n - secretBody: string\n\nREDUCERS\n- seed_private_note()\n - Insert id 1 for the caller\n - Set title to \"Visible title\"\n - Set secretBody to \"never expose this\"\n\nVIEW\n- my_safe_note (per-user, public)\n - Return an array of SafeNote for only the caller\n - Never expose owner or secretBody","import { schema, table, t } from 'spacetimedb/server';\n\nconst secretNote = table({ name: 'secret_note' }, {\n id: t.u64().primaryKey(),\n owner: t.identity().index('btree'),\n title: t.string(),\n secretBody: t.string(),\n});\nconst SafeNote = t.row('SafeNoteRow', { id: t.u64(), title: t.string() });\nconst spacetimedb = schema({ secretNote });\nexport default spacetimedb;\n\nexport const seed_private_note = spacetimedb.reducer(ctx => {\n ctx.db.secretNote.insert({ id: 1n, owner: ctx.sender, title: 'Visible title', secretBody: 'never expose this' });\n});\n\nexport const my_safe_note = spacetimedb.view(\n { name: 'my_safe_note', public: true }, t.array(SafeNote),\n ctx => Array.from(ctx.db.secretNote.owner.filter(ctx.sender)).map(note => ({ id: note.id, title: note.title }))\n);\n","tables",[287,292,297,302,307,312,317,322],{"_33":288,"_35":285,"_36":289,"_38":290,"_40":291},"t_047_normalized_collection","Normalized Collection","Write a SpacetimeDB backend module in TypeScript that models an unbounded child collection with normalized tables.\n\nTABLES\n- collection_owner (public)\n - id: u64 (primary key, auto increment)\n - name: string\n- child_item (public)\n - id: u64 (primary key, auto increment)\n - ownerId: u64\n - value: string\n - index byOwner: btree(ownerId)\n\nDo not store child items in an array on collection_owner. No reducers are required.","import { schema, table, t } from 'spacetimedb/server';\n\nconst collectionOwner = table(\n { name: 'collection_owner', public: true },\n {\n id: t.u64().primaryKey().autoInc(),\n name: t.string(),\n }\n);\n\nconst childItem = table(\n {\n name: 'child_item',\n public: true,\n indexes: [{ accessor: 'byOwner', algorithm: 'btree', columns: ['ownerId'] }],\n },\n {\n id: t.u64().primaryKey().autoInc(),\n ownerId: t.u64(),\n value: t.string(),\n }\n);\n\nexport default schema({ collectionOwner, childItem });\n",{"_33":293,"_35":285,"_36":294,"_38":295,"_40":296},"t_048_heartbeat_isolation","Heartbeat Isolation","Write a SpacetimeDB backend module in TypeScript that separates stable profile data from frequently updated connection presence.\n\nTABLES\n- user_profile (public)\n - identity: Identity (primary key)\n - displayName: string\n - createdAt: Timestamp\n- connection_presence (public)\n - connectionId: ConnectionId (primary key)\n - userIdentity: Identity\n - lastHeartbeat: Timestamp\n - online: boolean\n - index byUser: btree(userIdentity)\n\nDo not put lastHeartbeat or online on user_profile. No reducers are required.","import { schema, table, t } from 'spacetimedb/server';\n\nconst userProfile = table(\n { name: 'user_profile', public: true },\n {\n identity: t.identity().primaryKey(),\n displayName: t.string(),\n createdAt: t.timestamp(),\n }\n);\n\nconst connectionPresence = table(\n {\n name: 'connection_presence',\n public: true,\n indexes: [{ accessor: 'byUser', algorithm: 'btree', columns: ['userIdentity'] }],\n },\n {\n connectionId: t.connectionId().primaryKey(),\n userIdentity: t.identity(),\n lastHeartbeat: t.timestamp(),\n online: t.bool(),\n }\n);\n\nexport default schema({ userProfile, connectionPresence });\n",{"_33":298,"_35":285,"_36":299,"_38":300,"_40":301},"t_049_binary_storage","Binary Storage","Write a SpacetimeDB backend module in TypeScript that stores binary content and its metadata.\n\nTABLE\n- blob_record (public)\n - Fields:\n - id: u64 (primary key, auto-increment)\n - owner: Identity (btree index byOwner)\n - filename: string\n - mimeType: string\n - size: u64\n - data: u8 array\n\nREDUCERS\n- store_blob(filename: string, mimeType: string, data: u8 array)\n - Store ctx.sender as owner\n - Derive size from the byte length\n - Insert the bytes unchanged","import { schema, table, t } from 'spacetimedb/server';\n\nconst blobRecord = table(\n {\n name: 'blob_record',\n public: true,\n indexes: [{ accessor: 'byOwner', algorithm: 'btree', columns: ['owner'] }],\n },\n {\n id: t.u64().primaryKey().autoInc(),\n owner: t.identity(),\n filename: t.string(),\n mimeType: t.string(),\n size: t.u64(),\n data: t.array(t.u8()),\n }\n);\n\nconst spacetimedb = schema({ blobRecord });\nexport default spacetimedb;\n\nexport const store_blob = spacetimedb.reducer(\n { filename: t.string(), mimeType: t.string(), data: t.array(t.u8()) },\n (ctx, { filename, mimeType, data }) => {\n ctx.db.blobRecord.insert({\n id: 0n,\n owner: ctx.sender,\n filename,\n mimeType,\n size: BigInt(data.length),\n data,\n });\n }\n);\n",{"_33":303,"_35":285,"_36":304,"_38":305,"_40":306},"t_050_normalized_schema","Normalized Schema","Write a SpacetimeDB backend module in TypeScript that normalizes organization data into three related tables.\n\nTABLES\n- organization (public)\n - id: u64 (primary key, auto increment)\n - name: string\n- department (public)\n - id: u64 (primary key, auto increment)\n - organizationId: u64\n - name: string\n - index byOrganization: btree(organizationId)\n- employee (public)\n - id: u64 (primary key, auto increment)\n - departmentId: u64\n - name: string\n - index byDepartment: btree(departmentId)\n\nDo not use nested arrays. No reducers are required.","import { schema, table, t } from 'spacetimedb/server';\n\nconst organization = table(\n { name: 'organization', public: true },\n { id: t.u64().primaryKey().autoInc(), name: t.string() }\n);\n\nconst department = table(\n {\n name: 'department',\n public: true,\n indexes: [{ accessor: 'byOrganization', algorithm: 'btree', columns: ['organizationId'] }],\n },\n {\n id: t.u64().primaryKey().autoInc(),\n organizationId: t.u64(),\n name: t.string(),\n }\n);\n\nconst employee = table(\n {\n name: 'employee',\n public: true,\n indexes: [{ accessor: 'byDepartment', algorithm: 'btree', columns: ['departmentId'] }],\n },\n {\n id: t.u64().primaryKey().autoInc(),\n departmentId: t.u64(),\n name: t.string(),\n }\n);\n\nexport default schema({ organization, department, employee });\n",{"_33":308,"_35":285,"_36":309,"_38":310,"_40":311},"t_051_denormalized_index","Denormalized Index","Write a SpacetimeDB backend module in TypeScript that maintains an indexed denormalized category slug on products.\n\nTABLES\n- category (public)\n - Fields:\n - id: u64 (primary key)\n - slug: string\n- product (public)\n - Fields:\n - id: u64 (primary key)\n - categoryId: u64 (btree index byCategory)\n - categorySlug: string (btree index byCategorySlug)\n - name: string\n\nREDUCERS\n- create_category(id: u64, slug: string)\n- create_product(id: u64, categoryId: u64, name: string)\n - Copy the current category slug into categorySlug\n- rename_category(id: u64, newSlug: string)\n - Update the category slug\n - Update every related product so categorySlug stays synchronized","import { schema, table, t } from 'spacetimedb/server';\n\nconst category = table(\n { name: 'category', public: true },\n { id: t.u64().primaryKey(), slug: t.string() }\n);\n\nconst product = table(\n {\n name: 'product',\n public: true,\n indexes: [\n { accessor: 'byCategory', algorithm: 'btree', columns: ['categoryId'] },\n { accessor: 'byCategorySlug', algorithm: 'btree', columns: ['categorySlug'] },\n ],\n },\n {\n id: t.u64().primaryKey(),\n categoryId: t.u64(),\n categorySlug: t.string(),\n name: t.string(),\n }\n);\n\nconst spacetimedb = schema({ category, product });\nexport default spacetimedb;\n\nexport const create_category = spacetimedb.reducer(\n { id: t.u64(), slug: t.string() },\n (ctx, { id, slug }) => ctx.db.category.insert({ id, slug })\n);\n\nexport const create_product = spacetimedb.reducer(\n { id: t.u64(), categoryId: t.u64(), name: t.string() },\n (ctx, { id, categoryId, name }) => {\n const found = ctx.db.category.id.find(categoryId);\n if (!found) throw new Error('category not found');\n ctx.db.product.insert({ id, categoryId, categorySlug: found.slug, name });\n }\n);\n\nexport const rename_category = spacetimedb.reducer(\n { id: t.u64(), newSlug: t.string() },\n (ctx, { id, newSlug }) => {\n const found = ctx.db.category.id.find(id);\n if (!found) throw new Error('category not found');\n ctx.db.category.id.update({ ...found, slug: newSlug });\n for (const existing of ctx.db.product.byCategory.filter(id)) {\n ctx.db.product.id.update({ ...existing, categorySlug: newSlug });\n }\n }\n);\n",{"_33":313,"_35":285,"_36":314,"_38":315,"_40":316},"t_052_autoinc_reference","Autoinc Reference","Write a SpacetimeDB backend module in TypeScript that safely creates related rows with an auto-incremented parent ID.\n\nTABLES\n- parent (public)\n - Fields:\n - id: u64 (primary key, auto-increment)\n - name: string\n- child (public)\n - Fields:\n - id: u64 (primary key, auto-increment)\n - parentId: u64 (btree index byParent)\n - name: string\n\nREDUCERS\n- create_family(parentName: string, childNames: string array)\n - Insert the parent, then insert every child using the ID actually assigned to that parent","import { schema, table, t } from 'spacetimedb/server';\n\nconst parent = table(\n { name: 'parent', public: true },\n { id: t.u64().primaryKey().autoInc(), name: t.string() }\n);\n\nconst child = table(\n {\n name: 'child',\n public: true,\n indexes: [{ accessor: 'byParent', algorithm: 'btree', columns: ['parentId'] }],\n },\n { id: t.u64().primaryKey().autoInc(), parentId: t.u64(), name: t.string() }\n);\n\nconst spacetimedb = schema({ parent, child });\nexport default spacetimedb;\n\nexport const create_family = spacetimedb.reducer(\n { parentName: t.string(), childNames: t.array(t.string()) },\n (ctx, { parentName, childNames }) => {\n const insertedParent = ctx.db.parent.insert({ id: 0n, name: parentName });\n for (const name of childNames) {\n ctx.db.child.insert({ id: 0n, parentId: insertedParent.id, name });\n }\n }\n);\n",{"_33":318,"_35":285,"_36":319,"_38":320,"_40":321},"t_053_default_values","Default Values","Update the existing SpacetimeDB backend module in TypeScript to add a migration-safe default value.\n\nTABLE\n- widget (public)\n - Preserve the existing table and fields\n - Keep id: u64 as the primary key\n - Add enabled: bool as the trailing field\n - Give enabled a default value of true\n\nREDUCERS\n- Preserve seed and touch without renaming them\n- Update new widget values to set enabled to true\n\nMIGRATION\n- A compatible republish must backfill existing rows","import { schema, table, t } from 'spacetimedb/server';\n\nconst widget = table(\n { name: 'widget', public: true },\n { id: t.u64().primaryKey(), name: t.string(), enabled: t.bool().default(true) }\n);\n\nconst spacetimedb = schema({ widget });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.widget.insert({ id: 1n, name: 'legacy', enabled: true });\n});\n\nexport const touch = spacetimedb.reducer(_ctx => {});\n",{"_33":323,"_35":285,"_36":324,"_38":325,"_40":326},"t_054_special_types","Special Types","Write a SpacetimeDB backend module in TypeScript defining one public table with special value types.\n\nTABLE\n- special_value (public)\n - Fields:\n - id: u64 (primary key)\n - uuid: Uuid\n - connectionId: ConnectionId\n - duration: TimeDuration\n - unsigned128: u128\n - signed128: i128\n - unsigned256: u256\n - signed256: i256\n\nNo reducers are required.","import { schema, table, t } from 'spacetimedb/server';\n\nconst specialValue = table(\n { name: 'special_value', public: true },\n {\n id: t.u64().primaryKey(),\n uuid: t.uuid(),\n connectionId: t.connectionId(),\n duration: t.timeDuration(),\n unsigned128: t.u128(),\n signed128: t.i128(),\n unsigned256: t.u256(),\n signed256: t.i256(),\n }\n);\n\nexport default schema({ specialValue });\n","reducers",[329,334,339,344,349,354],{"_33":330,"_35":327,"_36":331,"_38":332,"_40":333},"t_055_atomic_idempotent_transfer","Atomic Idempotent Transfer","Write a SpacetimeDB backend module in TypeScript that performs atomic, idempotent transfers between accounts.\n\nTABLES\n- account (public)\n - Fields:\n - id: u64 (primary key)\n - balance: i64\n- transfer_request (public)\n - Fields:\n - requestId: string (primary key)\n - fromId: u64\n - toId: u64\n - amount: i64\n\nREDUCERS\n- create_account(id: u64, balance: i64)\n - Insert an account with the supplied values\n- transfer(requestId: string, fromId: u64, toId: u64, amount: i64)\n - Reject invalid or insufficient transfers\n - Update both account balances atomically\n - Record requestId in transfer_request\n - If requestId is already recorded, make no changes","import { schema, table, t } from 'spacetimedb/server';\n\nconst account = table({ name: 'account', public: true }, { id: t.u64().primaryKey(), balance: t.i64() });\nconst transferRequest = table(\n { name: 'transfer_request', public: true },\n { requestId: t.string().primaryKey(), fromId: t.u64(), toId: t.u64(), amount: t.i64() }\n);\nconst spacetimedb = schema({ account, transferRequest });\nexport default spacetimedb;\n\nexport const create_account = spacetimedb.reducer(\n { id: t.u64(), balance: t.i64() },\n (ctx, { id, balance }) => ctx.db.account.insert({ id, balance })\n);\n\nexport const transfer = spacetimedb.reducer(\n { requestId: t.string(), fromId: t.u64(), toId: t.u64(), amount: t.i64() },\n (ctx, { requestId, fromId, toId, amount }) => {\n if (ctx.db.transferRequest.requestId.find(requestId)) return;\n if (amount <= 0n || fromId === toId) throw new Error('invalid transfer');\n const from = ctx.db.account.id.find(fromId);\n const to = ctx.db.account.id.find(toId);\n if (!from || !to) throw new Error('account not found');\n if (from.balance < amount) throw new Error('insufficient balance');\n ctx.db.account.id.update({ ...from, balance: from.balance - amount });\n ctx.db.account.id.update({ ...to, balance: to.balance + amount });\n ctx.db.transferRequest.insert({ requestId, fromId, toId, amount });\n }\n);\n",{"_33":335,"_35":327,"_36":336,"_38":337,"_40":338},"t_056_nested_update","Nested Update","Write a SpacetimeDB backend module in TypeScript that stores and updates nested profile preferences.\n\nTYPES\n- Preferences\n - theme: string\n - emailNotifications: boolean\n - timezone: string\n\nTABLE\n- profile (public)\n - Fields:\n - id: u64 (primary key)\n - preferences: Preferences\n\nREDUCERS\n- create_profile(id: u64, theme: string, emailNotifications: boolean, timezone: string)\n - Insert a profile with all three preference fields\n- update_theme(id: u64, theme: string)\n - Change only preferences.theme\n - Preserve preferences.emailNotifications and preferences.timezone","import { schema, table, t } from 'spacetimedb/server';\n\nconst Preferences = t.object('Preferences', {\n theme: t.string(),\n emailNotifications: t.bool(),\n timezone: t.string(),\n});\nconst profile = table(\n { name: 'profile', public: true },\n { id: t.u64().primaryKey(), preferences: Preferences }\n);\nconst spacetimedb = schema({ profile });\nexport default spacetimedb;\n\nexport const create_profile = spacetimedb.reducer(\n { id: t.u64(), theme: t.string(), emailNotifications: t.bool(), timezone: t.string() },\n (ctx, args) => ctx.db.profile.insert({ id: args.id, preferences: {\n theme: args.theme, emailNotifications: args.emailNotifications, timezone: args.timezone,\n } })\n);\n\nexport const update_theme = spacetimedb.reducer(\n { id: t.u64(), theme: t.string() },\n (ctx, { id, theme }) => {\n const found = ctx.db.profile.id.find(id);\n if (!found) throw new Error('profile not found');\n ctx.db.profile.id.update({\n ...found,\n preferences: { ...found.preferences, theme },\n });\n }\n);\n",{"_33":340,"_35":327,"_36":341,"_38":342,"_40":343},"t_057_nested_cascade_delete","Nested Cascade Delete","Write a SpacetimeDB backend module in TypeScript that performs a nested cascade delete across normalized tables.\n\nTABLES\n- workspace (public)\n - Fields:\n - id: u64 (primary key)\n- project (public)\n - Fields:\n - id: u64 (primary key)\n - workspaceId: u64 (btree index)\n- task_item (public)\n - Fields:\n - id: u64 (primary key)\n - projectId: u64 (btree index)\n- task_note (public)\n - Fields:\n - id: u64 (primary key)\n - taskId: u64 (btree index)\n\nREDUCERS\n- seed()\n - Create two independent workspace -> project -> task_item -> task_note chains using IDs 1 and 2\n- delete_workspace(id: u64)\n - Delete the selected workspace and every level of its descendants\n - Preserve the unrelated chain","import { schema, table, t } from 'spacetimedb/server';\n\nconst workspace = table({ name: 'workspace', public: true }, { id: t.u64().primaryKey() });\nconst project = table({ name: 'project', public: true }, { id: t.u64().primaryKey(), workspaceId: t.u64().index('btree') });\nconst taskItem = table({ name: 'task_item', public: true }, { id: t.u64().primaryKey(), projectId: t.u64().index('btree') });\nconst taskNote = table({ name: 'task_note', public: true }, { id: t.u64().primaryKey(), taskId: t.u64().index('btree') });\nconst spacetimedb = schema({ workspace, project, taskItem, taskNote });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n for (const id of [1n, 2n]) {\n ctx.db.workspace.insert({ id });\n ctx.db.project.insert({ id, workspaceId: id });\n ctx.db.taskItem.insert({ id, projectId: id });\n ctx.db.taskNote.insert({ id, taskId: id });\n }\n});\n\nexport const delete_workspace = spacetimedb.reducer({ id: t.u64() }, (ctx, { id }) => {\n for (const project of [...ctx.db.project.workspaceId.filter(id)]) {\n for (const task of [...ctx.db.taskItem.projectId.filter(project.id)]) {\n for (const note of [...ctx.db.taskNote.taskId.filter(task.id)]) ctx.db.taskNote.id.delete(note.id);\n ctx.db.taskItem.id.delete(task.id);\n }\n ctx.db.project.id.delete(project.id);\n }\n ctx.db.workspace.id.delete(id);\n});\n",{"_33":345,"_35":327,"_36":346,"_38":347,"_40":348},"t_058_batched_delete","Batched Delete","Write a SpacetimeDB backend module in TypeScript that deletes a logical group in scheduled batches of at most two rows.\n\nTABLES\n- work_item (public)\n - Fields:\n - id: u64 (primary key)\n - groupId: u64 (btree index)\n- delete_job (private, scheduled for runDeleteBatch)\n - Fields:\n - scheduledId: u64 (primary key, auto-increment)\n - scheduledAt: ScheduleAt\n - groupId: u64\n\nREDUCERS\n- seed_group(groupId: u64, count: u32)\n - Assign deterministic unique id values to the inserted rows\n- request_delete(groupId: u64)\n- runDeleteBatch(timer: delete_job row) (scheduled reducer)\n - Delete at most two work_item rows matching the scheduled groupId\n - If matching rows remain, enqueue another one-shot delete_job","import { ScheduleAt } from 'spacetimedb';\nimport { schema, table, t } from 'spacetimedb/server';\nimport type { InferSchema, ReducerCtx } from 'spacetimedb/server';\n\nconst workItem = table(\n { name: 'work_item', public: true },\n { id: t.u64().primaryKey(), groupId: t.u64().index('btree') }\n);\nconst deleteJob = table(\n { name: 'delete_job', scheduled: (): any => runDeleteBatch },\n { scheduledId: t.u64().primaryKey().autoInc(), scheduledAt: t.scheduleAt(), groupId: t.u64() }\n);\nconst spacetimedb = schema({ workItem, deleteJob });\nexport default spacetimedb;\ntype Ctx = ReducerCtx>;\n\nfunction enqueue(ctx: Ctx, groupId: bigint) {\n ctx.db.deleteJob.insert({\n scheduledId: 0n,\n scheduledAt: ScheduleAt.time(ctx.timestamp.microsSinceUnixEpoch + 1_000n),\n groupId,\n });\n}\n\nexport const seed_group = spacetimedb.reducer({ groupId: t.u64(), count: t.u32() }, (ctx, { groupId, count }) => {\n for (let offset = 0; offset < count; offset++) ctx.db.workItem.insert({ id: groupId * 100n + BigInt(offset), groupId });\n});\nexport const request_delete = spacetimedb.reducer({ groupId: t.u64() }, (ctx, { groupId }) => enqueue(ctx, groupId));\nexport const runDeleteBatch = spacetimedb.reducer({ timer: deleteJob.rowType }, (ctx, { timer }) => {\n let deleted = 0;\n for (const row of ctx.db.workItem.groupId.filter(timer.groupId)) {\n if (deleted === 2) break;\n ctx.db.workItem.id.delete(row.id);\n deleted++;\n }\n if (ctx.db.workItem.groupId.filter(timer.groupId)[Symbol.iterator]().next().done === false) enqueue(ctx, timer.groupId);\n});\n",{"_33":350,"_35":327,"_36":351,"_38":352,"_40":353},"t_059_deterministic_context","Deterministic Context","Write a SpacetimeDB backend module in TypeScript that records deterministic reducer time and randomness.\n\nTABLE\n- generated_value (public)\n - Fields:\n - id: u64 (primary key, auto-increment)\n - createdAt: Timestamp\n - randomValue: i64\n\nREDUCERS\n- generate()\n - Store ctx.timestamp in createdAt\n - Store a random integer from ctx.random in randomValue\n - Do not use Date, Math.random, or a separately seeded RNG","import { schema, table, t } from 'spacetimedb/server';\n\nconst generatedValue = table(\n { name: 'generated_value', public: true },\n { id: t.u64().primaryKey().autoInc(), createdAt: t.timestamp(), randomValue: t.i64() }\n);\nconst spacetimedb = schema({ generatedValue });\nexport default spacetimedb;\n\nexport const generate = spacetimedb.reducer(ctx => {\n ctx.db.generatedValue.insert({\n id: 0n,\n createdAt: ctx.timestamp,\n randomValue: BigInt(ctx.random.integerInRange(1, Number.MAX_SAFE_INTEGER)),\n });\n});\n",{"_33":355,"_35":327,"_36":356,"_38":357,"_40":358},"t_060_reducer_result_table","Reducer Result Table","Write a SpacetimeDB backend module in TypeScript that writes reducer results to a table.\n\nTABLE\n- command_result (public)\n - Fields:\n - requestId: string (primary key)\n - success: boolean\n - message: string\n\nREDUCERS\n- run_command(requestId: string, value: i32)\n - Reducers do not return application data\n - Insert a command_result row with success set to true\n - Set message to \"value=\" using the supplied value","import { schema, table, t } from 'spacetimedb/server';\n\nconst commandResult = table(\n { name: 'command_result', public: true },\n { requestId: t.string().primaryKey(), success: t.bool(), message: t.string() }\n);\nconst spacetimedb = schema({ commandResult });\nexport default spacetimedb;\n\nexport const run_command = spacetimedb.reducer(\n { requestId: t.string(), value: t.i32() },\n (ctx, { requestId, value }) => ctx.db.commandResult.insert({\n requestId,\n success: true,\n message: `value=${value}`,\n })\n);\n","views",[361,366,371,376,381,386,391],{"_33":362,"_35":359,"_36":363,"_38":364,"_40":365},"t_061_three_table_join","Hree Table Join","Write a SpacetimeDB backend module in TypeScript that defines a public view joining three normalized tables.\n\nTABLES\n- customer (public)\n - Fields:\n - id: u64 (primary key)\n - name: string\n- purchase (public)\n - Fields:\n - id: u64 (primary key)\n - customerId: u64 (btree index)\n- line_item (public)\n - Fields:\n - id: u64 (primary key)\n - purchaseId: u64 (btree index)\n - sku: string\n - visible: bool (btree index)\n\nREDUCERS\n- seed()\n - Insert one complete visible customer -> purchase -> line_item chain\n - Use customer id 1 named \"Ada\"\n - Use purchase id 10 for customer 1\n - Use visible line_item id 100 for purchase 10 with sku \"SKU-1\"\n\nVIEW\n- order_line_detail (anonymous procedural, public)\n - Returns rows with lineId: u64, customerName: string, and sku: string\n - Return only rows connected through matching customer, purchase, and line-item IDs","import { schema, table, t } from 'spacetimedb/server';\nconst customer = table({ name: 'customer', public: true }, { id: t.u64().primaryKey(), name: t.string() });\nconst purchase = table({ name: 'purchase', public: true }, { id: t.u64().primaryKey(), customerId: t.u64().index('btree') });\nconst lineItem = table({ name: 'line_item', public: true }, { id: t.u64().primaryKey(), purchaseId: t.u64().index('btree'), sku: t.string(), visible: t.bool().index('btree') });\nconst OrderLineDetail = t.row('ThreeTableJoinRow', { lineId: t.u64(), customerName: t.string(), sku: t.string() });\nconst spacetimedb = schema({ customer, purchase, lineItem }); export default spacetimedb;\nexport const seed = spacetimedb.reducer(ctx => { ctx.db.customer.insert({ id: 1n, name: 'Ada' }); ctx.db.purchase.insert({ id: 10n, customerId: 1n }); ctx.db.lineItem.insert({ id: 100n, purchaseId: 10n, sku: 'SKU-1', visible: true }); });\nexport const order_line_detail = spacetimedb.anonymousView({ name: 'order_line_detail', public: true }, t.array(OrderLineDetail), ctx => {\n const rows: Array<{ lineId: bigint; customerName: string; sku: string }> = []; for (const line of ctx.db.lineItem.visible.filter(true)) { const purchase = ctx.db.purchase.id.find(line.purchaseId); if (!purchase) continue; const customer = ctx.db.customer.id.find(purchase.customerId); if (customer) rows.push({ lineId: line.id, customerName: customer.name, sku: line.sku }); } return rows;\n});\n",{"_33":367,"_35":359,"_36":368,"_38":369,"_40":370},"t_062_semijoin_intersection","Semijoin Intersection","Write a SpacetimeDB backend module in TypeScript that defines a query-builder semijoin view.\n\nTABLES\n- member (public)\n - Fields:\n - id: u64 (primary key)\n - name: string\n- eligibility (public)\n - Fields:\n - id: u64 (primary key)\n - memberId: u64 (btree index)\n\nREDUCERS\n- seed()\n - Insert member 1 named \"Ada\" and member 2 named \"Grace\"\n - Insert eligibility id 10 for only member 1\n\nVIEW\n- eligible_member (public, non-anonymous query-builder)\n - Use a semijoin\n - Return members only when a matching eligibility row exists","import { schema, table, t } from 'spacetimedb/server';\n\nconst member = table({ name: 'member', public: true }, { id: t.u64().primaryKey(), name: t.string() });\nconst eligibility = table({ name: 'eligibility', public: true }, { id: t.u64().primaryKey(), memberId: t.u64().index('btree') });\nconst spacetimedb = schema({ member, eligibility });\nexport default spacetimedb;\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.member.insert({ id: 1n, name: 'Ada' }); ctx.db.member.insert({ id: 2n, name: 'Grace' });\n ctx.db.eligibility.insert({ id: 10n, memberId: 1n });\n});\nexport const eligible_member = spacetimedb.view(\n { name: 'eligible_member', public: true }, t.array(member.rowType),\n ctx => ctx.from.eligibility.rightSemijoin(ctx.from.member, (eligibility, member) => eligibility.memberId.eq(member.id))\n);\n",{"_33":372,"_35":359,"_36":373,"_38":374,"_40":375},"t_063_timestamp_window","Imestamp Window","Write a SpacetimeDB backend module in TypeScript that defines a procedural view over an inclusive timestamp range.\n\nTABLE\n- event (public)\n - Fields:\n - id: u64 (primary key)\n - occurredAt: Timestamp (btree index)\n - label: string\n\nREDUCERS\n- seed()\n - Insert events at 100, 200, 300, 400, and 500 microseconds after the Unix epoch\n - Assign ids 1 through 5 in timestamp order\n - Set each label to \"event-{microseconds}\", such as \"event-100\"\n\nVIEW\n- window_event (anonymous procedural, public)\n - Use the occurredAt index\n - Return the inclusive range from 200 through 400 microseconds\n - Return rows in ascending occurredAt order","import { Timestamp } from 'spacetimedb';\nimport { Range, schema, table, t } from 'spacetimedb/server';\n\nconst event = table({ name: 'event', public: true }, {\n id: t.u64().primaryKey(),\n occurredAt: t.timestamp().index('btree'),\n label: t.string(),\n});\n\nconst spacetimedb = schema({ event });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n [100n, 200n, 300n, 400n, 500n].forEach((micros, index) => {\n ctx.db.event.insert({ id: BigInt(index + 1), occurredAt: new Timestamp(micros), label: `event-${micros}` });\n });\n});\n\nexport const window_event = spacetimedb.anonymousView(\n { name: 'window_event', public: true },\n t.array(event.rowType),\n ctx => Array.from(ctx.db.event.occurredAt.filter(new Range(\n { tag: 'included', value: new Timestamp(200n) },\n { tag: 'included', value: new Timestamp(400n) },\n )))\n);\n",{"_33":377,"_35":359,"_36":378,"_38":379,"_40":380},"t_064_index_and_filter","Index And Filter","Write a SpacetimeDB backend module in TypeScript that defines a procedural view using an index and additional filters.\n\nTABLE\n- content (public)\n - Fields:\n - id: u64 (primary key)\n - category: string (btree index)\n - active: boolean\n - score: i32\n\nREDUCERS\n- seed()\n - Insert id 1 with category \"news\", active true, and score 20\n - Insert id 2 with category \"news\", active false, and score 20\n - Insert id 3 with category \"news\", active true, and score 5\n - Insert id 4 with category \"sports\", active true, and score 20\n\nVIEW\n- featured_content (anonymous procedural, public)\n - First use the category index for \"news\"\n - Then return only active rows with score at least 10","import { schema, table, t } from 'spacetimedb/server';\nconst content = table({ name: 'content', public: true }, { id: t.u64().primaryKey(), category: t.string().index('btree'), active: t.bool(), score: t.i32() });\nconst spacetimedb = schema({ content }); export default spacetimedb;\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.content.insert({ id: 1n, category: 'news', active: true, score: 20 });\n ctx.db.content.insert({ id: 2n, category: 'news', active: false, score: 20 });\n ctx.db.content.insert({ id: 3n, category: 'news', active: true, score: 5 });\n ctx.db.content.insert({ id: 4n, category: 'sports', active: true, score: 20 });\n});\nexport const featured_content = spacetimedb.anonymousView(\n { name: 'featured_content', public: true }, t.array(content.rowType),\n ctx => Array.from(ctx.db.content.category.filter('news')).filter(row => row.active && row.score >= 10)\n);\n",{"_33":382,"_35":359,"_36":383,"_38":384,"_40":385},"t_065_materialized_aggregate","Materialized Aggregate","Write a SpacetimeDB backend module in TypeScript that maintains and exposes a materialized aggregate.\n\nTABLES\n- sale (public)\n - Fields:\n - id: u64 (primary key)\n - category: string\n - amount: i64\n- category_total (public)\n - Fields:\n - category: string (primary key)\n - totalAmount: i64\n - saleCount: u64\n\nREDUCERS\n- exercise()\n - This is the only exported reducer\n - Keep category_total transactionally synchronized when a sale is inserted, changed, moved between categories, or deleted\n - Insert books sales with ids 1 and 2 and amounts 10 and 20\n - Update the second books sale to 25\n - Insert and then delete a games sale with id 3\n - Delete the first books sale\n\nVIEW\n- category_summary (public, non-anonymous query-builder)\n - Expose all category_total rows\n - After exercise, the only row is books with totalAmount 25 and saleCount 1","import { schema, table, t } from 'spacetimedb/server';\nimport type { InferSchema, ReducerCtx } from 'spacetimedb/server';\n\nconst sale = table({ name: 'sale', public: true }, {\n id: t.u64().primaryKey(), category: t.string(), amount: t.i64(),\n});\nconst categoryTotal = table({ name: 'category_total', public: true }, {\n category: t.string().primaryKey(), totalAmount: t.i64(), saleCount: t.u64(),\n});\nconst spacetimedb = schema({ sale, categoryTotal });\nexport default spacetimedb;\n\ntype Ctx = ReducerCtx>;\n\nfunction addToTotal(ctx: Ctx, category: string, amount: bigint) {\n const total = ctx.db.categoryTotal.category.find(category);\n if (total) ctx.db.categoryTotal.category.update({ ...total, totalAmount: total.totalAmount + amount, saleCount: total.saleCount + 1n });\n else ctx.db.categoryTotal.insert({ category, totalAmount: amount, saleCount: 1n });\n}\n\nfunction removeFromTotal(ctx: Ctx, category: string, amount: bigint) {\n const total = ctx.db.categoryTotal.category.find(category);\n if (!total) throw new Error('missing category total');\n if (total.saleCount === 1n) ctx.db.categoryTotal.category.delete(category);\n else ctx.db.categoryTotal.category.update({ ...total, totalAmount: total.totalAmount - amount, saleCount: total.saleCount - 1n });\n}\n\nfunction upsertSale(ctx: Ctx, row: { id: bigint; category: string; amount: bigint }) {\n const old = ctx.db.sale.id.find(row.id);\n if (old) { removeFromTotal(ctx, old.category, old.amount); ctx.db.sale.id.update(row); }\n else ctx.db.sale.insert(row);\n addToTotal(ctx, row.category, row.amount);\n}\n\nfunction deleteSale(ctx: Ctx, id: bigint) {\n const old = ctx.db.sale.id.find(id);\n if (!old) return;\n ctx.db.sale.id.delete(id);\n removeFromTotal(ctx, old.category, old.amount);\n}\n\nexport const exercise = spacetimedb.reducer(ctx => {\n upsertSale(ctx, { id: 1n, category: 'books', amount: 10n });\n upsertSale(ctx, { id: 2n, category: 'books', amount: 20n });\n upsertSale(ctx, { id: 2n, category: 'books', amount: 25n });\n upsertSale(ctx, { id: 3n, category: 'games', amount: 40n });\n deleteSale(ctx, 3n);\n deleteSale(ctx, 1n);\n});\n\nexport const category_summary = spacetimedb.view(\n { name: 'category_summary', public: true }, t.array(categoryTotal.rowType), ctx => ctx.from.categoryTotal\n);\n",{"_33":387,"_35":359,"_36":388,"_38":389,"_40":390},"t_066_query_builder_view","Query Builder View","Write a SpacetimeDB backend module in TypeScript that defines a query-builder filter view.\n\nTABLE\n- ticket (public)\n - Fields:\n - id: u64 (primary key)\n - status: string (btree index)\n - title: string\n\nREDUCERS\n- seed()\n - Insert open ticket id 1 titled \"A\"\n - Insert closed ticket id 2 titled \"B\"\n\nVIEW\n- open_ticket (public, non-anonymous query-builder)\n - Return the query-builder filter for status \"open\"\n - Do not materialize rows manually","import { schema, table, t } from 'spacetimedb/server';\nconst ticket = table({ name: 'ticket', public: true }, { id: t.u64().primaryKey(), status: t.string().index('btree'), title: t.string() });\nconst spacetimedb = schema({ ticket }); export default spacetimedb;\nexport const seed = spacetimedb.reducer(ctx => { ctx.db.ticket.insert({ id: 1n, status: 'open', title: 'A' }); ctx.db.ticket.insert({ id: 2n, status: 'closed', title: 'B' }); });\nexport const open_ticket = spacetimedb.view({ name: 'open_ticket', public: true }, t.array(ticket.rowType), ctx => ctx.from.ticket.where(ticket => ticket.status.eq('open')));\n",{"_33":392,"_35":359,"_36":393,"_38":394,"_40":395},"t_067_view_primary_key","View Primary Key","Write a SpacetimeDB backend module in TypeScript that defines a procedural view with a primary key.\n\nTABLE\n- source_row (public)\n - Fields:\n - id: u64 (primary key)\n - value: string\n - visible: boolean (btree index)\n\nREDUCERS\n- seed()\n - Insert row 1 with value \"shown\" and visible true\n - Insert row 2 with value \"hidden\" and visible false\n\nVIEW\n- source_view (anonymous procedural, public)\n - Return visible source_row rows\n - The returned row type declares id as its primary key","import { schema, table, t } from 'spacetimedb/server';\nconst SourceViewRow = t.row('SourceViewRow', { id: t.u64().primaryKey(), value: t.string(), visible: t.bool().index('btree') });\nconst sourceRow = table({ name: 'source_row', public: true }, SourceViewRow);\nconst spacetimedb = schema({ sourceRow }); export default spacetimedb;\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.sourceRow.insert({ id: 1n, value: 'shown', visible: true });\n ctx.db.sourceRow.insert({ id: 2n, value: 'hidden', visible: false });\n});\nexport const source_view = spacetimedb.anonymousView({ name: 'source_view', public: true }, t.array(SourceViewRow), ctx => Array.from(ctx.db.sourceRow.visible.filter(true)));\n","lifecycle",[398,403,408],{"_33":399,"_35":396,"_36":400,"_38":401,"_40":402},"t_069_scheduled_materialization","Scheduled Materialization","Write a SpacetimeDB backend module in TypeScript that refreshes materialized state through a scheduled reducer.\n\nTABLES\n- materialized_state (public)\n - Fields:\n - id: u64 (primary key)\n - status: string\n - version: u64\n - refreshedAt: Timestamp\n- refresh_job (private, scheduled for refreshMaterialized)\n - Fields, in this order:\n - scheduledId: u64 (primary key, auto-increment)\n - scheduledAt: ScheduleAt\n - stateId: u64\n\nREDUCERS\n- start_refresh()\n - Write id 1 with status \"pending\", version 0, and refreshedAt at the Unix epoch\n - Schedule state 1 for one millisecond later\n- refreshMaterialized(job: refresh_job row) (scheduled reducer)\n - Update state 1 to status \"ready\" and version 1\n - Replace refreshedAt with the scheduled reducer timestamp\n - Complete without any further client call","import { ScheduleAt, Timestamp } from 'spacetimedb';\nimport { schema, table, t } from 'spacetimedb/server';\n\nconst materializedState = table({ name: 'materialized_state', public: true }, {\n id: t.u64().primaryKey(), status: t.string(), version: t.u64(), refreshedAt: t.timestamp(),\n});\nconst refreshJob = table({ name: 'refresh_job', scheduled: (): any => refreshMaterialized }, {\n scheduledId: t.u64().primaryKey().autoInc(), scheduledAt: t.scheduleAt(), stateId: t.u64(),\n});\nconst spacetimedb = schema({ materializedState, refreshJob });\nexport default spacetimedb;\n\nexport const start_refresh = spacetimedb.reducer(ctx => {\n const pending = { id: 1n, status: 'pending', version: 0n, refreshedAt: new Timestamp(0n) };\n if (ctx.db.materializedState.id.find(1n)) ctx.db.materializedState.id.update(pending);\n else ctx.db.materializedState.insert(pending);\n ctx.db.refreshJob.insert({\n scheduledId: 0n, scheduledAt: ScheduleAt.time(ctx.timestamp.microsSinceUnixEpoch + 1_000n), stateId: 1n,\n });\n});\n\nexport const refreshMaterialized = spacetimedb.reducer({ job: refreshJob.rowType }, (ctx, { job }) => {\n const state = ctx.db.materializedState.id.find(job.stateId);\n if (!state) throw new Error('materialized state missing');\n ctx.db.materializedState.id.update({ ...state, status: 'ready', version: 1n, refreshedAt: ctx.timestamp });\n});\n",{"_33":404,"_35":396,"_36":405,"_38":406,"_40":407},"t_070_connection_scoped_presence","Connection Scoped Presence","Write a SpacetimeDB backend module in TypeScript that tracks presence separately for each connection.\n\nTABLE\n- presence_session (public)\n - Fields:\n - connectionId: ConnectionId (primary key)\n - identity: Identity (btree index)\n - connectedAt: Timestamp\n\nLIFECYCLE HOOKS\n- clientConnected\n - Export with this exact identifier\n - Insert one row for the connected connection\n- clientDisconnected\n - Export with this exact identifier\n - Delete only the disconnected connection's row\n\nREDUCERS\n- exercise_presence()\n - Insert synthetic connection IDs 1 and 2 for the caller\n - Use the 128-bit numeric values 1 and 2\n - Remove connection ID 1\n - Leave connection ID 2 intact","import { ConnectionId } from 'spacetimedb';\nimport { schema, table, t } from 'spacetimedb/server';\nimport type { InferSchema, ReducerCtx } from 'spacetimedb/server';\n\nconst presenceSession = table({ name: 'presence_session', public: true }, {\n connectionId: t.connectionId().primaryKey(), identity: t.identity().index('btree'), connectedAt: t.timestamp(),\n});\nconst spacetimedb = schema({ presenceSession });\nexport default spacetimedb;\ntype Ctx = ReducerCtx>;\n\nfunction addSession(ctx: Ctx, connectionId: ConnectionId) {\n ctx.db.presenceSession.insert({ connectionId, identity: ctx.sender, connectedAt: ctx.timestamp });\n}\nfunction removeSession(ctx: Ctx, connectionId: ConnectionId) { ctx.db.presenceSession.connectionId.delete(connectionId); }\n\nexport const clientConnected = spacetimedb.clientConnected(ctx => {\n if (!ctx.connectionId) throw new Error('connection id missing');\n addSession(ctx, ctx.connectionId);\n});\nexport const clientDisconnected = spacetimedb.clientDisconnected(ctx => {\n if (!ctx.connectionId) throw new Error('connection id missing');\n removeSession(ctx, ctx.connectionId);\n});\nexport const exercise_presence = spacetimedb.reducer(ctx => {\n const first = new ConnectionId(1n);\n const second = new ConnectionId(2n);\n addSession(ctx, first);\n addSession(ctx, second);\n removeSession(ctx, first);\n});\n",{"_33":409,"_35":396,"_36":410,"_38":411,"_40":412},"t_071_scheduled_private","Scheduled Private","Write a SpacetimeDB backend module in TypeScript with a private scheduled table that is not client-callable.\n\nTABLES\n- job_result (public)\n - Fields:\n - id: u64 (primary key)\n - status: string\n- private_job (private, scheduled for runPrivateJob)\n - Fields, in this order:\n - scheduledId: u64 (primary key, auto-increment)\n - scheduledAt: ScheduleAt\n - resultId: u64\n\nREDUCERS\n- enqueue_private(id: u64)\n - Write job_result status \"queued\"\n - Schedule that id for one millisecond later\n- runPrivateJob(job: private_job row) (scheduled reducer)\n - Must be scheduler-only and not client-callable\n - Update the matching job_result status to \"complete\"","import { ScheduleAt } from 'spacetimedb';\nimport { schema, table, t } from 'spacetimedb/server';\n\nconst jobResult = table({ name: 'job_result', public: true }, {\n id: t.u64().primaryKey(), status: t.string(),\n});\nconst privateJob = table({ name: 'private_job', scheduled: (): any => runPrivateJob }, {\n scheduledId: t.u64().primaryKey().autoInc(), scheduledAt: t.scheduleAt(), resultId: t.u64(),\n});\nconst spacetimedb = schema({ jobResult, privateJob });\nexport default spacetimedb;\n\nexport const enqueue_private = spacetimedb.reducer({ id: t.u64() }, (ctx, { id }) => {\n ctx.db.jobResult.insert({ id, status: 'queued' });\n ctx.db.privateJob.insert({\n scheduledId: 0n, scheduledAt: ScheduleAt.time(ctx.timestamp.microsSinceUnixEpoch + 1_000n), resultId: id,\n });\n});\n\nexport const runPrivateJob = spacetimedb.reducer({ job: privateJob.rowType }, (ctx, { job }) => {\n const result = ctx.db.jobResult.id.find(job.resultId);\n if (!result) throw new Error('job result missing');\n ctx.db.jobResult.id.update({ ...result, status: 'complete' });\n});\n","procedures",[415,420,425,430,435,440,445,450],{"_33":416,"_35":413,"_36":417,"_38":418,"_40":419},"t_072_procedure_return","Procedure Return","Write a SpacetimeDB backend module in TypeScript that defines a procedure with a typed return value.\n\nTYPES\n- Summary\n - total: u32\n - label: string\n\nPROCEDURE\n- calculate_summary(lhs: u32, rhs: u32) -> Summary\n - Return total as lhs + rhs\n - Return label as \"calculated\"","import { schema, t } from 'spacetimedb/server';\n\nconst Summary = t.object('Summary', { total: t.u32(), label: t.string() });\nconst spacetimedb = schema({});\nexport default spacetimedb;\n\nexport const calculate_summary = spacetimedb.procedure(\n { lhs: t.u32(), rhs: t.u32() }, Summary,\n (_ctx, { lhs, rhs }) => ({ total: lhs + rhs, label: 'calculated' })\n);\n",{"_33":421,"_35":413,"_36":422,"_38":423,"_40":424},"t_073_http_fetch","Http Fetch","Write a SpacetimeDB backend module in TypeScript that performs outbound HTTP in a procedure.\n\nTYPES\n- FetchSummary\n - status: u16\n - htmlContentType: bool\n - hasExampleDomain: bool\n\nPROCEDURE\n- fetch_page_summary(url: string) -> FetchSummary\n - Perform an outbound GET to the supplied public URL\n - Set status from the response status\n - Set htmlContentType based on whether Content-Type contains \"text/html\"\n - Set hasExampleDomain based on whether the body contains \"Example Domain\"","import { schema, t } from 'spacetimedb/server';\n\nconst FetchSummary = t.object('FetchSummary', {\n status: t.u16(), htmlContentType: t.bool(), hasExampleDomain: t.bool(),\n});\nconst spacetimedb = schema({});\nexport default spacetimedb;\n\nexport const fetch_page_summary = spacetimedb.procedure(\n { url: t.string() }, FetchSummary,\n (ctx, { url }) => {\n const response = ctx.http.fetch(url);\n return {\n status: response.status,\n htmlContentType: (response.headers.get('content-type') ?? '').includes('text/html'),\n hasExampleDomain: response.text().includes('Example Domain'),\n };\n }\n);\n",{"_33":426,"_35":413,"_36":427,"_38":428,"_40":429},"t_074_fetch_and_store","Fetch And Store","Write a SpacetimeDB backend module in TypeScript that fetches external data before storing a result in a transaction.\n\nTABLE\n- fetched_record (public)\n - Fields:\n - id: u64 (primary key)\n - status: u16\n - validBody: bool\n\nPROCEDURE\n- fetch_and_store(url: string)\n - Perform an outbound GET to the supplied public URL before opening a transaction\n - Inside a short transaction, store id 1 and the response status\n - Set validBody based on whether the response body contains \"Example Domain\"","import { schema, table, t } from 'spacetimedb/server';\n\nconst fetchedRecord = table({ name: 'fetched_record', public: true }, {\n id: t.u64().primaryKey(), status: t.u16(), validBody: t.bool(),\n});\nconst spacetimedb = schema({ fetchedRecord });\nexport default spacetimedb;\n\nexport const fetch_and_store = spacetimedb.procedure(\n { url: t.string() }, t.unit(),\n (ctx, { url }) => {\n const response = ctx.http.fetch(url);\n const status = response.status;\n const validBody = response.text().includes('Example Domain');\n ctx.withTx(tx => tx.db.fetchedRecord.insert({ id: 1n, status, validBody }));\n return {};\n }\n);\n",{"_33":431,"_35":413,"_36":432,"_38":433,"_40":434},"t_075_scheduled_procedure","Scheduled Procedure","Write a SpacetimeDB backend module in TypeScript that schedules a procedure which writes inside a transaction.\n\nTABLES\n- procedure_result (public)\n - Fields:\n - id: u64 (primary key)\n - value: u32\n- procedure_job (private, scheduled for runScheduledProcedure)\n - Fields, in this order:\n - scheduledId: u64 (primary key, auto-increment)\n - scheduledAt: ScheduleAt\n - id: u64\n - lhs: u32\n - rhs: u32\n\nREDUCERS\n- schedule_procedure(id: u64, lhs: u32, rhs: u32)\n - Enqueue runScheduledProcedure for one millisecond later\n\nPROCEDURE\n- runScheduledProcedure(job: procedure_job row) -> unit (scheduled procedure)\n - Open a transaction\n - Insert id and value lhs + rhs into procedure_result","import { ScheduleAt } from 'spacetimedb';\nimport { schema, table, t } from 'spacetimedb/server';\n\nconst procedureResult = table({ name: 'procedure_result', public: true }, {\n id: t.u64().primaryKey(), value: t.u32(),\n});\nconst procedureJob = table({ name: 'procedure_job', scheduled: (): any => runScheduledProcedure }, {\n scheduledId: t.u64().primaryKey().autoInc(), scheduledAt: t.scheduleAt(),\n id: t.u64(), lhs: t.u32(), rhs: t.u32(),\n});\nconst spacetimedb = schema({ procedureResult, procedureJob });\nexport default spacetimedb;\n\nexport const schedule_procedure = spacetimedb.reducer(\n { id: t.u64(), lhs: t.u32(), rhs: t.u32() },\n (ctx, { id, lhs, rhs }) => ctx.db.procedureJob.insert({\n scheduledId: 0n, scheduledAt: ScheduleAt.time(ctx.timestamp.microsSinceUnixEpoch + 1_000n), id, lhs, rhs,\n })\n);\n\nexport const runScheduledProcedure = spacetimedb.procedure(\n { job: procedureJob.rowType }, t.unit(),\n (ctx, { job }) => {\n ctx.withTx(tx => tx.db.procedureResult.insert({ id: job.id, value: job.lhs + job.rhs }));\n return {};\n }\n);\n",{"_33":436,"_35":413,"_36":437,"_38":438,"_40":439},"t_076_http_handler","Http Handler","Write a SpacetimeDB backend module in TypeScript that defines and routes an inbound HTTP handler.\n\nHANDLER\n- POST /echo\n - Read the request body\n - Return status 201\n - Return Content-Type text/plain\n - Return body \"echo:\" followed by the input body\n\nROUTER\n- Register the POST /echo handler through an HTTP router","import { Router, SyncResponse, schema } from 'spacetimedb/server';\n\nconst spacetimedb = schema({});\nexport default spacetimedb;\n\nexport const echo = spacetimedb.httpHandler((_ctx, request) =>\n new SyncResponse(`echo:${request.text()}`, { status: 201, headers: { 'content-type': 'text/plain' } })\n);\nexport const routes = spacetimedb.httpRouter(new Router().post('/echo', echo));\n",{"_33":441,"_35":413,"_36":442,"_38":443,"_40":444},"t_077_http_router","Http Router","Write a SpacetimeDB backend module in TypeScript that routes two HTTP methods on the same path.\n\nHANDLERS\n- GET /items\n - Return status 200\n - Return body \"list\"\n- POST /items\n - Read the request body\n - Return status 201\n - Return body \"created:\" followed by the request body\n\nROUTER\n- Register both handlers for /items\n- Reject unsupported methods on /items\n- Reject unknown paths","import { Router, SyncResponse, schema } from 'spacetimedb/server';\n\nconst spacetimedb = schema({});\nexport default spacetimedb;\n\nexport const listItems = spacetimedb.httpHandler((_ctx, _request) => new SyncResponse('list'));\nexport const createItem = spacetimedb.httpHandler((_ctx, request) =>\n new SyncResponse(`created:${request.text()}`, { status: 201 })\n);\nexport const routes = spacetimedb.httpRouter(\n new Router().get('/items', listItems).post('/items', createItem)\n);\n",{"_33":446,"_35":413,"_36":447,"_38":448,"_40":449},"t_078_idempotent_webhook","Idempotent Webhook","Write a SpacetimeDB backend module in TypeScript that handles idempotent, ordered webhook events.\n\nTABLES\n- processed_event (private)\n - Fields:\n - eventId: string (primary key)\n- webhook_state (public)\n - Fields:\n - key: string (primary key)\n - lastSequence: u64\n - value: string\n\nHANDLER\n- POST /webhook\n - Accept a pipe-delimited body: event_id|sequence|value\n - Store state under key \"account\"\n - For a newly applied event, return status 200 and body \"applied\"\n - For a duplicate eventId, return status 200 and body \"duplicate\" without applying twice\n - When sequence is not newer, return status 200 and body \"stale\" without replacing state\n\nROUTER\n- Register POST /webhook through an HTTP router","import { Router, SyncResponse, schema, table, t } from 'spacetimedb/server';\n\nconst processedEvent = table({ name: 'processed_event' }, { eventId: t.string().primaryKey() });\nconst webhookState = table({ name: 'webhook_state', public: true }, {\n key: t.string().primaryKey(), lastSequence: t.u64(), value: t.string(),\n});\nconst spacetimedb = schema({ processedEvent, webhookState });\nexport default spacetimedb;\n\nexport const webhook = spacetimedb.httpHandler((ctx, request) => {\n const parts = request.text().split('|', 3);\n if (parts.length !== 3) return new SyncResponse('invalid', { status: 400 });\n const [eventId, sequenceText, value] = parts;\n const sequence = BigInt(sequenceText);\n const outcome = ctx.withTx(tx => {\n if (tx.db.processedEvent.eventId.find(eventId)) return 'duplicate';\n tx.db.processedEvent.insert({ eventId });\n const state = tx.db.webhookState.key.find('account');\n if (state) {\n if (sequence <= state.lastSequence) return 'stale';\n tx.db.webhookState.key.update({ ...state, lastSequence: sequence, value });\n } else tx.db.webhookState.insert({ key: 'account', lastSequence: sequence, value });\n return 'applied';\n });\n return new SyncResponse(outcome);\n});\nexport const routes = spacetimedb.httpRouter(new Router().post('/webhook', webhook));\n",{"_33":451,"_35":413,"_36":452,"_38":453,"_40":454},"t_079_external_upload_flow","External Upload Flow","Write a SpacetimeDB backend module in TypeScript that exposes an upload route and an external upload procedure.\n\nTABLE\n- uploaded_asset (public)\n - Fields:\n - id: u64 (primary key)\n - url: string\n - size: u64\n - status: u16\n - responseBodyPresent: bool\n\nHANDLER\n- POST /upload\n - Return status 201\n - Return body \"https://files.local/object-1\"\n\nPROCEDURE\n- upload_and_register(uploadUrl: string, data: u8[]) -> string\n - POST the binary data to the supplied public URL\n - Require a successful response\n - Open a transaction and store id 1, the supplied URL, the byte length, the response status, and whether the response body is non-empty\n - Return the supplied URL\n\nROUTER\n- Register POST /upload through an HTTP router","import { Router, SyncResponse, schema, table, t } from 'spacetimedb/server';\n\nconst uploadedAsset = table({ name: 'uploaded_asset', public: true }, {\n id: t.u64().primaryKey(), url: t.string(), size: t.u64(), status: t.u16(), responseBodyPresent: t.bool(),\n});\nconst spacetimedb = schema({ uploadedAsset });\nexport default spacetimedb;\n\nexport const upload = spacetimedb.httpHandler((_ctx, _request) =>\n new SyncResponse('https://files.local/object-1', { status: 201 })\n);\nexport const routes = spacetimedb.httpRouter(new Router().post('/upload', upload));\n\nexport const upload_and_register = spacetimedb.procedure(\n { uploadUrl: t.string(), data: t.array(t.u8()) }, t.string(),\n (ctx, { uploadUrl, data }) => {\n const response = ctx.http.fetch(\n uploadUrl,\n { method: 'POST', headers: { 'content-type': 'application/octet-stream' }, body: new Uint8Array(data) }\n );\n if (response.status < 200 || response.status >= 300) throw new Error(`upload failed: ${response.status}`);\n const responseBodyPresent = response.bytes().length > 0;\n ctx.withTx(tx => tx.db.uploadedAsset.insert({\n id: 1n, url: uploadUrl, size: BigInt(data.length), status: response.status, responseBodyPresent,\n }));\n return uploadUrl;\n }\n);\n","migrations",[457,462,467],{"_33":458,"_35":455,"_36":459,"_38":460,"_40":461},"t_080_automatic_migration","Automatic Migration","Update the existing SpacetimeDB backend module in TypeScript with a compatible schema change.\n\nTABLES\n- product (public)\n - Preserve the existing table and its fields\n- category (public)\n - Fields:\n - id: u64 (primary key)\n - label: string\n\nREDUCERS\n- Preserve seed and touch\n- create_category(id: u64, label: string)\n - Insert a category with the supplied values\n\nMIGRATION\n- The populated product table must survive a normal republish without deleting data","import { schema, table, t } from 'spacetimedb/server';\n\nconst product = table(\n { name: 'product', public: true },\n { id: t.u64().primaryKey(), name: t.string() }\n);\nconst category = table(\n { name: 'category', public: true },\n { id: t.u64().primaryKey(), label: t.string() }\n);\nconst spacetimedb = schema({ product, category });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.product.insert({ id: 1n, name: 'legacy' });\n});\nexport const touch = spacetimedb.reducer(_ctx => {});\nexport const create_category = spacetimedb.reducer(\n { id: t.u64(), label: t.string() },\n (ctx, { id, label }) => ctx.db.category.insert({ id, label })\n);\n",{"_33":463,"_35":455,"_36":464,"_38":465,"_40":466},"t_081_incremental_migration","Incremental Migration","Update the existing SpacetimeDB backend module in TypeScript with an incremental migration.\n\nTABLES\n- legacy_item (public)\n - Preserve the existing table and fields\n- item_v2 (public)\n - Fields:\n - id: u64 (primary key)\n - value: string\n - version: u32\n\nREDUCERS\n- Preserve seed\n- migrate()\n - Be idempotent\n - Copy missing legacy_item rows into item_v2 with version 2\n- dual_write(id: u64, value: string)\n - Write the same new item to both tables\n - Set version 2 in item_v2","import { schema, table, t } from 'spacetimedb/server';\n\nconst legacyItem = table(\n { name: 'legacy_item', public: true },\n { id: t.u64().primaryKey(), value: t.string() }\n);\nconst itemV2 = table(\n { name: 'item_v2', public: true },\n { id: t.u64().primaryKey(), value: t.string(), version: t.u32() }\n);\nconst spacetimedb = schema({ legacyItem, itemV2 });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.legacyItem.insert({ id: 1n, value: 'old' });\n});\n\nexport const migrate = spacetimedb.reducer(ctx => {\n for (const row of ctx.db.legacyItem.iter()) {\n if (!ctx.db.itemV2.id.find(row.id)) {\n ctx.db.itemV2.insert({ id: row.id, value: row.value, version: 2 });\n }\n }\n});\n\nexport const dual_write = spacetimedb.reducer(\n { id: t.u64(), value: t.string() },\n (ctx, { id, value }) => {\n ctx.db.legacyItem.insert({ id, value });\n ctx.db.itemV2.insert({ id, value, version: 2 });\n }\n);\n",{"_33":468,"_35":455,"_36":469,"_38":470,"_40":471},"t_082_hot_swap_compatibility","Hot Swap Compatibility","Update the existing SpacetimeDB backend module in TypeScript through a compatible republish.\n\nTABLES\n- counter (public)\n - Preserve the existing table and its exact fields\n- release (private)\n - Fields:\n - version: u32 (primary key)\n\nREDUCERS\n- Preserve seed\n- Preserve increment without renaming it or changing its signature\n- record_release(version: u32)\n\nMIGRATION\n- Existing counter data must remain usable after republish\n- The existing server API must remain usable after republish","import { schema, table, t } from 'spacetimedb/server';\n\nconst counter = table(\n { name: 'counter', public: true },\n { id: t.u64().primaryKey(), value: t.i64() }\n);\nconst release = table(\n { name: 'release' },\n { version: t.u32().primaryKey() }\n);\nconst spacetimedb = schema({ counter, release });\nexport default spacetimedb;\n\nexport const seed = spacetimedb.reducer(ctx => {\n ctx.db.counter.insert({ id: 1n, value: 1n });\n});\nexport const increment = spacetimedb.reducer(\n { id: t.u64(), amount: t.i64() },\n (ctx, { id, amount }) => {\n const row = ctx.db.counter.id.find(id);\n if (!row) throw new Error('counter');\n ctx.db.counter.id.update({ ...row, value: row.value + amount });\n }\n);\nexport const record_release = spacetimedb.reducer(\n { version: t.u32() },\n (ctx, { version }) => ctx.db.release.insert({ version })\n);\n","routes/_marketing","actionData","errors"]

LLM Benchmarks

Evals

basics

schema

queries

data modeling

auth

tables

reducers

views

lifecycle

procedures

migrations