Hi

\"\n});\n```\n\n## Val Town Utility Functions\n\nVal Town provides several utility functions to help with common project tasks.\n\n### Importing Utilities\n\nAlways import utilities with version pins to avoid breaking changes:\n\n```ts\nimport { parseProject, readFile, serveFile } from \"https://esm.town/v/std/utils@85-main/index.ts\";\n```\n\n### Available Utilities\n\n\n#### **serveFile** - Serve project files with proper content types\n\nFor example, in Hono:\n\n```ts\n// serve all files in frontend/ and shared/\napp.get(\"/frontend/*\", c => serveFile(c.req.path, import.meta.url));\napp.get(\"/shared/*\", c => serveFile(c.req.path, import.meta.url));\n```\n\n#### **readFile** - Read files from within the project:\n\n```ts\n// Read a file from the project\nconst fileContent = await readFile(\"/frontend/index.html\", import.meta.url);\n```\n\n#### **listFiles** - List all files in the project\n\n```ts\nconst files = await listFiles(import.meta.url);\n```\n\n#### **parseProject** - Extract information about the current project from import.meta.url\n\nThis is useful for including info for linking back to a val, ie in \"view source\" urls:\n\n```ts\nconst projectVal = parseProject(import.meta.url);\nconsole.log(projectVal.username); // Owner of the project\nconsole.log(projectVal.name); // Project name\nconsole.log(projectVal.version); // Version number\nconsole.log(projectVal.branch); // Branch name\nconsole.log(projectVal.links.self.project); // URL to the project page\n```\n\nHowever, it's *extremely importing* to note that `parseProject` and other Standard Library utilities ONLY RUN ON THE SERVER.\nIf you need access to this data on the client, run it in the server and pass it to the client by splicing it into the HTML page\nor by making an API request for it.\n\n## Val Town Platform Specifics\n\n- **Redirects:** Use `return new Response(null, { status: 302, headers: { Location: \"/place/to/redirect\" }})` instead of `Response.redirect` which is broken\n- **Images:** Avoid external images or base64 images. Use emojis, unicode symbols, or icon fonts/libraries instead\n- **AI Image:** To inline generate an AI image use: `

`\n- **Storage:** DO NOT use the Deno KV module for storage\n- **Browser APIs:** DO NOT use the `alert()`, `prompt()`, or `confirm()` methods\n- **Weather Data:** Use open-meteo for weather data (doesn't require API keys) unless otherwise specified\n- **View Source:** Add a view source link by importing & using `import.meta.url.replace(\"ems.sh\", \"val.town)\"` (or passing this data to the client) and include `target=\"_top\"` attribute\n- **Error Debugging:** Add `` to HTML to capture client-side errors\n- **Error Handling:** Only use try...catch when there's a clear local resolution; Avoid catches that merely log or return 500s. Let errors bubble up with full context\n- **Environment Variables:** Use `Deno.env.get('keyname')` when you need to, but generally prefer APIs that don't require keys\n- **Imports:** Use `https://esm.sh` for npm and Deno dependencies to ensure compatibility on server and browser\n- **Storage Strategy:** Only use backend storage if explicitly required; prefer simple static client-side sites\n- **React Configuration:** When using React libraries, pin versions with `?deps=react@18.2.0,react-dom@18.2.0` and start the file with `/** @jsxImportSource https://esm.sh/react@18.2.0 */`\n- Ensure all React dependencies and sub-dependencies are pinned to the same version\n- **Styling:** Default to using TailwindCSS via `` unless otherwise specified\n\n## Project Structure and Design Patterns\n\n### Recommended Directory Structure\n```\n├── backend/\n│ ├── database/\n│ │ ├── migrations.ts # Schema definitions\n│ │ ├── queries.ts # DB query functions\n│ │ └── README.md\n│ └── routes/ # Route modules\n│ ├── [route].ts\n│ └── static.ts # Static file serving\n│ ├── index.ts # Main entry point\n│ └── README.md\n├── frontend/\n│ ├── components/\n│ │ ├── App.tsx\n│ │ └── [Component].tsx\n│ ├── favicon.svg\n│ ├── index.html # Main HTML template\n│ ├── index.tsx # Frontend JS entry point\n│ ├── README.md\n│ └── style.css\n├── README.md\n└── shared/\n ├── README.md\n └── utils.ts # Shared types and functions\n```\n\n### Backend (Hono) Best Practices\n\n- Hono is the recommended API framework\n- Main entry point should be `backend/index.ts`\n- **Static asset serving:** Use the utility functions to read and serve project files:\n ```ts\n import { readFile, serveFile } from \"https://esm.town/v/std/utils@85-main/index.ts\";\n \n // serve all files in frontend/ and shared/\n app.get(\"/frontend/*\", c => serveFile(c.req.path, import.meta.url));\n app.get(\"/shared/*\", c => serveFile(c.req.path, import.meta.url));\n \n // For index.html, often you'll want to bootstrap with initial data\n app.get(\"/\", async c => {\n let html = await readFile(\"/frontend/index.html\", import.meta.url);\n \n // Inject data to avoid extra round-trips\n const initialData = await fetchInitialData();\n const dataScript = ``;\n \n html = html.replace(\"\", `${dataScript}`);\n return c.html(html);\n });\n ```\n- Create RESTful API routes for CRUD operations\n- Always include this snippet at the top-level Hono app to re-throwing errors to see full stack traces:\n ```ts\n // Unwrap Hono errors to see original error details\n app.onError((err, c) => {\n throw err;\n });\n ```\n\n### Database Patterns\n- Run migrations on startup or comment out for performance\n- Change table names when modifying schemas rather than altering\n- Export clear query functions with proper TypeScript typing\n\n## Common Gotchas and Solutions\n\n1. **Environment Limitations:** \n - Val Town runs on Deno in a serverless context, not Node.js\n - Code in `shared/` must work in both frontend and backend environments\n - Cannot use `Deno` keyword in shared code\n - Use `https://esm.sh` for imports that work in both environments\n\n2. **SQLite Peculiarities:**\n - Limited support for ALTER TABLE operations\n - Create new tables with updated schemas and copy data when needed\n - Always run table creation before querying\n\n3. **React Configuration:**\n - All React dependencies must be pinned to 18.2.0\n - Always include `@jsxImportSource https://esm.sh/react@18.2.0` at the top of React files\n - Rendering issues often come from mismatched React versions\n\n4. **File Handling:**\n - Val Town only supports text files, not binary\n - Use the provided utilities to read files across branches and forks\n - For files in the project, use `readFile` helpers\n\n5. **API Design:**\n - `fetch` handler is the entry point for HTTP vals\n - Run the Hono app with `export default app.fetch // This is the entry point for HTTP vals`\n\n",[212],"174b0a1e-1752-11f1-b042-42dde27851f2",".vtignore","174b0ac8-1752-11f1-b042-42dde27851f2",426,["D",1772577677068],".git\n.vscode\n.cursorrules\n.DS_Store\nnode_modules\nvendor",[219],"01db1fe6-1768-11f1-aed8-42dde27851f2","tests","01db20b8-1768-11f1-aed8-42dde27851f2",435,["D",1772587090024],"directory",[226],"d18aa2a6-1831-11f1-92a6-42dde27851f2",".claude","d18aa364-1831-11f1-92a6-42dde27851f2",478,["D",1772673767310],[233],"pulls","branches","forks","envVars",{"_245":26,"_247":26},"connections",{"_245":26,"_246":26},"count","unfilledCount","emptyCount",{"_33":232,"_13":233,"_62":234,"_43":-5,"_35":36,"_162":235,"_164":76,"_37":397,"_39":26,"_64":230,"_168":-5,"_65":24,"_170":-5,"_271":398,"_17":399},{"_33":388,"_13":389,"_62":390,"_43":234,"_35":36,"_162":391,"_164":76,"_37":392,"_39":393,"_64":21,"_168":394,"_65":24,"_170":-5,"_271":395,"_17":396},{"_33":225,"_13":226,"_62":227,"_43":-5,"_35":36,"_162":228,"_164":76,"_37":385,"_39":26,"_64":230,"_168":-5,"_65":24,"_170":-5,"_271":386,"_17":387},{"_33":377,"_13":378,"_62":379,"_43":227,"_35":36,"_162":380,"_164":76,"_37":381,"_39":26,"_64":167,"_168":382,"_65":24,"_170":-5,"_271":383,"_17":384},{"_33":369,"_13":370,"_62":371,"_43":227,"_35":36,"_162":372,"_164":76,"_37":373,"_39":26,"_64":167,"_168":374,"_65":24,"_170":-5,"_271":375,"_17":376},{"_33":360,"_13":361,"_62":362,"_43":227,"_35":36,"_162":363,"_164":76,"_37":364,"_39":365,"_64":167,"_168":366,"_65":24,"_170":-5,"_271":367,"_17":368},{"_33":352,"_13":353,"_62":354,"_43":227,"_35":36,"_162":355,"_164":76,"_37":356,"_39":26,"_64":167,"_168":357,"_65":24,"_170":-5,"_271":358,"_17":359},{"_33":344,"_13":345,"_62":346,"_43":227,"_35":36,"_162":347,"_164":76,"_37":348,"_39":92,"_64":167,"_168":349,"_65":24,"_170":-5,"_271":350,"_17":351},{"_33":336,"_13":337,"_62":338,"_43":227,"_35":36,"_162":339,"_164":76,"_37":340,"_39":26,"_64":167,"_168":341,"_65":24,"_170":-5,"_271":342,"_17":343},{"_33":328,"_13":329,"_62":330,"_43":227,"_35":36,"_162":331,"_164":76,"_37":332,"_39":92,"_64":167,"_168":333,"_65":24,"_170":-5,"_271":334,"_17":335},{"_33":320,"_13":321,"_62":322,"_43":227,"_35":36,"_162":323,"_164":76,"_37":324,"_39":26,"_64":167,"_168":325,"_65":24,"_170":-5,"_271":326,"_17":327},{"_33":312,"_13":313,"_62":314,"_43":227,"_35":36,"_162":315,"_164":76,"_37":316,"_39":26,"_64":167,"_168":317,"_65":24,"_170":-5,"_271":318,"_17":319},{"_33":304,"_13":305,"_62":306,"_43":227,"_35":36,"_162":307,"_164":76,"_37":308,"_39":26,"_64":167,"_168":309,"_65":24,"_170":-5,"_271":310,"_17":311},{"_33":295,"_13":296,"_62":297,"_43":227,"_35":36,"_162":298,"_164":76,"_37":299,"_39":300,"_64":167,"_168":301,"_65":24,"_170":-5,"_271":302,"_17":303},{"_33":218,"_13":219,"_62":220,"_43":-5,"_35":36,"_162":221,"_164":76,"_37":292,"_39":26,"_64":21,"_168":223,"_65":24,"_170":-5,"_271":293,"_17":294},{"_33":211,"_13":212,"_62":213,"_43":-5,"_35":36,"_162":214,"_164":76,"_37":289,"_39":26,"_64":21,"_168":216,"_65":24,"_170":-5,"_271":290,"_17":291},{"_33":204,"_13":205,"_62":206,"_43":-5,"_35":36,"_162":115,"_164":76,"_37":286,"_39":208,"_64":21,"_168":209,"_65":24,"_170":-5,"_271":287,"_17":288},{"_33":197,"_13":198,"_62":199,"_43":-5,"_35":36,"_162":200,"_164":76,"_37":283,"_39":26,"_64":21,"_168":202,"_65":24,"_170":-5,"_271":284,"_17":285},{"_33":188,"_13":189,"_62":190,"_43":-5,"_35":36,"_162":191,"_164":76,"_37":280,"_39":193,"_64":194,"_168":195,"_65":24,"_170":-5,"_271":281,"_17":282},{"_33":180,"_13":181,"_62":182,"_43":-5,"_35":36,"_162":183,"_164":76,"_37":277,"_39":185,"_64":167,"_168":186,"_65":24,"_170":-5,"_271":278,"_17":279},{"_33":172,"_13":173,"_62":174,"_43":-5,"_35":36,"_162":175,"_164":76,"_37":274,"_39":177,"_64":167,"_168":178,"_65":24,"_170":-5,"_271":275,"_17":276},{"_33":159,"_13":160,"_62":161,"_43":-5,"_35":36,"_162":163,"_164":76,"_37":270,"_39":166,"_64":167,"_168":169,"_65":24,"_170":-5,"_271":272,"_17":273},["D",1773703785452],"children",[],[160],["D",1772587312058],[],[173],["D",1775338887529],[],[181],["D",1771726668666],[],[189],["D",1772577677006],[],[198],["D",1775340280550],[],[205],["D",1772577676981],[],[212],["D",1772577677068],[],[219],"298bf716-17f6-11f1-bcc2-42dde27851f2","vector.test.ts","7336a2c8-1768-11f1-8448-42dde27851f2",472,["D",1772648145121],3,"// Tests for vector (F32_BLOB) column support:\n// • Object-form schema { type: \"vector\", dimensions: N } → stored as F32_BLOB(N)\n// • String-form schema \"F32_BLOB(N)\" passed verbatim\n// • insertRow() accepting a JS number array for vector columns\n// • batchInsert() / batchUpsert() with vector columns\n// • Error thrown when `dimensions` is missing from an object-form vector column\n//\n// Uses _testVectorTable (object-form) and _testVectorTableStr (string-form),\n// both created fresh in setup().\n\nimport { SQLiteTable } from \"../main.tsx\";\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testVectorTable, _testVectorTableStr } from \"./fixtures.ts\";\n\nexport const vectorTests = [\n\n async function vectorTableExists() {\n // The object-form vector table should have been created by setup().\n const result = await _testVectorTable.exists();\n assert(!!result, \"vector table should exist after create()\");\n },\n\n async function vectorColumnDefinedAsBlob() {\n // { type: \"vector\", dimensions: 3 } should be stored as F32_BLOB(3) in SQLite.\n const info = await _testVectorTable.getInfo();\n const embeddingCol = info.columns.find((c: any) => c.name === \"embedding\");\n assert(embeddingCol !== undefined, \"embedding column should exist\");\n assert(\n embeddingCol.type.toUpperCase().startsWith(\"F32_BLOB\"),\n `embedding column type should be F32_BLOB, got ${embeddingCol.type}`,\n );\n },\n\n async function insertRowWithVector() {\n // insertRow() should accept a JS array for a vector column and persist it.\n await _testVectorTable.insertRow({ id: 1, label: \"a\", embedding: [0.1, 0.2, 0.3] });\n const count = await _testVectorTable.countRows();\n assertEqual(count, 1, \"vector table should have 1 row after insert\");\n },\n\n async function insertRowVectorRowRetrievable() {\n // The inserted vector row should be retrievable by a non-vector condition.\n const count = await _testVectorTable.countRows({ id: 1 });\n assertEqual(count, 1, \"inserted vector row should be retrievable by id\");\n },\n\n async function insertRowMissingDimensionsThrows() {\n // Defining a vector column without `dimensions` is invalid; create() should\n // throw before making any database call.\n const badTable = new SQLiteTable(\n \"_badVectorTable\",\n { embedding: { type: \"vector\" } },\n { scope: \"val\" },\n );\n let threw = false;\n try {\n await badTable.create();\n } catch (_err) {\n threw = true;\n }\n assert(threw, \"vector column without dimensions should throw on create()\");\n },\n\n async function stringFormVectorInsert() {\n // A column defined as the raw string \"F32_BLOB(3)\" should also accept a\n // JS array on insert, just like the object-form equivalent.\n await _testVectorTableStr.insertRow({ id: 1, label: \"b\", embedding: [1.0, 2.0, 3.0] });\n const count = await _testVectorTableStr.countRows();\n assertEqual(count, 1, \"string-form vector table should have 1 row after insert\");\n },\n\n async function addVectorIndex() {\n // addVectorIndex() should create an index named __vidx.\n await _testVectorTable.addVectorIndex(\"embedding\");\n const indices = await _testVectorTable.getIndices();\n const found = indices.some((i: any) => i.name === \"_testVectorTable_embedding_vidx\");\n assert(found, \"vector index should appear in getIndices() with auto-generated name\");\n },\n\n async function vectorSearchFullScan() {\n // Seed two more rows so we have a meaningful nearest-neighbour result.\n // After prior tests, id=1 ([0.1, 0.2, 0.3]) already exists.\n await _testVectorTable.insertRow({ id: 2, label: \"close\", embedding: [1.0, 0.0, 0.0] });\n await _testVectorTable.insertRow({ id: 3, label: \"far\", embedding: [0.0, 0.0, 1.0] });\n\n // Query close to [1, 0, 0] — id=2 should be the nearest neighbour.\n const results = await _testVectorTable.vectorSearch({\n queryVector: [1.0, 0.1, 0.0],\n column: \"embedding\",\n limit: 3,\n forceFullScan: true,\n });\n\n assert(Array.isArray(results) && results.length > 0, \"vectorSearch should return results\");\n assert(\"distance\" in results[0], \"results should include a distance field\");\n assertEqual(results[0].id, 2, \"nearest neighbour should be id=2\");\n },\n\n async function vectorSearchUsesIndex() {\n // With the index created in addVectorIndex(), vectorSearch() should use ANN\n // (vector_top_k) automatically. We verify it returns results without error\n // and that the closest row is still id=2.\n const results = await _testVectorTable.vectorSearch({\n queryVector: [1.0, 0.1, 0.0],\n column: \"embedding\",\n limit: 3,\n });\n\n assert(Array.isArray(results) && results.length > 0, \"indexed vectorSearch should return results\");\n assertEqual(results[0].id, 2, \"indexed search: nearest neighbour should be id=2\");\n },\n\n async function batchInsertWithVectors() {\n // batchInsert() should wrap vector fields with vector() just like insertRow().\n // Table has ids 1-3 after prior tests; add ids 4 and 5.\n const before = await _testVectorTable.countRows();\n await _testVectorTable.batchInsert([\n { id: 4, label: \"d\", embedding: [0.5, 0.5, 0.0] },\n { id: 5, label: \"e\", embedding: [0.0, 0.5, 0.5] },\n ]);\n const after = await _testVectorTable.countRows();\n assertEqual(after, before + 2, \"batchInsert should add 2 vector rows\");\n },\n\n async function batchUpsertWithVectors() {\n // batchUpsert() should handle vector fields on both insert and update paths.\n // Update existing id=5 with a new vector, and insert new id=6.\n const before = await _testVectorTable.countRows();\n await _testVectorTable.batchUpsert([\n { id: 5, label: \"e-updated\", embedding: [0.1, 0.9, 0.0] },\n { id: 6, label: \"f\", embedding: [0.0, 0.1, 0.9] },\n ], \"id\");\n const after = await _testVectorTable.countRows();\n assertEqual(after, before + 1, \"batchUpsert should add 1 new row and update 1 existing\");\n const count5 = await _testVectorTable.countRows({ id: 5 });\n assertEqual(count5, 1, \"batchUpsert should not duplicate the updated row\");\n },\n];\n",[],[226,296],"63f28340-1768-11f1-ae72-42dde27851f2","string-schema.test.ts","63f2844e-1768-11f1-ae72-42dde27851f2",443,["D",1772587254600],"// Tests for string-form column definitions — schemas where each column value\n// is a raw SQL fragment string (e.g. \"integer primary key\", \"text not null\")\n// rather than a structured object.\n//\n// Verifies that constraint keywords embedded in the string (NOT NULL, PRIMARY KEY)\n// are honoured by the underlying SQLite engine.\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testTableStr } from \"./fixtures.ts\";\n\nexport const stringSchemaTests = [\n\n async function stringSchemaTableExists() {\n // The string-schema table should have been created successfully in setup().\n const result = await _testTableStr.exists();\n assert(!!result, \"string-schema table should exist after create()\");\n },\n\n async function stringSchemaCorrectColumns() {\n // getInfo() should report all three columns defined in the string schema.\n const info = await _testTableStr.getInfo();\n const colNames = info.columns.map((c: any) => c.name);\n assert(colNames.includes(\"id\"), \"string-schema table should have 'id' column\");\n assert(colNames.includes(\"label\"), \"string-schema table should have 'label' column\");\n assert(colNames.includes(\"value\"), \"string-schema table should have 'value' column\");\n },\n\n async function stringSchemaInsertAndGetRow() {\n // Basic insert + round-trip read to confirm the table functions normally.\n await _testTableStr.insertRow({ id: 1, label: \"alpha\", value: 1.5 });\n const row = await _testTableStr.getRow({ id: 1 }, { json: true });\n assertEqual(row, { id: 1, label: \"alpha\", value: 1.5 }, \"string-schema row mismatch\");\n },\n\n async function stringSchemaNotNullEnforced() {\n // 'label' is declared as \"text not null\"; omitting it should cause SQLite\n // to throw a constraint violation.\n let threw = false;\n try {\n await _testTableStr.insertRow({ id: 2, value: 3.14 });\n } catch (_err) {\n threw = true;\n }\n assert(threw, \"inserting a row without a NOT NULL column should throw\");\n },\n\n async function stringSchemaPrimaryKeyEnforced() {\n // 'id' is the primary key; a duplicate value should be rejected.\n let threw = false;\n try {\n await _testTableStr.insertRow({ id: 1, label: \"duplicate\", value: 0 });\n } catch (_err) {\n threw = true;\n }\n assert(threw, \"string-schema: duplicate primary key should throw\");\n },\n];\n",[],[226,305],"5941cb40-1768-11f1-8ee1-42dde27851f2","streaming.test.ts","5941cc12-1768-11f1-8ee1-42dde27851f2",442,["D",1772587236664],"// Tests for streamRowBatches() — the paginated async row-streaming method.\n// • Basic stream: total rows delivered across all batches equals countRows().\n// • stopAt option: limits the number of batches processed.\n\nimport { assertEqual } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const streamingTests = [\n\n async function streamRowBatches() {\n // The callback should receive every row in the table across one or more\n // batches; the cumulative count must match countRows().\n const batches: any[][] = [];\n await _testTable.streamRowBatches((rows: any[]) => {\n batches.push(rows);\n });\n const totalStreamed = batches.reduce((sum, b) => sum + b.length, 0);\n const count = await _testTable.countRows();\n assertEqual(totalStreamed, count, \"streamed row count should match total rows\");\n },\n\n async function streamRowBatchesStopAt() {\n // With batchSize=1000 and only a handful of rows the table fits in one\n // batch. stopAt:1 should therefore process exactly that one batch without\n // throwing or hanging.\n await _testTable.streamRowBatches(\n (_rows: any[]) => {},\n { stopAt: 1 },\n );\n // No error thrown = pass.\n },\n];\n",[],[226,313],"504709e2-1768-11f1-9cdf-42dde27851f2","schema.test.ts","50470b54-1768-11f1-9cdf-42dde27851f2",441,["D",1772587221594],"// Tests for schema-mutation methods on an existing table:\n// • addColumn — ALTER TABLE … ADD COLUMN\n// • removeColumn — ALTER TABLE … DROP COLUMN (requires SQLite 3.35+)\n//\n// These run after the query-options suite. The table has 5 rows at this point;\n// the tests do not change the row data, only the column structure.\n\nimport { assert } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const schemaTests = [\n\n async function addColumn() {\n // Adding a new column should make it visible in getInfo().columns.\n await _testTable.addColumn(\"tag\", { type: \"text\" });\n const info = await _testTable.getInfo();\n const colNames = info.columns.map((c: any) => c.name);\n assert(colNames.includes(\"tag\"), \"new 'tag' column should appear in getInfo\");\n },\n\n async function removeColumn() {\n // Dropping a column should remove it from getInfo().columns.\n await _testTable.removeColumn(\"tag\");\n const info = await _testTable.getInfo();\n const colNames = info.columns.map((c: any) => c.name);\n assert(!colNames.includes(\"tag\"), \"'tag' column should be gone after removeColumn\");\n },\n];\n",[],[226,321],"2dda5402-306f-11f1-a211-42dde27851f2","raw-query.test.ts","c79f492c-18ef-11f1-a6af-42dde27851f2",505,["D",1775338949381],"// Tests for rawQuery() — direct SQL execution that enables cross-table joins,\n// aggregations, CTEs, UNIONs, and any other SQL that single-table methods\n// cannot express.\n//\n// These tests use their own dedicated tables (_rawQueryUsers, _rawQueryPosts)\n// and are independent of the cumulative _testTable state in other suites.\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _rawQueryUsers, _rawQueryPosts } from \"./fixtures.ts\";\n\nexport const rawQueryTests = [\n\n // ── Seed data ────────────────────────────────────────────────────────────\n\n async function rawQuerySeedData() {\n // Alice has 2 posts, Bob has 1, Charlie has none — intentional for join tests.\n await _rawQueryUsers.batchInsert([\n { id: 1, name: \"Alice\", score: 90 },\n { id: 2, name: \"Bob\", score: 50 },\n { id: 3, name: \"Charlie\", score: 70 },\n ]);\n await _rawQueryPosts.batchInsert([\n { id: 1, user_id: 1, title: \"Hello\" },\n { id: 2, user_id: 1, title: \"World\" },\n { id: 3, user_id: 2, title: \"Foo\" },\n ]);\n const userCount = await _rawQueryUsers.countRows();\n assertEqual(userCount, 3, \"seed: expected 3 users\");\n const postCount = await _rawQueryPosts.countRows();\n assertEqual(postCount, 3, \"seed: expected 3 posts\");\n },\n\n // ── Single-table SQL ─────────────────────────────────────────────────────\n\n async function rawQueryBasicSelect() {\n // rawQuery() should work for plain single-table SQL with a WHERE clause.\n const rows = await _rawQueryUsers.rawQuery(\n `SELECT * FROM _rawQueryUsers WHERE score > 60`,\n );\n // Alice (90) and Charlie (70) qualify; Bob (50) does not.\n assert(rows.length === 2, `expected 2 rows, got ${rows.length}`);\n const names = rows.map((r: any) => r.name).sort();\n assertEqual(names, [\"Alice\", \"Charlie\"], \"only high-scorers should be returned\");\n },\n\n async function rawQueryAggregation() {\n // COUNT and AVG should work across the table.\n const rows = await _rawQueryUsers.rawQuery(\n `SELECT COUNT(*) AS total, AVG(score) AS avg_score FROM _rawQueryUsers`,\n );\n assertEqual(rows[0].total, 3, \"total should be 3\");\n // (90 + 50 + 70) / 3 = 70\n assertEqual(rows[0].avg_score, 70, \"avg_score should be 70\");\n },\n\n async function rawQueryEmptyResult() {\n // A query matching nothing should return an empty array, not undefined or null.\n const rows = await _rawQueryUsers.rawQuery(\n `SELECT * FROM _rawQueryUsers WHERE id = 9999`,\n );\n assertEqual(rows, [], \"no-match query should return []\");\n },\n\n // ── Cross-table joins ────────────────────────────────────────────────────\n\n async function rawQueryInnerJoin() {\n // INNER JOIN returns only rows present in both tables.\n // Charlie has no posts so he should be excluded.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT _rawQueryUsers.name, _rawQueryPosts.title\n FROM _rawQueryUsers\n JOIN _rawQueryPosts ON _rawQueryUsers.id = _rawQueryPosts.user_id\n ORDER BY _rawQueryPosts.id\n `);\n assert(rows.length === 3, `INNER JOIN should return 3 rows, got ${rows.length}`);\n assertEqual(rows[0].name, \"Alice\", \"first joined row should be Alice\");\n assertEqual(rows[0].title, \"Hello\", \"first joined row should be 'Hello'\");\n const hasCharlie = rows.some((r: any) => r.name === \"Charlie\");\n assert(!hasCharlie, \"Charlie (no posts) should be excluded from INNER JOIN\");\n },\n\n async function rawQueryLeftJoin() {\n // LEFT JOIN includes all users, with null title where there is no matching post.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT _rawQueryUsers.name, _rawQueryPosts.title\n FROM _rawQueryUsers\n LEFT JOIN _rawQueryPosts ON _rawQueryUsers.id = _rawQueryPosts.user_id\n ORDER BY _rawQueryUsers.id, _rawQueryPosts.id\n `);\n // Alice×2 + Bob×1 + Charlie×1 (null) = 4 rows\n assert(rows.length === 4, `LEFT JOIN should return 4 rows, got ${rows.length}`);\n const charlie = rows.find((r: any) => r.name === \"Charlie\");\n assert(charlie !== undefined, \"Charlie should appear in LEFT JOIN result\");\n assertEqual(charlie.title, null, \"Charlie should have null title (no posts)\");\n },\n\n // ── Aggregation across tables ─────────────────────────────────────────────\n\n async function rawQueryGroupBy() {\n // Per-user post count via GROUP BY.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT _rawQueryUsers.name, COUNT(_rawQueryPosts.id) AS post_count\n FROM _rawQueryUsers\n LEFT JOIN _rawQueryPosts ON _rawQueryUsers.id = _rawQueryPosts.user_id\n GROUP BY _rawQueryUsers.id\n ORDER BY post_count DESC, _rawQueryUsers.name ASC\n `);\n assertEqual(rows.length, 3, \"GROUP BY should return one row per user\");\n assertEqual(rows[0].name, \"Alice\", \"Alice should have the most posts\");\n assertEqual(rows[0].post_count, 2, \"Alice should have 2 posts\");\n assertEqual(rows[2].post_count, 0, \"Charlie should have 0 posts\");\n },\n\n // ── CTEs ─────────────────────────────────────────────────────────────────\n\n async function rawQueryCTE() {\n // WITH (CTE) lets you name a subquery and reference it in the main query.\n const rows = await _rawQueryUsers.rawQuery(`\n WITH high_scorers AS (\n SELECT id, name FROM _rawQueryUsers WHERE score >= 70\n )\n SELECT high_scorers.name, _rawQueryPosts.title\n FROM high_scorers\n LEFT JOIN _rawQueryPosts ON high_scorers.id = _rawQueryPosts.user_id\n ORDER BY high_scorers.name, _rawQueryPosts.id\n `);\n // Alice (90, 2 posts) + Charlie (70, 0 posts) = 3 rows; Bob excluded\n assert(rows.length === 3, `CTE should return 3 rows, got ${rows.length}`);\n const names = rows.map((r: any) => r.name);\n assert(names.includes(\"Alice\"), \"Alice should be in CTE result\");\n assert(names.includes(\"Charlie\"), \"Charlie should be in CTE result\");\n assert(!names.includes(\"Bob\"), \"Bob (score 50) should be excluded by CTE filter\");\n },\n\n // ── {{thisTable}} interpolation ──────────────────────────────────────────\n\n async function rawQueryThisTableBasic() {\n // {{thisTable}} should be replaced with the instance's table name.\n const rows = await _rawQueryUsers.rawQuery(\n `SELECT * FROM {{thisTable}} WHERE score > 60`,\n );\n assert(rows.length === 2, `expected 2 rows, got ${rows.length}`);\n const names = rows.map((r: any) => r.name).sort();\n assertEqual(names, [\"Alice\", \"Charlie\"], \"{{thisTable}} basic select\");\n },\n\n async function rawQueryThisTableMultipleOccurrences() {\n // Multiple {{thisTable}} tokens in a single query should all be replaced.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT a.name\n FROM {{thisTable}} a\n JOIN {{thisTable}} b ON a.id = b.id\n WHERE a.score > 60\n `);\n assert(rows.length === 2, `expected 2 rows, got ${rows.length}`);\n },\n\n async function rawQueryThisTableCrossTable() {\n // {{thisTable}} should resolve to the calling instance's table even in\n // cross-table queries that also reference other tables by name.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT {{thisTable}}.name, _rawQueryPosts.title\n FROM {{thisTable}}\n JOIN _rawQueryPosts ON {{thisTable}}.id = _rawQueryPosts.user_id\n ORDER BY _rawQueryPosts.id\n `);\n assert(rows.length === 3, `expected 3 rows, got ${rows.length}`);\n assertEqual(rows[0].name, \"Alice\", \"first row should be Alice\");\n },\n\n // ── UNION ─────────────────────────────────────────────────────────────────\n\n async function rawQueryUnion() {\n // UNION stacks results from two SELECT statements with matching column shapes.\n const rows = await _rawQueryUsers.rawQuery(`\n SELECT name AS label, 'user' AS kind FROM _rawQueryUsers\n UNION ALL\n SELECT title AS label, 'post' AS kind FROM _rawQueryPosts\n ORDER BY kind, label\n `);\n // 3 users + 3 posts = 6 total\n assertEqual(rows.length, 6, \"UNION ALL should return 6 rows\");\n const kinds = new Set(rows.map((r: any) => r.kind));\n assert(kinds.has(\"user\") && kinds.has(\"post\"), \"result should include both kinds\");\n },\n];\n",[],[226,329],"47c0ba52-1768-11f1-8d8b-42dde27851f2","query-options.test.ts","47c0bb1a-1768-11f1-8d8b-42dde27851f2",440,["D",1772587207297],"// Tests for SelectOutputOptions passed to getRow() and getRows():\n// • No condition (return any row / all rows)\n// • Column projection via the `columns` option\n// • Ordering via `ascendBy` / `descendBy`\n// • Row cap via `limit`\n// • Combining options (columns + ordering, condition + ordering, etc.)\n// • Edge case: empty table returns [] / empty ResultSet\n//\n// NOTE: At entry the table may contain rows with null scores from the\n// conditions suite. getRowsEmptyTable() clears and re-seeds a clean set of\n// five rows that subsequent tests in this file rely on.\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const queryOptionTests = [\n\n // ── getRow options ────────────────────────────────────────────────────────\n\n async function getRowNoCondition() {\n // Omitting a condition should return the first available row, not throw.\n const row = await _testTable.getRow(undefined, { json: true });\n assert(row !== undefined, \"getRow with no condition should return a row\");\n assert(\"id\" in row, \"returned row should have an 'id' field\");\n },\n\n async function getRowColumns() {\n // The `columns` option should limit which fields appear in the result.\n const row = await _testTable.getRow({ id: 1 }, {\n json: true,\n columns: [\"id\", \"name\"],\n });\n assert(row !== undefined, \"getRow with columns should return a row\");\n assert(\"id\" in row, \"row should have 'id'\");\n assert(\"name\" in row, \"row should have 'name'\");\n assert(!(\"score\" in row), \"row should not have 'score' when excluded via columns\");\n },\n\n // ── getRows edge cases ────────────────────────────────────────────────────\n\n async function getRowsEmptyTable() {\n // JSON output on an empty table should be an empty array.\n // Raw output should have a rows array of length 0.\n await _testTable.deleteRows();\n const rows = await _testTable.getRows(undefined, { json: true });\n assertEqual(rows, [], \"getRows on empty table should return []\");\n const raw = await _testTable.getRows();\n assert(raw.rows.length === 0, \"raw getRows on empty table should have 0 rows\");\n\n // Re-seed five rows for the remaining tests in this file.\n await _testTable.insertRow({ id: 1, name: \"Alice\", score: 42 });\n await _testTable.insertRow({ id: 2, name: \"Bob\", score: 99 });\n await _testTable.insertRow({ id: 3, name: \"Charlie\", score: 7 });\n await _testTable.insertRow({ id: 4, name: \"Dave\", score: 55 });\n await _testTable.insertRow({ id: 5, name: \"Eve\", score: 60 });\n },\n\n // ── limit ─────────────────────────────────────────────────────────────────\n\n async function getRowsLimitOnly() {\n // `limit` should cap the number of returned rows regardless of ordering.\n const rows = await _testTable.getRows(undefined, { json: true, limit: 2 });\n assertEqual(rows.length, 2, \"limit alone should cap results to 2 rows\");\n },\n\n // ── columns + ordering ────────────────────────────────────────────────────\n\n async function getRowsColumnsWithOrdering() {\n // Combining `columns` and `ascendBy` should both filter fields and sort.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n ascendBy: \"score\",\n columns: [\"id\", \"score\"],\n });\n assert(rows.length > 1, \"should return multiple rows\");\n assert(!(\"name\" in rows[0]), \"name should be excluded via columns\");\n assert(\"score\" in rows[0], \"score should be present\");\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score >= rows[i - 1].score,\n \"rows should be in ascending order by score\",\n );\n }\n },\n\n // ── freeform condition + ordering ─────────────────────────────────────────\n\n async function getRowsFreeformConditionWithOrdering() {\n // A raw SQL condition string and `descendBy` should compose correctly.\n const rows = await _testTable.getRows(\"score > 10\", {\n json: true,\n descendBy: \"score\",\n });\n assert(\n rows.every((r: any) => r.score > 10),\n \"all rows should satisfy score > 10\",\n );\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score <= rows[i - 1].score,\n \"rows should be in descending order by score\",\n );\n }\n },\n\n // ── ascendBy ─────────────────────────────────────────────────────────────\n\n async function getRowsAscendBy() {\n // `ascendBy` should return all rows sorted lowest → highest.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n ascendBy: \"score\",\n });\n assert(Array.isArray(rows) && rows.length > 1, \"ascendBy should return multiple rows\");\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score >= rows[i - 1].score,\n `row ${i} score (${rows[i].score}) should be >= row ${i - 1} score (${rows[i - 1].score})`,\n );\n }\n },\n\n // ── descendBy ────────────────────────────────────────────────────────────\n\n async function getRowsDescendBy() {\n // `descendBy` should return all rows sorted highest → lowest.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n descendBy: \"score\",\n });\n assert(Array.isArray(rows) && rows.length > 1, \"descendBy should return multiple rows\");\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score <= rows[i - 1].score,\n `row ${i} score (${rows[i].score}) should be <= row ${i - 1} score (${rows[i - 1].score})`,\n );\n }\n },\n\n // ── ascendBy + limit ──────────────────────────────────────────────────────\n\n async function getRowsAscendByWithLimit() {\n // `ascendBy` combined with `limit` should return the N lowest-scored rows.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n ascendBy: \"score\",\n limit: 2,\n });\n assertEqual(rows.length, 2, \"ascendBy with limit 2 should return 2 rows\");\n assert(rows[0].score <= rows[1].score, \"rows should be in ascending order\");\n },\n\n // ── descendBy + condition ─────────────────────────────────────────────────\n\n async function getRowsDescendByWithCondition() {\n // An operator condition and `descendBy` should both be applied together.\n const rows = await _testTable.getRows(\n { score: { greaterThan: 10 } },\n { json: true, descendBy: \"score\" },\n );\n assert(\n rows.every((r: any) => r.score > 10),\n \"all rows should satisfy score > 10\",\n );\n for (let i = 1; i < rows.length; i++) {\n assert(\n rows[i].score <= rows[i - 1].score,\n \"rows should be in descending order by score\",\n );\n }\n },\n];\n",[],[226,337],"ddb4331c-18ef-11f1-97dd-42dde27851f2","index.ts","7d78c176-1768-11f1-b41e-42dde27851f2",487,["D",1772755392087],"// Test runner — imports every suite and runs them in the correct sequential\n// order, then prints a summary.\n//\n// Suite execution order matters: the _testTable tests build cumulative state\n// across files (crud → conditions → query-options → schema → streaming).\n// String-schema and vector tests use their own tables and are independent.\n\nimport { runTest, TestResult } from \"./helpers.ts\";\nimport { setup, teardown } from \"./fixtures.ts\";\nimport { crudTests } from \"./crud.test.ts\";\nimport { conditionTests } from \"./conditions.test.ts\";\nimport { queryOptionTests } from \"./query-options.test.ts\";\nimport { schemaTests } from \"./schema.test.ts\";\nimport { streamingTests } from \"./streaming.test.ts\";\nimport { stringSchemaTests } from \"./string-schema.test.ts\";\nimport { vectorTests } from \"./vector.test.ts\";\nimport { rawQueryTests } from \"./raw-query.test.ts\";\n\nconst allTests = [\n // Core CRUD, raw output, index management — sequential state on _testTable\n ...crudTests,\n // WHERE clause condition operators and forms\n ...conditionTests,\n // getRow / getRows output options (ordering, limit, columns)\n ...queryOptionTests,\n // Schema mutation: addColumn / removeColumn\n ...schemaTests,\n // Paginated streaming via streamRowBatches()\n ...streamingTests,\n // String-form column definition schema (_testTableStr)\n ...stringSchemaTests,\n // Vector (F32_BLOB) column support (_testVectorTable, _testVectorTableStr)\n ...vectorTests,\n // rawQuery() — cross-table joins, aggregations, CTEs, UNIONs\n ...rawQueryTests,\n];\n\nexport async function runAllTests(): Promise {\n await setup();\n const results: TestResult[] = [];\n\n for (const test of allTests) {\n results.push(await runTest(test.name, test));\n }\n\n await teardown();\n\n const passed = results.filter((r) => r.passed).length;\n const failed = results.filter((r) => !r.passed);\n\n console.log(`\\n=== Test Results: ${passed}/${results.length} passed ===\\n`);\n for (const r of results) {\n const icon = r.passed ? \"✅\" : \"❌\";\n console.log(`${icon} ${r.name}`);\n }\n\n if (failed.length > 0) {\n console.log(`\\n=== ${failed.length} test(s) failed ===\\n`);\n for (const r of failed) {\n console.log(`❌ ${r.name}\\n ${r.error}\\n`);\n }\n throw new Error(`${failed.length} test(s) failed`);\n }\n}\n",[],[226,345],"01fac97c-1768-11f1-aed8-42dde27851f2","helpers.ts","01faca1c-1768-11f1-aed8-42dde27851f2",436,["D",1772587090234],"// Shared test utilities used by all test suites.\n\nexport type TestResult = { name: string; passed: boolean; error?: string };\n\n/** Throws if condition is false. */\nexport function assert(condition: boolean, message: string) {\n if (!condition) throw new Error(`Assertion failed: ${message}`);\n}\n\n/** Deep-equality check via JSON serialization; throws with a diff on mismatch. */\nexport function assertEqual(actual: any, expected: any, message: string) {\n const a = JSON.stringify(actual);\n const e = JSON.stringify(expected);\n if (a !== e) {\n throw new Error(`${message}\\n expected: ${e}\\n actual: ${a}`);\n }\n}\n\n/** Runs a single test function, catching errors and returning a result object. */\nexport async function runTest(\n name: string,\n fn: () => Promise,\n): Promise {\n try {\n await fn();\n return { name, passed: true };\n } catch (err) {\n return { name, passed: false, error: String(err) };\n }\n}\n",[],[226,353],"64604bfe-18ef-11f1-8622-42dde27851f2","fixtures.ts","0b1d38e6-1768-11f1-9138-42dde27851f2",485,["D",1772755188536],2,"// Shared table instances and setup / teardown logic used by all test suites.\n// Each table exercises a distinct part of the schema API.\n\nimport { SQLiteTable } from \"../main.tsx\";\n\n// Primary test table — object-form schema with integer PK, text, and numeric columns.\nexport const _testTable = new SQLiteTable(\n \"_testTable\",\n {\n id: { type: \"integer\", primaryKey: true },\n name: { type: \"text\" },\n score: { type: \"number\" },\n },\n { scope: \"val\" },\n);\n\n// Table defined with string-form column definitions (raw SQL fragments).\nexport const _testTableStr = new SQLiteTable(\n \"_testTableStr\",\n {\n id: \"integer primary key\",\n label: \"text not null\",\n value: \"real\",\n },\n { scope: \"val\" },\n);\n\n// Table with an object-form vector (F32_BLOB) column.\nexport const _testVectorTable = new SQLiteTable(\n \"_testVectorTable\",\n {\n id: { type: \"integer\", primaryKey: true },\n label: { type: \"text\" },\n embedding: { type: \"vector\", dimensions: 3 },\n },\n { scope: \"val\" },\n);\n\n// Tables used by rawQuery tests — a users/posts pair for join exercises.\nexport const _rawQueryUsers = new SQLiteTable(\n \"_rawQueryUsers\",\n {\n id: { type: \"integer\", primaryKey: true },\n name: { type: \"text\" },\n score: { type: \"number\" },\n },\n { scope: \"val\" },\n);\n\nexport const _rawQueryPosts = new SQLiteTable(\n \"_rawQueryPosts\",\n {\n id: { type: \"integer\", primaryKey: true },\n user_id: { type: \"integer\" },\n title: { type: \"text\" },\n },\n { scope: \"val\" },\n);\n\n// Table with a string-form vector column (\"F32_BLOB(3)\").\nexport const _testVectorTableStr = new SQLiteTable(\n \"_testVectorTableStr\",\n {\n id: { type: \"integer\", primaryKey: true },\n label: { type: \"text\" },\n embedding: \"F32_BLOB(3)\",\n },\n { scope: \"val\" },\n);\n\n/** Drop any leftover tables from a previous failed run, then (re-)create them. */\nexport async function setup() {\n if (await _testTable.exists()) await _testTable.drop();\n await _testTable.create();\n\n if (await _testTableStr.exists()) await _testTableStr.drop();\n await _testTableStr.create();\n\n if (await _testVectorTable.exists()) await _testVectorTable.drop();\n await _testVectorTable.create();\n\n if (await _testVectorTableStr.exists()) await _testVectorTableStr.drop();\n await _testVectorTableStr.create();\n\n if (await _rawQueryUsers.exists()) await _rawQueryUsers.drop();\n await _rawQueryUsers.create();\n\n if (await _rawQueryPosts.exists()) await _rawQueryPosts.drop();\n await _rawQueryPosts.create();\n}\n\n/** Drop all test tables after a run. */\nexport async function teardown() {\n if (await _testTable.exists()) await _testTable.drop();\n if (await _testTableStr.exists()) await _testTableStr.drop();\n if (await _testVectorTable.exists()) await _testVectorTable.drop();\n if (await _testVectorTableStr.exists()) await _testVectorTableStr.drop();\n if (await _rawQueryUsers.exists()) await _rawQueryUsers.drop();\n if (await _rawQueryPosts.exists()) await _rawQueryPosts.drop();\n}\n",[],[226,361],"2287db4e-1768-11f1-9cdf-42dde27851f2","crud.test.ts","2287dc02-1768-11f1-9cdf-42dde27851f2",438,["D",1772587144846],"// Tests for core CRUD operations on the primary test table:\n// insertRow, getRow, getRows, countRows, updateRow, batchInsert, batchUpsert,\n// deleteRows, getInfo, addIndex / getIndices, and raw (non-JSON) output.\n//\n// NOTE: These tests run sequentially and share cumulative table state — each\n// test assumes the rows left by the previous ones are still present.\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const crudTests = [\n\n // ── Table lifecycle ──────────────────────────────────────────────────────\n\n async function tableExists() {\n // create() should have been called in setup(); verify the table is live.\n const result = await _testTable.exists();\n assert(!!result, \"table should exist after create()\");\n },\n\n // ── Single-row insert & retrieval ────────────────────────────────────────\n\n async function insertAndGetRow() {\n // Insert one row and round-trip it through getRow with JSON output.\n await _testTable.insertRow({ id: 1, name: \"Alice\", score: 42 });\n const row = await _testTable.getRow({ id: 1 }, { json: true });\n assertEqual(row, { id: 1, name: \"Alice\", score: 42 }, \"inserted row mismatch\");\n },\n\n // ── Multi-row read ───────────────────────────────────────────────────────\n\n async function getRows() {\n // Add two more rows; total should be 3.\n await _testTable.insertRow({ id: 2, name: \"Bob\", score: 99 });\n await _testTable.insertRow({ id: 3, name: \"Charlie\", score: 7 });\n const rows = await _testTable.getRows(undefined, { json: true });\n assert(rows.length === 3, `expected 3 rows, got ${rows.length}`);\n },\n\n // ── Row count ────────────────────────────────────────────────────────────\n\n async function countRows() {\n // Confirm the unconditional count matches the number of inserts so far.\n const count = await _testTable.countRows();\n assertEqual(count, 3, \"countRows should return 3\");\n },\n\n async function countRowsWithCondition() {\n // Alice(42) and Bob(99) both have score > 10; Charlie(7) does not.\n const count = await _testTable.countRows({ score: { greaterThan: 10 } });\n assertEqual(count, 2, \"rows with score > 10 should be 2\");\n },\n\n // ── Update ───────────────────────────────────────────────────────────────\n\n async function updateRow() {\n // Update a single column on an existing row and verify the change.\n await _testTable.updateRow({ id: 1 }, { score: 100 });\n const row = await _testTable.getRow({ id: 1 }, { json: true });\n assertEqual(row?.score, 100, \"score should be updated to 100\");\n },\n\n // ── Batch insert ─────────────────────────────────────────────────────────\n\n async function batchInsert() {\n // Insert multiple rows in a single call; total should grow to 5.\n await _testTable.batchInsert([\n { id: 4, name: \"Dave\", score: 55 },\n { id: 5, name: \"Eve\", score: 60 },\n ]);\n const count = await _testTable.countRows();\n assertEqual(count, 5, \"batchInsert: total rows should be 5\");\n },\n\n // ── Batch upsert ─────────────────────────────────────────────────────────\n\n async function batchUpsert() {\n // id=1 already exists → its score should be updated to 200.\n // id=6 is new → it should be inserted, bringing the total to 6.\n await _testTable.batchUpsert(\n [\n { id: 1, name: \"Alice\", score: 200 },\n { id: 6, name: \"Frank\", score: 11 },\n ],\n \"id\",\n );\n const alice = await _testTable.getRow({ id: 1 }, { json: true });\n assertEqual(alice?.score, 200, \"upserted alice score should be 200\");\n const count = await _testTable.countRows();\n assertEqual(count, 6, \"batchUpsert: total rows should be 6\");\n },\n\n // ── Table info ───────────────────────────────────────────────────────────\n\n async function getInfo() {\n // getInfo() should return column metadata and the current row count.\n const info = await _testTable.getInfo();\n assert(typeof info === \"object\" && info !== null, \"getInfo should return an object\");\n assert(Array.isArray(info.columns), \"getInfo.columns should be an array\");\n const names = info.columns.map((c: any) => c.name);\n assert(names.includes(\"id\"), \"getInfo should include 'id' column\");\n assert(names.includes(\"name\"), \"getInfo should include 'name' column\");\n assert(names.includes(\"score\"), \"getInfo should include 'score' column\");\n assert(typeof info.rowCount === \"number\", \"getInfo.rowCount should be a number\");\n },\n\n // ── Index management ─────────────────────────────────────────────────────\n\n async function addIndexAndGetIndices() {\n // Create a named index on 'score' and verify it appears in getIndices().\n await _testTable.addIndex({ name: \"_testTable_score_idx\", column: \"score\" });\n const indices = await _testTable.getIndices();\n assert(Array.isArray(indices), \"getIndices should return an array\");\n const found = indices.some((i: any) => i.name === \"_testTable_score_idx\");\n assert(found, \"created index should appear in getIndices()\");\n },\n\n // ── Column projection ────────────────────────────────────────────────────\n\n async function selectColumns() {\n // Passing a columns list should exclude unlisted columns from results.\n const rows = await _testTable.getRows(undefined, {\n json: true,\n columns: [\"id\", \"name\"],\n });\n assert(rows.length > 0, \"should return rows\");\n assert(!(\"score\" in rows[0]), \"score column should be excluded\");\n assert(\"name\" in rows[0], \"name column should be present\");\n },\n\n // ── Constraint enforcement ───────────────────────────────────────────────\n\n async function insertRowDuplicateKeyThrows() {\n // The integer primary key should reject a duplicate value.\n await _testTable.insertRow({ id: 99, name: \"Unique\", score: 1 });\n let threw = false;\n try {\n await _testTable.insertRow({ id: 99, name: \"Duplicate\", score: 2 });\n } catch (_err) {\n threw = true;\n }\n assert(threw, \"inserting a duplicate primary key should throw\");\n },\n\n // ── Delete ───────────────────────────────────────────────────────────────\n\n async function deleteRowsWithCondition() {\n // Conditional delete should remove exactly the matching rows.\n const before = await _testTable.countRows();\n await _testTable.deleteRows({ id: 6 });\n const after = await _testTable.countRows();\n assertEqual(after, before - 1, \"deleteRows should remove exactly 1 row\");\n const gone = await _testTable.getRow({ id: 6 }, { json: true });\n assertEqual(gone, undefined, \"deleted row should not be retrievable\");\n },\n\n async function deleteAllRows() {\n // Calling deleteRows() with no condition should truncate the table.\n await _testTable.deleteRows();\n const count = await _testTable.countRows();\n assertEqual(count, 0, \"deleteRows() with no condition should clear the table\");\n },\n\n // ── Raw (non-JSON) output ────────────────────────────────────────────────\n\n async function getRawRow() {\n // Without { json: true }, getRow() returns the raw sqlite row object.\n await _testTable.insertRow({ id: 1, name: \"Alice\", score: 42 });\n const row = await _testTable.getRow({ id: 1 });\n assert(row !== undefined, \"raw getRow should return a result\");\n assert(\"id\" in row, \"raw row should have 'id' key\");\n },\n\n async function getRawRows() {\n // Without { json: true }, getRows() returns the raw ResultSet object\n // with 'rows' and 'columns' properties rather than a plain array.\n const result = await _testTable.getRows();\n assert(result !== undefined, \"raw getRows should return a result\");\n assert(\"rows\" in result, \"raw getRows result should have a 'rows' property\");\n assert(\"columns\" in result, \"raw getRows result should have a 'columns' property\");\n },\n\n async function getRowMiss() {\n // getRow() should return undefined when no row matches the condition.\n const row = await _testTable.getRow({ id: 9999 }, { json: true });\n assertEqual(row, undefined, \"getRow with no match should return undefined\");\n },\n];\n",[],[226,370],"3321634e-1768-11f1-ade9-42dde27851f2","conditions.test.ts","3321643e-1768-11f1-ade9-42dde27851f2",439,["D",1772587172694],"// Tests for WHERE clause condition forms supported by RowSelectCondition:\n// • Comparison operators: greaterThan, atLeast, lessThan, atMost, notEqual\n// • Pattern matching: like\n// • Set membership: in (non-empty and empty array)\n// • Null equality: { column: null } → IS NULL\n// • Freeform SQL string passed directly as the condition\n//\n// NOTE: These tests run after crud.test.ts. At entry the table contains\n// exactly one row: { id:1, name:\"Alice\", score:42 }.\n// Additional rows are seeded inside the suite and left in place for subsequent\n// test files (query-options.test.ts expects the same five rows).\n\nimport { assert, assertEqual } from \"./helpers.ts\";\nimport { _testTable } from \"./fixtures.ts\";\n\nexport const conditionTests = [\n\n async function conditionOperators() {\n // Seed rows so we have a spread of score values to test operators against.\n await _testTable.insertRow({ id: 2, name: \"Bob\", score: 99 });\n await _testTable.insertRow({ id: 3, name: \"Charlie\", score: 7 });\n await _testTable.insertRow({ id: 4, name: \"Dave\", score: 55 });\n await _testTable.insertRow({ id: 5, name: \"Eve\", score: 60 });\n // Scores: Alice=42, Bob=99, Charlie=7, Dave=55, Eve=60\n\n // atLeast (>=) — Dave(55), Bob(99), Eve(60)\n const gte = await _testTable.countRows({ score: { atLeast: 55 } });\n assertEqual(gte, 3, \"atLeast 55: expected 3 rows\");\n\n // lessThan (<) — Alice(42), Charlie(7)\n const lt = await _testTable.countRows({ score: { lessThan: 55 } });\n assertEqual(lt, 2, \"lessThan 55: expected 2 rows\");\n\n // atMost (<=) — Alice(42), Charlie(7), Dave(55)\n const lte = await _testTable.countRows({ score: { atMost: 55 } });\n assertEqual(lte, 3, \"atMost 55: expected 3 rows\");\n\n // notEqual (!=) — everyone except Alice(42)\n const ne = await _testTable.countRows({ score: { notEqual: 42 } });\n assertEqual(ne, 4, \"notEqual 42: expected 4 rows\");\n\n // like — only Alice starts with 'A'\n const like = await _testTable.getRows({ name: { like: \"A%\" } }, { json: true });\n assertEqual(like.length, 1, \"LIKE 'A%': expected 1 row\");\n assertEqual(like[0].name, \"Alice\", \"LIKE 'A%': expected Alice\");\n\n // in — rows with id 1 or 3\n const inList = await _testTable.getRows({ id: { in: [1, 3] } }, { json: true });\n assertEqual(inList.length, 2, \"IN [1,3]: expected 2 rows\");\n\n // in with empty array — IN () is invalid SQL; the library should treat it\n // as an always-false condition and return 0 rows without erroring.\n const inEmpty = await _testTable.countRows({ id: { in: [] } });\n assertEqual(inEmpty, 0, \"IN []: expected 0 rows\");\n },\n\n async function conditionNullEquality() {\n // Passing null as a column value should generate IS NULL (not = NULL).\n await _testTable.insertRow({ id: 10, name: \"Null Score\" });\n const nullRows = await _testTable.getRows({ score: null }, { json: true });\n assertEqual(nullRows.length, 1, \"IS NULL: expected 1 row with null score\");\n assertEqual(nullRows[0].id, 10, \"IS NULL: expected row id=10\");\n },\n\n async function conditionStringFreeform() {\n // A raw SQL string can be passed as the condition instead of an object.\n const rows = await _testTable.getRows(\"score > 50\", { json: true });\n assert(rows.length > 0, \"freeform string condition should return results\");\n assert(\n rows.every((r: any) => r.score > 50),\n \"all rows should satisfy score > 50\",\n );\n },\n];\n",[],[226,378],["D",1772587090024],[251,252,253,254,255,256,257,258,259,260,261],[226],"2864de9c-18f1-11f1-8553-42dde27851f2","settings.local.json","d19c4150-1831-11f1-b04c-42dde27851f2",490,["D",1772755946899],4,"{\n \"permissions\": {\n \"allow\": [\n \"mcp__claude_ai_valtown__list_files\",\n \"mcp__claude_ai_valtown__read_file\",\n \"WebFetch(domain:turso.tech)\",\n \"mcp__claude_ai_valtown__list_vals\",\n \"mcp__claude_ai_valtown__run_file\"\n ]\n }\n}\n",[],[233,389],["D",1772673767310],[249],[233],["D",1746232377860],["D",1789519256886],{"_11":12,"_128":68},{"_11":12,"_124":-5,"_67":68,"_30":66,"_125":126,"_127":24},{"_39":115,"_13":16,"_33":36,"_116":78,"_117":-5,"_118":-5,"_119":-5,"_120":-5,"_121":-5,"_122":14,"_123":12},"ctx",{"_52":-5,"_146":438,"_439":440,"_441":442,"_443":24,"_444":24,"_445":24,"_446":76,"_447":-5,"_448":-7,"_449":-7,"_450":26,"_451":24,"_452":24,"_453":-5,"_454":24,"_455":24,"_456":24,"_457":-5},"ENV",{"_409":410,"_411":412,"_413":16,"_414":415,"_416":417,"_418":419,"_420":421,"_422":423,"_424":425,"_426":427,"_428":429,"_430":431,"_432":433,"_434":435,"_436":437},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

History · utils