Deploy generated Order console with request-tree TraceChain and reproducible runtime snapshot

README.md

@@ -7,25 +7,66 @@ sdk: static
 app_file: dist/index.html
 pinned: false
 license: apache-2.0
-short_description: TeaQL and SQLite, entirely in your browser.
+short_description: Typed queries and real TraceChain, entirely in your browser.
+tags:
+  - teaql
+  - sqlite
+  - webassembly
+  - typescript
 ---
 
 # TeaQL Browser SQLite Playground
 
-This playground runs entirely inside your browser:
+Edit a generated TypeScript Q query and inspect its data, facets and actual SQL
+execution evidence. SQLite/WASM runs in a browser worker; there is no application
+backend or server-side business database. Query data stays in your browser.
 
-- SQLite runs as WebAssembly in a dedicated Web Worker.
-- Generated TeaQL Q APIs execute against that browser-local database.
-- Demo records are created through audited generated mutation APIs.
-- Memory mode resets on refresh and gives every visitor the same starting point.
-- Optional OPFS mode persists data within the current browser origin when the host supports it.
-- Reset drops the local schema, recreates it, and seeds the demo again.
+The deterministic fixture contains four synthetic orders, twenty items and three
+statuses. The default query demonstrates filtered pagination, named totals,
+status COUNT/SUM facets, status details and three-item previews with full counts.
+Switch the example, edit the query, or restore the preset. Peggy parses a controlled
+query AST; it does not evaluate arbitrary JavaScript, imports or assignments.
 
-There is no application backend and no server-side business database. The
-Space only serves static HTML, JavaScript, CSS, and WASM assets. Query and
-mutation data remain in the visitor's browser.
+## Request TraceChain
 
-The complete source and executable browser smoke test are maintained in the
-[`teaql-ts` browser-sqlite example](https://github.com/teaql/teaql-ts/tree/main/examples/browser-sqlite).
+Each SQL record retains its root purpose, root comment, native Q-operation parents
+and nested business comments. The browser only renders runtime `traceChain`;
+physical `tracePath` remains separate. For example:
+
+```text
+render order list page: load order list → selectStatusWith(...) → load status
+render order list page: load order list → facetByStatusAs('statusCounts') → load status facets
+```
+
+The table displays `Time | Identity | Trace chain | SQL`. Time is recorded execution
+duration; Identity is the request entity, not an invented user or object ID. SQL is
+the runtime's parameter-filled diagnostic text, with its masking policy intact.
+An explicit execution observer retains evidence even when diagnostic logging is off.
+
+## Storage and reproducibility
+
+Memory is the default and resets on refresh. Audited generated mutation APIs seed
+the data; Reset recreates it. OPFS is enabled only when the hosting origin provides
+cross-origin isolation. When unavailable on Hugging Face, the option is disabled
+and memory mode remains fully usable.
+
+This demo uses a tested **unreleased request-tree runtime snapshot**, based on
+the [TeaQL TypeScript repository](https://github.com/teaql/teaql-ts). Its package
+version remains 0.3.0; this is not a claim that published npm 0.3.0 contains the new
+TraceChain design. Exact source, model, generated library, packaged runtime and
+hashes are retained in [source](https://huggingface.co/spaces/teaql/browser-sqlite-playground/tree/main/source).
+
+```bash
+hf download teaql/browser-sqlite-playground --repo-type space --include 'source/**' --local-dir teaql-demo
+cd teaql-demo/source/browser-sqlite
+npm ci
+npm run build
+npm run smoke
+npm run dev
+```
+
+The included browser test checks memory/OPFS, refresh/reset, logging modes, exact
+facets/counts/previews, real TraceChain rows, query presets and rejected constructor
+access. This first profile does not implement multi-tab coordination or true streaming.
 
 Learn more at [teaql.io](https://teaql.io/).

assets/index-DmPc8xp3.css

@@ -0,0 +1 @@
+:root{font:16px/1.5 Inter,system-ui,sans-serif;color:#e8edf5;background:#090b10}body{margin:0}main{width:min(760px,calc(100% - 40px));margin:10vh auto}.eyebrow{color:#d9ff52;font-size:12px;font-weight:800;letter-spacing:.16em}h1{margin:8px 0;font-size:clamp(36px,7vw,68px);letter-spacing:-.05em}.controls{display:flex;gap:18px;align-items:center;margin:32px 0}button{border:0;border-radius:5px;padding:10px 14px;background:#d9ff52;font-weight:800}#status{color:#aab4c4}pre{min-height:260px;padding:22px;overflow:auto;border:1px solid #2b323e;border-radius:8px;background:#11151c;color:#c6d1df}.evidence-scroll{overflow-x:auto;margin:24px 0}.evidence-table{border-collapse:collapse;width:100%;text-align:left}.evidence-table th,.evidence-table td{padding:12px;border:1px solid #2b323e;vertical-align:top}.evidence-table td{white-space:pre-wrap;overflow-wrap:anywhere;min-width:110px}.evidence-table td:last-child{min-width:320px;font-family:monospace}

dist/assets/index-DmPc8xp3.css

@@ -0,0 +1 @@
+:root{font:16px/1.5 Inter,system-ui,sans-serif;color:#e8edf5;background:#090b10}body{margin:0}main{width:min(760px,calc(100% - 40px));margin:10vh auto}.eyebrow{color:#d9ff52;font-size:12px;font-weight:800;letter-spacing:.16em}h1{margin:8px 0;font-size:clamp(36px,7vw,68px);letter-spacing:-.05em}.controls{display:flex;gap:18px;align-items:center;margin:32px 0}button{border:0;border-radius:5px;padding:10px 14px;background:#d9ff52;font-weight:800}#status{color:#aab4c4}pre{min-height:260px;padding:22px;overflow:auto;border:1px solid #2b323e;border-radius:8px;background:#11151c;color:#c6d1df}.evidence-scroll{overflow-x:auto;margin:24px 0}.evidence-table{border-collapse:collapse;width:100%;text-align:left}.evidence-table th,.evidence-table td{padding:12px;border:1px solid #2b323e;vertical-align:top}.evidence-table td{white-space:pre-wrap;overflow-wrap:anywhere;min-width:110px}.evidence-table td:last-child{min-width:320px;font-family:monospace}

dist/index.html

@@ -1,44 +1,45 @@
 <!doctype html>
 <html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <link rel="icon" href="data:," />
-    <title>TeaQL Browser SQLite</title>
-    <script type="module" crossorigin src="/assets/index-DTZ5iA72.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-inj2slTy.css">
-  </head>
-  <body>
-    <main>
-      <p class="eyebrow">TEAQL TYPESCRIPT RUNTIME</p>
-      <h1>Browser-local Data Service</h1>
-      <p>Write the same generated Q API used by an application. Peggy parses it into a controlled AST; no arbitrary JavaScript is evaluated.</p>
-      <p><strong>Everything runs in this browser.</strong> There is no application backend and no server-side business database.</p>
-      <div class="controls">
-        <label><input id="persist" type="checkbox" /> Persist locally with OPFS <span id="opfs-note"></span></label>
-        <button id="reset">Reset demo data</button>
-      </div>
-      <p id="status">Starting SQLite/WASM…</p>
-      <section class="query-panel">
-        <div class="query-toolbar">
-          <label for="preset">Example</label>
-          <select id="preset">
-            <option value="facet">Rows + relation facet</option>
-            <option value="filter">String filter</option>
-            <option value="all">Bounded list</option>
-          </select>
-          <button id="run" class="run">Run query</button>
-        </div>
-        <textarea id="query" spellcheck="false" aria-label="TeaQL query"></textarea>
-        <p class="hint">Accepted input is the generated TypeScript Q API. Execution, imports, assignments, and browser APIs are not part of the grammar.</p>
-      </section>
-      <section class="response-panel">
-        <div class="response-heading">
-          <h2>Web Response</h2>
-          <span>data · metadata · facets</span>
-        </div>
-        <pre id="result"></pre>
-      </section>
-    </main>
-  </body>
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="icon" href="data:," />
+  <title>TeaQL browser order TraceChain</title>
+  <script type="module" crossorigin src="/assets/index-CSFBt0NB.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-DmPc8xp3.css">
+</head>
+<body>
+  <main>
+    <p class="eyebrow">GENERATED Q + E · SQLITE/WASM · NO BACKEND</p>
+    <h1>Order query evidence</h1>
+    <p>One filtered page, named total, status facets and bounded item previews.</p>
+    <p>Entirely browser-local · SQLite/WASM · Generated typed Order Q/E APIs</p>
+    <p><a href="https://github.com/teaql/teaql-ts">Runtime source</a> · <a href="https://huggingface.co/spaces/teaql/browser-sqlite-playground/tree/main/source">This demo's source snapshot</a></p>
+    <div class="controls">
+      <label><input id="persist" type="checkbox" /> Persist locally with OPFS <span id="opfs-note"></span></label>
+      <label><input id="logging" type="checkbox" checked /> Diagnostic logging</label>
+      <button id="reset">Reset demo data</button>
+    </div>
+    <label for="example">Example query</label>
+    <select id="example"><option value="filtered">Filtered order page</option><option value="all">All orders</option></select>
+    <label for="search">Editable generated TypeScript Q API, parsed into a controlled AST</label>
+    <textarea id="search" rows="20" spellcheck="false" style="display:block;width:100%;margin:12px 0"></textarea>
+    <p>No eval, imports, assignments or arbitrary JavaScript execution.</p>
+    <button id="query">Run query</button>
+    <button id="preset">Restore example search</button>
+    <p id="status">Starting SQLite/WASM…</p>
+    <h2>Response data and metadata</h2>
+    <pre id="result"></pre>
+    <h2>SQL execution evidence</h2>
+    <p>Time is the recorded execution duration. Identity is the request entity from tracePath, not a user or object ID.</p>
+    <div class="evidence-scroll">
+      <table class="evidence-table">
+        <thead><tr><th scope="col">Time</th><th scope="col">Identity</th><th scope="col">Trace chain</th><th scope="col">SQL</th></tr></thead>
+        <tbody id="evidence-rows"></tbody>
+      </table>
+    </div>
+    <details><summary>Business TraceChain as text</summary><pre id="trace"></pre></details>
+    <details><summary>Runtime metadata and physical tracePath</summary><pre id="sql"></pre></details>
+  </main>
+</body>
 </html>

index.html

@@ -1,19 +1,45 @@
 <!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="icon" href="data:," />
+  <title>TeaQL browser order TraceChain</title>
+  <script type="module" crossorigin src="/assets/index-CSFBt0NB.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-DmPc8xp3.css">
+</head>
+<body>
+  <main>
+    <p class="eyebrow">GENERATED Q + E · SQLITE/WASM · NO BACKEND</p>
+    <h1>Order query evidence</h1>
+    <p>One filtered page, named total, status facets and bounded item previews.</p>
+    <p>Entirely browser-local · SQLite/WASM · Generated typed Order Q/E APIs</p>
+    <p><a href="https://github.com/teaql/teaql-ts">Runtime source</a> · <a href="https://huggingface.co/spaces/teaql/browser-sqlite-playground/tree/main/source">This demo's source snapshot</a></p>
+    <div class="controls">
+      <label><input id="persist" type="checkbox" /> Persist locally with OPFS <span id="opfs-note"></span></label>
+      <label><input id="logging" type="checkbox" checked /> Diagnostic logging</label>
+      <button id="reset">Reset demo data</button>
+    </div>
+    <label for="example">Example query</label>
+    <select id="example"><option value="filtered">Filtered order page</option><option value="all">All orders</option></select>
+    <label for="search">Editable generated TypeScript Q API, parsed into a controlled AST</label>
+    <textarea id="search" rows="20" spellcheck="false" style="display:block;width:100%;margin:12px 0"></textarea>
+    <p>No eval, imports, assignments or arbitrary JavaScript execution.</p>
+    <button id="query">Run query</button>
+    <button id="preset">Restore example search</button>
+    <p id="status">Starting SQLite/WASM…</p>
+    <h2>Response data and metadata</h2>
+    <pre id="result"></pre>
+    <h2>SQL execution evidence</h2>
+    <p>Time is the recorded execution duration. Identity is the request entity from tracePath, not a user or object ID.</p>
+    <div class="evidence-scroll">
+      <table class="evidence-table">
+        <thead><tr><th scope="col">Time</th><th scope="col">Identity</th><th scope="col">Trace chain</th><th scope="col">SQL</th></tr></thead>
+        <tbody id="evidence-rows"></tbody>
+      </table>
+    </div>
+    <details><summary>Business TraceChain as text</summary><pre id="trace"></pre></details>
+    <details><summary>Runtime metadata and physical tracePath</summary><pre id="sql"></pre></details>
+  </main>
+</body>
 </html>

source/browser-sqlite/assist/create-customer.md

@@ -0,0 +1,82 @@
+<!-- ephemeral -->
+
+# TypeScript Assist — Create `Customer`
+
+Use the exact generated `Q.customers()` entry point. The
+trusted `UserContext` supplies actor, tenant, policy, provider, and audit sink;
+none of those values may be accepted from the writable input.
+
+```typescript
+import { UserContext } from '../teaql-ts';
+import { Q } from './Q';
+import { Customer } from './models/Customer';
+
+export interface CreateCustomerInput {
+    platform: string | number;
+    name: string;
+
+}
+
+export async function createCustomer(
+    input: CreateCustomerInput,
+    context: UserContext,
+): Promise<Customer> {
+    const entity = Q.customers()
+        .comment('what: initialize Customer')
+        .purpose('why: create Customer')
+        .newEntity(context);
+
+    entity.updatePlatform(input.platform);
+    entity.updateName(input.name);
+
+    await entity
+        .auditAs('Create Customer for the requested business operation')
+        .save(context);
+    return entity;
+}
+```
+
+Only the generated updater methods above are writable. Constant relation
+candidates, when present, are also generated and must be copied exactly:
+
+Compile the result unchanged. Test persistence and query-back, and prove that
+blank/missing intent, blank/missing audit reason, unknown fields, and attempted
+trusted-context overrides fail. Do not edit generated sources.
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `create`.
+
+- Validate and allow-list writable business fields; never mass-assign dynamic JSON.
+- Create through the generated request/entity API, attach a non-empty audit reason,
+  save with the same UserContext, and return the runtime's native save result.
+- Add a negative test proving a missing audit reason cannot write.

source/browser-sqlite/assist/create-customer_order.md

@@ -0,0 +1,92 @@
+<!-- ephemeral -->
+
+# TypeScript Assist — Create `Customer Order`
+
+Use the exact generated `Q.customerOrders()` entry point. The
+trusted `UserContext` supplies actor, tenant, policy, provider, and audit sink;
+none of those values may be accepted from the writable input.
+
+```typescript
+import { UserContext } from '../teaql-ts';
+import { Q } from './Q';
+import { CustomerOrder } from './models/CustomerOrder';
+
+export interface CreateCustomerOrderInput {
+    customer: string | number;
+    status: string | number;
+    orderNumber: string;
+    orderDate: string;
+    totalAmount: number;
+
+}
+
+export async function createCustomerOrder(
+    input: CreateCustomerOrderInput,
+    context: UserContext,
+): Promise<CustomerOrder> {
+    const entity = Q.customerOrders()
+        .comment('what: initialize Customer Order')
+        .purpose('why: create Customer Order')
+        .newEntity(context);
+
+    entity.updateCustomer(input.customer);
+    entity.updateStatus(input.status);
+    entity.updateOrderNumber(input.orderNumber);
+    entity.updateOrderDate(input.orderDate);
+    entity.updateTotalAmount(input.totalAmount);
+
+    await entity
+        .auditAs('Create Customer Order for the requested business operation')
+        .save(context);
+    return entity;
+}
+```
+
+Only the generated updater methods above are writable. Constant relation
+candidates, when present, are also generated and must be copied exactly:
+- `updateStatusToNew()`
+- `updateStatusToPaid()`
+- `updateStatusToCancelled()`
+
+
+Compile the result unchanged. Test persistence and query-back, and prove that
+blank/missing intent, blank/missing audit reason, unknown fields, and attempted
+trusted-context overrides fail. Do not edit generated sources.
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `create`.
+
+- Validate and allow-list writable business fields; never mass-assign dynamic JSON.
+- Create through the generated request/entity API, attach a non-empty audit reason,
+  save with the same UserContext, and return the runtime's native save result.
+- Add a negative test proving a missing audit reason cannot write.

source/browser-sqlite/assist/create-order_item.md

@@ -0,0 +1,86 @@
+<!-- ephemeral -->
+
+# TypeScript Assist — Create `Order Item`
+
+Use the exact generated `Q.orderItems()` entry point. The
+trusted `UserContext` supplies actor, tenant, policy, provider, and audit sink;
+none of those values may be accepted from the writable input.
+
+```typescript
+import { UserContext } from '../teaql-ts';
+import { Q } from './Q';
+import { OrderItem } from './models/OrderItem';
+
+export interface CreateOrderItemInput {
+    customerOrder: string | number;
+    productName: string;
+    quantity: number;
+    unitPrice: number;
+
+}
+
+export async function createOrderItem(
+    input: CreateOrderItemInput,
+    context: UserContext,
+): Promise<OrderItem> {
+    const entity = Q.orderItems()
+        .comment('what: initialize Order Item')
+        .purpose('why: create Order Item')
+        .newEntity(context);
+
+    entity.updateCustomerOrder(input.customerOrder);
+    entity.updateProductName(input.productName);
+    entity.updateQuantity(input.quantity);
+    entity.updateUnitPrice(input.unitPrice);
+
+    await entity
+        .auditAs('Create Order Item for the requested business operation')
+        .save(context);
+    return entity;
+}
+```
+
+Only the generated updater methods above are writable. Constant relation
+candidates, when present, are also generated and must be copied exactly:
+
+Compile the result unchanged. Test persistence and query-back, and prove that
+blank/missing intent, blank/missing audit reason, unknown fields, and attempted
+trusted-context overrides fail. Do not edit generated sources.
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `create`.
+
+- Validate and allow-list writable business fields; never mass-assign dynamic JSON.
+- Create through the generated request/entity API, attach a non-empty audit reason,
+  save with the same UserContext, and return the runtime's native save result.
+- Add a negative test proving a missing audit reason cannot write.

source/browser-sqlite/assist/debug.md

@@ -0,0 +1,101 @@
+<!-- ephemeral -->
+
+# TeaQL safe SQL execution evidence (TypeScript)
+
+Attach a trusted evidence store to the server-created SQL client and project
+only bounded fields before returning diagnostics to an application or Coding
+Agent.
+
+```typescript
+import type { SQLExecutionMetadata, SQLExecutionOperation } from 'teaql-ts/sql/core';
+
+export type SafeSQLExecutionEvidence = Readonly<{
+  operation: SQLExecutionOperation;
+  parameterizedSQL: string;
+  parameterCount: number;
+  elapsedMicros: number;
+  resultCount?: number;
+  affectedRows?: number;
+  resultSummary: string;
+  traceChain?: SQLExecutionMetadata['traceChain'];
+  tracePath: SQLExecutionMetadata['tracePath'];
+}>;
+
+export function safeSQLEvidence(
+  entries: readonly SQLExecutionMetadata[],
+): readonly SafeSQLExecutionEvidence[] {
+  return entries.map(entry => Object.freeze({
+    operation: entry.operation,
+    parameterizedSQL: entry.parameterizedSQL,
+    parameterCount: entry.parameters.length,
+    elapsedMicros: entry.elapsedMicros,
+    resultCount: entry.resultCount,
+    affectedRows: entry.affectedRows,
+    resultSummary: entry.resultSummary,
+    traceChain: entry.traceChain,
+    tracePath: entry.tracePath,
+  }));
+}
+```
+
+Create `SQLExecutionEvidenceStore`, attach it with
+`client.setRuntimeTelemetrySink(store)`, and select `enableAll`, `enableSelect`,
+`enableMutation`, or `disable`. Mode changes clear earlier entries. Raw
+parameters, credentials, connection strings, and interpolated SQL remain inside
+the trusted boundary and are intentionally absent above.
+
+Query and mutation logs, including the text diagnostic sink, are enabled by default.
+The default sink is `new TextDiagnosticSQLLogSink()` and may be
+replaced with `client.setDiagnosticSQLLogSink(...)`. Disable the two operation
+families independently with
+`client.setQueryLoggingEnabled(false)` and
+`client.setMutationLoggingEnabled(false)`; passing `undefined` to
+`setDiagnosticSQLLogSink` removes operator output entirely. Each metadata entry
+retains structured `comment`, `purpose`, `auditReason`, typed multi-level
+`tracePath`, business `traceChain`, parameterized SQL, copy-paste `debugSQL`, elapsed
+time, result count, and affected rows. `traceChain` follows the root purpose and
+request-parent comments, preserving both the native Q operation and a nested
+explicit/default comment. `tracePath` describes the physical provider/SQL route;
+do not derive one from the other or reconstruct either from SQL text. Runtime
+evidence is policy-projected by default; keep that projection when exposing it.
+Explicit debug plaintext is not ordinary telemetry and must not leave the trusted
+debugging boundary.
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `debug`.
+
+- Capture purpose, comment, trace/correlation id, parameterized SQL summary,
+  duration, row count, provider, and the runtime's native response when available.
+- Preserve the immutable row audit event and the customizable App Audit Sink as
+  separate paths. Redact credentials, tokens, connection strings, and customer data.
+- Document only switches and hooks present in the selected runtime source.

source/browser-sqlite/assist/expression-customer_order.md

@@ -0,0 +1,135 @@
+<!-- ephemeral -->
+
+# TypeScript Assist — Expression `Customer Order`
+
+The generated E facade preserves Value, loaded null/undefined, and NotLoaded.
+`eval()` returns a native value for the first two and throws
+`TeaQLNotLoadedError` for the third. `orElse` is nullish-only and never hides
+NotLoaded.
+
+```typescript
+import { E } from './E';
+import { CustomerOrder } from './models/CustomerOrder';
+
+export function extractId(entity: CustomerOrder) {
+    return E.customerOrder(entity).id().eval();
+}
+
+export function extractIdOrElse(
+    entity: CustomerOrder, fallback: NonNullable<CustomerOrder['id']>,
+) {
+    return E.customerOrder(entity).id().orElse(fallback);
+}
+
+export function extractOrderNumber(entity: CustomerOrder) {
+    return E.customerOrder(entity).orderNumber().eval();
+}
+
+export function extractOrderNumberOrElse(
+    entity: CustomerOrder, fallback: NonNullable<CustomerOrder['orderNumber']>,
+) {
+    return E.customerOrder(entity).orderNumber().orElse(fallback);
+}
+
+export function extractOrderDate(entity: CustomerOrder) {
+    return E.customerOrder(entity).orderDate().eval();
+}
+
+export function extractOrderDateOrElse(
+    entity: CustomerOrder, fallback: NonNullable<CustomerOrder['orderDate']>,
+) {
+    return E.customerOrder(entity).orderDate().orElse(fallback);
+}
+
+export function extractTotalAmount(entity: CustomerOrder) {
+    return E.customerOrder(entity).totalAmount().eval();
+}
+
+export function extractTotalAmountOrElse(
+    entity: CustomerOrder, fallback: NonNullable<CustomerOrder['totalAmount']>,
+) {
+    return E.customerOrder(entity).totalAmount().orElse(fallback);
+}
+
+export function extractVersion(entity: CustomerOrder) {
+    return E.customerOrder(entity).version().eval();
+}
+
+export function extractVersionOrElse(
+    entity: CustomerOrder, fallback: NonNullable<CustomerOrder['version']>,
+) {
+    return E.customerOrder(entity).version().orElse(fallback);
+}
+
+export function extractCustomerId(entity: CustomerOrder) {
+    return E.customerOrder(entity).customerId().eval();
+}
+
+export function traverseCustomer(entity: CustomerOrder) {
+    return E.customerOrder(entity).customer().eval();
+}
+
+export function extractStatusId(entity: CustomerOrder) {
+    return E.customerOrder(entity).statusId().eval();
+}
+
+export function traverseStatus(entity: CustomerOrder) {
+    return E.customerOrder(entity).status().eval();
+}
+
+export function aggregateOrderItemListSize(entity: CustomerOrder) {
+    return E.customerOrder(entity).orderItemList().size().eval();
+}
+
+export function firstOrderItemListId(entity: CustomerOrder) {
+    return E.customerOrder(entity).orderItemList().first().id().eval();
+}
+
+export function getOrderItemListId(entity: CustomerOrder, index: number) {
+    return E.customerOrder(entity).orderItemList().get(index).id().eval();
+}
+
+
+```
+
+Select every traversed field and relation. Never catch
+`TeaQLNotLoadedError` merely to supply a default, and never replace generated E
+accessors with optional chaining.
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `expression`.
+
+- Distinguish a loaded null from a field or relation that was not projected. A
+  NotLoaded/coding error must remain visible; do not turn it into an ordinary null.
+- Select every traversed relation first and use the generated E/expression API for
+  scalar, object, and list traversal. Do not translate Java accessor names by guess.

source/browser-sqlite/assist/query-customer_order.md

@@ -0,0 +1,104 @@
+<!-- ephemeral -->
+
+# TypeScript Assist — Query `Customer Order`
+
+Use the exact generated `Q.customerOrdersWithMinimalFields()`
+entry point. Trusted runtime and policy state comes only from `UserContext`.
+
+```typescript
+import { Q } from './Q';
+import { CustomerOrder } from './models/CustomerOrder';
+import { SmartList, UserContext } from '../teaql-ts';
+
+export async function queryCustomerOrderById(
+    context: UserContext,
+    entityId: string,
+): Promise<SmartList<CustomerOrder>> {
+    return Q.customerOrdersWithMinimalFields()
+        .withIdIs(entityId)
+        .orderByIdAscending()
+        .limit(20)
+        .comment('what: load the requested Customer Order row')
+        .purpose('why: serve the authorized Customer Order view')
+        .executeForList(context);
+}
+```
+
+Compile and execute this source unchanged. Use only generated projection,
+predicate, ordering, and relation-selection APIs. Missing or blank intent,
+unknown fields, unbounded reads, and trusted-context inputs must fail. Use generated
+relation loading rather than handwritten child-query loops; never guess a plural.
+
+
+## Field-specific Query Assist
+
+Use the canonical KSML field name from this list. Do not substitute a language member name, JSON name, or database column.
+
+| KSML field | Type | Field help |
+| --- | --- | --- |
+| `id` | `id` | `typescript-assist-query/customer_order.id` |
+| `customer` | `relation<customer>` | `typescript-assist-query/customer_order.customer` |
+| `status` | `relation<order_status>` | `typescript-assist-query/customer_order.status` |
+| `order_number` | `string` | `typescript-assist-query/customer_order.order_number` |
+| `order_date` | `date` | `typescript-assist-query/customer_order.order_date` |
+| `total_amount` | `number` | `typescript-assist-query/customer_order.total_amount` |
+| `version` | `version` | `typescript-assist-query/customer_order.version` |
+
+Generated reverse relations are derived from referencing KSML fields. Use their exact generated location for relation selection and access:
+
+| Generated reverse relation | Child entity | Field help |
+| --- | --- | --- |
+| `order_item_list` | `order_item` | `typescript-assist-query/customer_order.order_item_list` |
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `query`.
+
+- Use generated projection, relation, predicate, sort, and aggregate APIs; never
+  concatenate application SQL or silently ignore an unsupported filter.
+- Rows, record count, facets, and aggregates must share the same active filter.
+- Add negative tests for missing purpose/comment and forbidden dynamic fields.
+
+### Optional per-parent Top-N optimization
+
+- Configure `topNProbeParentThreshold(threshold)` on the nested child request before its intent/execution
+  stage. Use the field-specific relation Assist for the exact generated selector.
+- Give the child a per-parent limit and deterministic ordering with an ID tie-breaker;
+  bound the parent query separately. A single-parent detail query is not batch Top-N.
+- Server providers default to a window query (`threshold = 0`). A positive threshold
+  permits bounded probes only when the already-loaded parent count is at or below it;
+  above it, use the window plan. SQLite uses its internal AlwaysProbe policy by default.
+- Measure before opting in. Do not infer a threshold from table size or execute COUNT
+  or statistics queries to choose a plan. Keep an index on foreign key + sort + ID.
+- Inspect selected-plan, parent-count, per-parent-limit and probe-count telemetry.
+  Runtime-managed probes are not application-owned N+1 loops; neither strategy changes
+  authorization, loaded-state semantics or the required comment/purpose.

source/browser-sqlite/assist/query-customer_order.order_item_list.md

@@ -0,0 +1,66 @@
+<!-- ephemeral -->
+
+# Query Reverse-Relation Assist — `customer_order.order_item_list`
+
+KSML entity: `customer_order`  
+Derived reverse relation: `order_item_list`  
+Child entity: `order_item`
+
+| Capability | Generated API |
+| --- | --- |
+| Select | `.selectOrderItemListWith(Q.orderItemsWithMinimalFields())` |
+
+Reverse relations are model-derived and never perform an implicit database query. Select the relation explicitly before expression access. Apply query methods before the executable purpose stage, then execute with exactly one trusted context.
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `query`.
+
+- Use generated projection, relation, predicate, sort, and aggregate APIs; never
+  concatenate application SQL or silently ignore an unsupported filter.
+- Rows, record count, facets, and aggregates must share the same active filter.
+- Add negative tests for missing purpose/comment and forbidden dynamic fields.
+
+### Optional per-parent Top-N optimization
+
+- Configure `topNProbeParentThreshold(threshold)` on the nested child request before its intent/execution
+  stage. Use the field-specific relation Assist for the exact generated selector.
+- Give the child a per-parent limit and deterministic ordering with an ID tie-breaker;
+  bound the parent query separately. A single-parent detail query is not batch Top-N.
+- Server providers default to a window query (`threshold = 0`). A positive threshold
+  permits bounded probes only when the already-loaded parent count is at or below it;
+  above it, use the window plan. SQLite uses its internal AlwaysProbe policy by default.
+- Measure before opting in. Do not infer a threshold from table size or execute COUNT
+  or statistics queries to choose a plan. Keep an index on foreign key + sort + ID.
+- Inspect selected-plan, parent-count, per-parent-limit and probe-count telemetry.
+  Runtime-managed probes are not application-owned N+1 loops; neither strategy changes
+  authorization, loaded-state semantics or the required comment/purpose.

source/browser-sqlite/assist/query-customer_order.status.md

@@ -0,0 +1,72 @@
+<!-- ephemeral -->
+
+# TypeScript Query Field Assist — `customer_order.status`
+
+KSML entity: `Customer Order`  
+KSML field: `Order Status`  
+Type: `Order Status`
+
+| Capability | Generated API |
+| --- | --- |
+| Select | `selectStatusWith(request)`` |
+| Filter identity | `withStatusIs(id)`, `withStatusIn(ids)` |
+| Filter nested request | `withStatusMatching(request)`, `withoutStatusMatching(request)` |
+| Constant | `withStatusIs()` |
+| Constant | `withStatusIs()` |
+| Constant | `withStatusIs()` |
+| Group | `groupByStatus()`, `groupByStatusAs(alias)` |
+| Facet | `facetByStatusAs(name, request, includeAllFacets)` |
+Execution requires `comment(...)`, `purpose(...)`, and exactly one `context`.
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `query`.
+
+- Use generated projection, relation, predicate, sort, and aggregate APIs; never
+  concatenate application SQL or silently ignore an unsupported filter.
+- Rows, record count, facets, and aggregates must share the same active filter.
+- Add negative tests for missing purpose/comment and forbidden dynamic fields.
+
+### Optional per-parent Top-N optimization
+
+- Configure `topNProbeParentThreshold(threshold)` on the nested child request before its intent/execution
+  stage. Use the field-specific relation Assist for the exact generated selector.
+- Give the child a per-parent limit and deterministic ordering with an ID tie-breaker;
+  bound the parent query separately. A single-parent detail query is not batch Top-N.
+- Server providers default to a window query (`threshold = 0`). A positive threshold
+  permits bounded probes only when the already-loaded parent count is at or below it;
+  above it, use the window plan. SQLite uses its internal AlwaysProbe policy by default.
+- Measure before opting in. Do not infer a threshold from table size or execute COUNT
+  or statistics queries to choose a plan. Keep an index on foreign key + sort + ID.
+- Inspect selected-plan, parent-count, per-parent-limit and probe-count telemetry.
+  Runtime-managed probes are not application-owned N+1 loops; neither strategy changes
+  authorization, loaded-state semantics or the required comment/purpose.

source/browser-sqlite/assist/query-order_item.md

@@ -0,0 +1,97 @@
+<!-- ephemeral -->
+
+# TypeScript Assist — Query `Order Item`
+
+Use the exact generated `Q.orderItemsWithMinimalFields()`
+entry point. Trusted runtime and policy state comes only from `UserContext`.
+
+```typescript
+import { Q } from './Q';
+import { OrderItem } from './models/OrderItem';
+import { SmartList, UserContext } from '../teaql-ts';
+
+export async function queryOrderItemById(
+    context: UserContext,
+    entityId: string,
+): Promise<SmartList<OrderItem>> {
+    return Q.orderItemsWithMinimalFields()
+        .withIdIs(entityId)
+        .orderByIdAscending()
+        .limit(20)
+        .comment('what: load the requested Order Item row')
+        .purpose('why: serve the authorized Order Item view')
+        .executeForList(context);
+}
+```
+
+Compile and execute this source unchanged. Use only generated projection,
+predicate, ordering, and relation-selection APIs. Missing or blank intent,
+unknown fields, unbounded reads, and trusted-context inputs must fail. Use generated
+relation loading rather than handwritten child-query loops; never guess a plural.
+
+
+## Field-specific Query Assist
+
+Use the canonical KSML field name from this list. Do not substitute a language member name, JSON name, or database column.
+
+| KSML field | Type | Field help |
+| --- | --- | --- |
+| `id` | `id` | `typescript-assist-query/order_item.id` |
+| `customer_order` | `relation<customer_order>` | `typescript-assist-query/order_item.customer_order` |
+| `product_name` | `string` | `typescript-assist-query/order_item.product_name` |
+| `quantity` | `integer` | `typescript-assist-query/order_item.quantity` |
+| `unit_price` | `number` | `typescript-assist-query/order_item.unit_price` |
+| `version` | `version` | `typescript-assist-query/order_item.version` |
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `query`.
+
+- Use generated projection, relation, predicate, sort, and aggregate APIs; never
+  concatenate application SQL or silently ignore an unsupported filter.
+- Rows, record count, facets, and aggregates must share the same active filter.
+- Add negative tests for missing purpose/comment and forbidden dynamic fields.
+
+### Optional per-parent Top-N optimization
+
+- Configure `topNProbeParentThreshold(threshold)` on the nested child request before its intent/execution
+  stage. Use the field-specific relation Assist for the exact generated selector.
+- Give the child a per-parent limit and deterministic ordering with an ID tie-breaker;
+  bound the parent query separately. A single-parent detail query is not batch Top-N.
+- Server providers default to a window query (`threshold = 0`). A positive threshold
+  permits bounded probes only when the already-loaded parent count is at or below it;
+  above it, use the window plan. SQLite uses its internal AlwaysProbe policy by default.
+- Measure before opting in. Do not infer a threshold from table size or execute COUNT
+  or statistics queries to choose a plan. Keep an index on foreign key + sort + ID.
+- Inspect selected-plan, parent-count, per-parent-limit and probe-count telemetry.
+  Runtime-managed probes are not application-owned N+1 loops; neither strategy changes
+  authorization, loaded-state semantics or the required comment/purpose.

source/browser-sqlite/assist/query-order_status.customer_order_list.md

@@ -0,0 +1,66 @@
+<!-- ephemeral -->
+
+# Query Reverse-Relation Assist — `order_status.customer_order_list`
+
+KSML entity: `order_status`  
+Derived reverse relation: `customer_order_list`  
+Child entity: `customer_order`
+
+| Capability | Generated API |
+| --- | --- |
+| Select | `.selectCustomerOrderListWith(Q.customerOrdersWithMinimalFields())` |
+
+Reverse relations are model-derived and never perform an implicit database query. Select the relation explicitly before expression access. Apply query methods before the executable purpose stage, then execute with exactly one trusted context.
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `query`.
+
+- Use generated projection, relation, predicate, sort, and aggregate APIs; never
+  concatenate application SQL or silently ignore an unsupported filter.
+- Rows, record count, facets, and aggregates must share the same active filter.
+- Add negative tests for missing purpose/comment and forbidden dynamic fields.
+
+### Optional per-parent Top-N optimization
+
+- Configure `topNProbeParentThreshold(threshold)` on the nested child request before its intent/execution
+  stage. Use the field-specific relation Assist for the exact generated selector.
+- Give the child a per-parent limit and deterministic ordering with an ID tie-breaker;
+  bound the parent query separately. A single-parent detail query is not batch Top-N.
+- Server providers default to a window query (`threshold = 0`). A positive threshold
+  permits bounded probes only when the already-loaded parent count is at or below it;
+  above it, use the window plan. SQLite uses its internal AlwaysProbe policy by default.
+- Measure before opting in. Do not infer a threshold from table size or execute COUNT
+  or statistics queries to choose a plan. Keep an index on foreign key + sort + ID.
+- Inspect selected-plan, parent-count, per-parent-limit and probe-count telemetry.
+  Runtime-managed probes are not application-owned N+1 loops; neither strategy changes
+  authorization, loaded-state semantics or the required comment/purpose.

source/browser-sqlite/assist/query-order_status.md

@@ -0,0 +1,104 @@
+<!-- ephemeral -->
+
+# TypeScript Assist — Query `Order Status`
+
+Use the exact generated `Q.orderStatusesWithMinimalFields()`
+entry point. Trusted runtime and policy state comes only from `UserContext`.
+
+```typescript
+import { Q } from './Q';
+import { OrderStatus } from './models/OrderStatus';
+import { SmartList, UserContext } from '../teaql-ts';
+
+export async function queryOrderStatusById(
+    context: UserContext,
+    entityId: string,
+): Promise<SmartList<OrderStatus>> {
+    return Q.orderStatusesWithMinimalFields()
+        .withIdIs(entityId)
+        .orderByIdAscending()
+        .limit(20)
+        .comment('what: load the requested Order Status row')
+        .purpose('why: serve the authorized Order Status view')
+        .executeForList(context);
+}
+```
+
+Compile and execute this source unchanged. Use only generated projection,
+predicate, ordering, and relation-selection APIs. Missing or blank intent,
+unknown fields, unbounded reads, and trusted-context inputs must fail. Use generated
+relation loading rather than handwritten child-query loops; never guess a plural.
+
+
+## Field-specific Query Assist
+
+Use the canonical KSML field name from this list. Do not substitute a language member name, JSON name, or database column.
+
+| KSML field | Type | Field help |
+| --- | --- | --- |
+| `platform` | `relation<platform>` | `typescript-assist-query/order_status.platform` |
+| `id` | `id` | `typescript-assist-query/order_status.id` |
+| `name` | `string` | `typescript-assist-query/order_status.name` |
+| `code` | `string` | `typescript-assist-query/order_status.code` |
+| `color` | `string` | `typescript-assist-query/order_status.color` |
+| `display_order` | `integer` | `typescript-assist-query/order_status.display_order` |
+| `version` | `version` | `typescript-assist-query/order_status.version` |
+
+Generated reverse relations are derived from referencing KSML fields. Use their exact generated location for relation selection and access:
+
+| Generated reverse relation | Child entity | Field help |
+| --- | --- | --- |
+| `customer_order_list` | `customer_order` | `typescript-assist-query/order_status.customer_order_list` |
+
+
+---
+
+## TeaQL seven-language assist contract
+
+Apply the verified Rust semantic ceiling while using only the exact TYPESCRIPT generated and
+runtime APIs. Discover APIs through the generated application AGENTS.md and progressive
+model-aware Assist. Do not inspect generated domain-library source.
+
+- Do not create plurals by appending `s` or `es`; use the centralized generated plural.
+- Human and non-human entities use different generated predicate vocabularies. Preserve
+  forms such as “who are active” and “whose email is”; never infer them from English.
+- Configure filters, projection, paging, and other query options before `purpose(...)`.
+  Comment may appear anywhere in the chain. Purpose enters the executable stage; execution
+  requires both values, but comment does not have to immediately precede purpose.
+- Every execute/list/stream and every save accepts exactly one context argument:
+  `UserContext`. Name that argument `context`, never `runtime`; data services and global
+  policy are injected when the context is built. Reserve `runtime` for process-level
+  runtime ownership, provider/pool setup, and module assembly.
+- Tenant, merchant, identity, permissions, request policy, purpose policy, hard limit,
+  and continuous-page cursor policy come only from trusted context, never dynamic JSON or TFP.
+- If the required operation is absent after current entity/action and required field
+  Assist, stop that path and report MISSING_ASSIST. Do not guess an API or search the
+  generated library as a fallback.
+- Create each application-owned source file once. After its first compile attempt,
+  repair only the smallest block identified by the exact compiler or test diagnostic.
+  Preserve unrelated code; do not rewrite the complete file as an error-recovery loop.
+- Before a repair that would replace more than 25% of an existing application file,
+  stop and report LARGE_REWRITE_REQUEST with the file, exact diagnostic, reason, and
+  estimated scope. Initial creation and model-driven regeneration are not repairs.
+
+Capability: `query`.
+
+- Use generated projection, relation, predicate, sort, and aggregate APIs; never
+  concatenate application SQL or silently ignore an unsupported filter.
+- Rows, record count, facets, and aggregates must share the same active filter.
+- Add negative tests for missing purpose/comment and forbidden dynamic fields.
+
+### Optional per-parent Top-N optimization
+
+- Configure `topNProbeParentThreshold(threshold)` on the nested child request before its intent/execution
+  stage. Use the field-specific relation Assist for the exact generated selector.
+- Give the child a per-parent limit and deterministic ordering with an ID tie-breaker;
+  bound the parent query separately. A single-parent detail query is not batch Top-N.
+- Server providers default to a window query (`threshold = 0`). A positive threshold
+  permits bounded probes only when the already-loaded parent count is at or below it;
+  above it, use the window plan. SQLite uses its internal AlwaysProbe policy by default.
+- Measure before opting in. Do not infer a threshold from table size or execute COUNT
+  or statistics queries to choose a plan. Keep an index on foreign key + sort + ID.
+- Inspect selected-plan, parent-count, per-parent-limit and probe-count telemetry.
+  Runtime-managed probes are not application-owned N+1 loops; neither strategy changes
+  authorization, loaded-state semantics or the required comment/purpose.

source/browser-sqlite/generated-order-hashes.json

@@ -0,0 +1,22 @@
+{
+  "package.json" : "bbfaeef0b7488ec0f44377eecc68375124b8f0c4fcacd7d59df1755b0a127581",
+  "src/generated-bootstrap.ts" : "5f3065c1e4794c0d21ada7c2eef48f4694cec1cbc4771fa48bc7d6ff9221540b",
+  "src/generated-search-models.ts" : "7ece2e29eeb80306d09623c8685c8a0b8d3b25aad6b38f845d5c9f069bd6f7a3",
+  "src/generated/E.ts" : "c4c72de70c1b103343390acee51970dd1fa01cdbe1bdebd9b9aa34b3539d2039",
+  "src/generated/Q.ts" : "e03153a1477298d4b6568bdeab1b98cab21bf98fcafd6a2fb248a1129db0b46f",
+  "src/generated/models/Customer.ts" : "d134c6b78e25d86dacea5d4c738178c3629101269413bb45d62a2f490d9b4417",
+  "src/generated/models/CustomerOrder.ts" : "c65e857a6deb99599e34a06bb24ca948cc852e9a15b969ff4ffe21d041fcf05c",
+  "src/generated/models/OrderItem.ts" : "ce43fb172b461b74d53cb73933335a8fa055b6269738f44bf3e1deb04e1d8b85",
+  "src/generated/models/OrderStatus.ts" : "c6e3349c7da21267dee6940b61a9d43bc0413a7d68230b9c600b73ec82f96e16",
+  "src/generated/models/Platform.ts" : "6a2df07a3fc284d02639ecb530d0aaa58e448dbc77de7d97b46dc4e367cd58fd",
+  "src/generated/requests/CustomerOrderRequest.ts" : "0f2a2a3895c7245ea258354e6fc19e24b4e57adc48a29818abe7b8ce8126cb57",
+  "src/generated/requests/CustomerRequest.ts" : "109f1df30ccafb9e4a163fa5f94d8e77d915cd2bb5a2d8bf3e7adeadbe92e262",
+  "src/generated/requests/OrderItemRequest.ts" : "ab3fb698f606c848da983eaabc140268066b8d9bac73b54127733c98e48e19d9",
+  "src/generated/requests/OrderStatusRequest.ts" : "f9087a9084b3aaac46d91cd7006cf5b71214df711bfd0f51e17da83a53e633c9",
+  "src/generated/requests/PlatformRequest.ts" : "8a6dd581be256cad3332ca275ac3652ef1e01a0c4c9f0e6cefd2a6e14fc105e1",
+  "src/runtime-module.ts" : "f92fe9a9474678d26a233eb734b14493b4ddc216ed3b648bfad723b4b6a46eeb",
+  "src/teaql-schemas.ts" : "68cb7cacc725ff041d2289f17d7817ae56f37d035c92f2feb6c1318face6f806",
+  "src/teaql-ts.ts" : "cc705f9f7873450eae541311317db3402dc40b7cf068c440169bd7ba06dcb1ed",
+  "teaql-i18n.json" : "ee5dc28e916a8907555d5d5a4d0e3cf2fa37aad047af37abed0800582af18d96",
+  "tsconfig.json" : "cf9a9767019ac7f4035a6d16952a5ae75b964b1c10c4584822b90799e6ce2037"
+}

source/browser-sqlite/index.html

@@ -0,0 +1,44 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <link rel="icon" href="data:," />
+  <title>TeaQL browser order TraceChain</title>
+</head>
+<body>
+  <main>
+    <p class="eyebrow">GENERATED Q + E · SQLITE/WASM · NO BACKEND</p>
+    <h1>Order query evidence</h1>
+    <p>One filtered page, named total, status facets and bounded item previews.</p>
+    <p>Entirely browser-local · SQLite/WASM · Generated typed Order Q/E APIs</p>
+    <p><a href="https://github.com/teaql/teaql-ts">Runtime source</a> · <a href="https://huggingface.co/spaces/teaql/browser-sqlite-playground/tree/main/source">This demo's source snapshot</a></p>
+    <div class="controls">
+      <label><input id="persist" type="checkbox" /> Persist locally with OPFS <span id="opfs-note"></span></label>
+      <label><input id="logging" type="checkbox" checked /> Diagnostic logging</label>
+      <button id="reset">Reset demo data</button>
+    </div>
+    <label for="example">Example query</label>
+    <select id="example"><option value="filtered">Filtered order page</option><option value="all">All orders</option></select>
+    <label for="search">Editable generated TypeScript Q API, parsed into a controlled AST</label>
+    <textarea id="search" rows="20" spellcheck="false" style="display:block;width:100%;margin:12px 0"></textarea>
+    <p>No eval, imports, assignments or arbitrary JavaScript execution.</p>
+    <button id="query">Run query</button>
+    <button id="preset">Restore example search</button>
+    <p id="status">Starting SQLite/WASM…</p>
+    <h2>Response data and metadata</h2>
+    <pre id="result"></pre>
+    <h2>SQL execution evidence</h2>
+    <p>Time is the recorded execution duration. Identity is the request entity from tracePath, not a user or object ID.</p>
+    <div class="evidence-scroll">
+      <table class="evidence-table">
+        <thead><tr><th scope="col">Time</th><th scope="col">Identity</th><th scope="col">Trace chain</th><th scope="col">SQL</th></tr></thead>
+        <tbody id="evidence-rows"></tbody>
+      </table>
+    </div>
+    <details><summary>Business TraceChain as text</summary><pre id="trace"></pre></details>
+    <details><summary>Runtime metadata and physical tracePath</summary><pre id="sql"></pre></details>
+  </main>
+  <script type="module" src="/src/main.ts"></script>
+</body>
+</html>

source/browser-sqlite/order-model.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<root name="request-tree-order-service" org="example" data_service="sqlite" _module_key="root">
+  <platform _name="Commerce Platform" _module="Commerce" _module_key="commerce"
+            name="Commerce Test Platform"/>
+  <order_status _name="Order Status" _module="Commerce" _module_key="commerce"
+                platform="platform()" id="id()" name="string()" code="string()"
+                color="string()" display_order="1" _constant="true" _identifier="code">
+    <_value id="1001" name="New" code="NEW" color="#94A3B8" display_order="1"/>
+    <_value id="1002" name="Paid" code="PAID" color="#22C55E" display_order="2"/>
+    <_value id="1003" name="Cancelled" code="CANCELLED" color="#EF4444" display_order="3"/>
+  </order_status>
+  <customer _name="Customer" _module="Commerce" _module_key="commerce"
+            platform="platform()" name="North Star Retail"/>
+  <customer_order _name="Customer Order" _module="Commerce" _module_key="commerce"
+                  customer="customer()" status="order_status()"
+                  order_number="CO-20261011-000001" order_date="2026-10-11"
+                  total_amount="100.00"/>
+  <order_item _name="Order Item" _module="Commerce" _module_key="commerce"
+              customer_order="customer_order()" product_name="Packing Box"
+              quantity="5" unit_price="20.00"/>
+</root>

source/browser-sqlite/orders-lib/package.json

@@ -0,0 +1,15 @@
+{
+  "name" : "request-tree-order-service-lib",
+  "version" : "1.0.0",
+  "description" : "Generated typescript library",
+  "main" : "src/generated/Q.ts",
+  "scripts" : {
+    "build" : "tsc --noEmit"
+  },
+  "dependencies" : {
+    "teaql-ts" : "file:../../.."
+  },
+  "devDependencies" : {
+    "typescript" : "^5.0.0"
+  }
+}

source/browser-sqlite/orders-lib/src/generated-bootstrap.ts

@@ -0,0 +1,69 @@
+import { UserContext } from './teaql-ts';
+import { Q } from './generated/Q';
+import { Platform } from './generated/models/Platform';
+import { OrderStatus } from './generated/models/OrderStatus';
+
+/** @internal Generated typed Mutation bootstrap; never call from application code. */
+export async function ensureGeneratedBootstrap(context: UserContext): Promise<void> {
+  let domainRoot = (await Q.platforms().withIdIs('1').comment('what: locate generated Domain Root').purpose('why: idempotent runtime bootstrap').executeForList(context))[0];
+  if (!domainRoot) {
+    domainRoot = Platform.teaqlBootstrapNew('1');
+    domainRoot.updateName("Commerce Test Platform");
+    await domainRoot.auditAs('create generated Domain Root Platform').save(context);
+  }
+  context.withActiveRoot({ entity: 'Platform', id: domainRoot.id! });
+  let constantOrderStatus1001 = (await Q.orderStatuses().withIdIs("1001").comment('what: locate generated constant OrderStatus(1001)').purpose('why: idempotent runtime bootstrap').executeForList(context))[0];
+  if (!constantOrderStatus1001) {
+    constantOrderStatus1001 = OrderStatus.teaqlBootstrapNew("1001");
+    constantOrderStatus1001.updatePlatform(domainRoot);
+    constantOrderStatus1001.updateName("New");
+    constantOrderStatus1001.updateCode("NEW");
+    constantOrderStatus1001.updateColor("#94A3B8");
+    constantOrderStatus1001.updateDisplayOrder(1);
+    await constantOrderStatus1001.auditAs('create model constant OrderStatus(1001)').save(context);
+  } else {
+    let changed = false;
+    if (String((constantOrderStatus1001.platform as any)?.id ?? constantOrderStatus1001.platform) !== String(domainRoot.id)) { constantOrderStatus1001.updatePlatform(domainRoot); changed = true; }
+    if (constantOrderStatus1001.name !== "New") { constantOrderStatus1001.updateName("New"); changed = true; }
+    if (constantOrderStatus1001.code !== "NEW") { constantOrderStatus1001.updateCode("NEW"); changed = true; }
+    if (constantOrderStatus1001.color !== "#94A3B8") { constantOrderStatus1001.updateColor("#94A3B8"); changed = true; }
+    if (constantOrderStatus1001.displayOrder !== 1) { constantOrderStatus1001.updateDisplayOrder(1); changed = true; }
+    if (changed) await constantOrderStatus1001.auditAs('reconcile model constant OrderStatus(1001)').save(context);
+  }
+  let constantOrderStatus1002 = (await Q.orderStatuses().withIdIs("1002").comment('what: locate generated constant OrderStatus(1002)').purpose('why: idempotent runtime bootstrap').executeForList(context))[0];
+  if (!constantOrderStatus1002) {
+    constantOrderStatus1002 = OrderStatus.teaqlBootstrapNew("1002");
+    constantOrderStatus1002.updatePlatform(domainRoot);
+    constantOrderStatus1002.updateName("Paid");
+    constantOrderStatus1002.updateCode("PAID");
+    constantOrderStatus1002.updateColor("#22C55E");
+    constantOrderStatus1002.updateDisplayOrder(2);
+    await constantOrderStatus1002.auditAs('create model constant OrderStatus(1002)').save(context);
+  } else {
+    let changed = false;
+    if (String((constantOrderStatus1002.platform as any)?.id ?? constantOrderStatus1002.platform) !== String(domainRoot.id)) { constantOrderStatus1002.updatePlatform(domainRoot); changed = true; }
+    if (constantOrderStatus1002.name !== "Paid") { constantOrderStatus1002.updateName("Paid"); changed = true; }
+    if (constantOrderStatus1002.code !== "PAID") { constantOrderStatus1002.updateCode("PAID"); changed = true; }
+    if (constantOrderStatus1002.color !== "#22C55E") { constantOrderStatus1002.updateColor("#22C55E"); changed = true; }
+    if (constantOrderStatus1002.displayOrder !== 2) { constantOrderStatus1002.updateDisplayOrder(2); changed = true; }
+    if (changed) await constantOrderStatus1002.auditAs('reconcile model constant OrderStatus(1002)').save(context);
+  }
+  let constantOrderStatus1003 = (await Q.orderStatuses().withIdIs("1003").comment('what: locate generated constant OrderStatus(1003)').purpose('why: idempotent runtime bootstrap').executeForList(context))[0];
+  if (!constantOrderStatus1003) {
+    constantOrderStatus1003 = OrderStatus.teaqlBootstrapNew("1003");
+    constantOrderStatus1003.updatePlatform(domainRoot);
+    constantOrderStatus1003.updateName("Cancelled");
+    constantOrderStatus1003.updateCode("CANCELLED");
+    constantOrderStatus1003.updateColor("#EF4444");
+    constantOrderStatus1003.updateDisplayOrder(3);
+    await constantOrderStatus1003.auditAs('create model constant OrderStatus(1003)').save(context);
+  } else {
+    let changed = false;
+    if (String((constantOrderStatus1003.platform as any)?.id ?? constantOrderStatus1003.platform) !== String(domainRoot.id)) { constantOrderStatus1003.updatePlatform(domainRoot); changed = true; }
+    if (constantOrderStatus1003.name !== "Cancelled") { constantOrderStatus1003.updateName("Cancelled"); changed = true; }
+    if (constantOrderStatus1003.code !== "CANCELLED") { constantOrderStatus1003.updateCode("CANCELLED"); changed = true; }
+    if (constantOrderStatus1003.color !== "#EF4444") { constantOrderStatus1003.updateColor("#EF4444"); changed = true; }
+    if (constantOrderStatus1003.displayOrder !== 3) { constantOrderStatus1003.updateDisplayOrder(3); changed = true; }
+    if (changed) await constantOrderStatus1003.auditAs('reconcile model constant OrderStatus(1003)').save(context);
+  }
+}

source/browser-sqlite/orders-lib/src/generated-search-models.ts

@@ -0,0 +1,124 @@
+import type { GeneratedSearchModel } from "teaql-ts";
+
+/** Generated trusted naming/type metadata. No query execution or authorization lives here. */
+export const GENERATED_SEARCH_MODELS: Readonly<Record<string, GeneratedSearchModel>> = Object.freeze({
+  "Platform": Object.freeze({
+    fields: Object.freeze({
+     "id": "integer" as const,
+     "name": "string" as const,
+     "version": "integer" as const,
+    }),
+    queryFields: Object.freeze({
+     "id": "id",
+     "name": "name",
+     "version": "version",
+    }),
+    relations: Object.freeze({
+      "orderStatusList": "OrderStatus",
+      "customerList": "Customer",
+    }),
+  }),
+  "OrderStatus": Object.freeze({
+    fields: Object.freeze({
+     "platform": "integer" as const,
+     "id": "integer" as const,
+     "name": "string" as const,
+     "code": "string" as const,
+     "color": "string" as const,
+     "display_order": "integer" as const,
+     "displayOrder": "integer" as const,
+     "version": "integer" as const,
+    }),
+    queryFields: Object.freeze({
+     "platform": "platform",
+     "id": "id",
+     "name": "name",
+     "code": "code",
+     "color": "color",
+     "display_order": "displayOrder",
+     "displayOrder": "displayOrder",
+     "version": "version",
+    }),
+    relations: Object.freeze({
+     "platform": "Platform",
+      "customerOrderList": "CustomerOrder",
+    }),
+  }),
+  "Customer": Object.freeze({
+    fields: Object.freeze({
+     "id": "integer" as const,
+     "platform": "integer" as const,
+     "name": "string" as const,
+     "version": "integer" as const,
+    }),
+    queryFields: Object.freeze({
+     "id": "id",
+     "platform": "platform",
+     "name": "name",
+     "version": "version",
+    }),
+    relations: Object.freeze({
+     "platform": "Platform",
+      "customerOrderList": "CustomerOrder",
+    }),
+  }),
+  "CustomerOrder": Object.freeze({
+    fields: Object.freeze({
+     "id": "integer" as const,
+     "customer": "integer" as const,
+     "status": "integer" as const,
+     "order_number": "string" as const,
+     "orderNumber": "string" as const,
+     "order_date": "date" as const,
+     "orderDate": "date" as const,
+     "total_amount": "decimal" as const,
+     "totalAmount": "decimal" as const,
+     "version": "integer" as const,
+    }),
+    queryFields: Object.freeze({
+     "id": "id",
+     "customer": "customer",
+     "status": "status",
+     "order_number": "orderNumber",
+     "orderNumber": "orderNumber",
+     "order_date": "orderDate",
+     "orderDate": "orderDate",
+     "total_amount": "totalAmount",
+     "totalAmount": "totalAmount",
+     "version": "version",
+    }),
+    relations: Object.freeze({
+     "customer": "Customer",
+     "status": "OrderStatus",
+      "orderItemList": "OrderItem",
+    }),
+  }),
+  "OrderItem": Object.freeze({
+    fields: Object.freeze({
+     "id": "integer" as const,
+     "customer_order": "integer" as const,
+     "customerOrder": "integer" as const,
+     "product_name": "string" as const,
+     "productName": "string" as const,
+     "quantity": "integer" as const,
+     "unit_price": "decimal" as const,
+     "unitPrice": "decimal" as const,
+     "version": "integer" as const,
+    }),
+    queryFields: Object.freeze({
+     "id": "id",
+     "customer_order": "customerOrder",
+     "customerOrder": "customerOrder",
+     "product_name": "productName",
+     "productName": "productName",
+     "quantity": "quantity",
+     "unit_price": "unitPrice",
+     "unitPrice": "unitPrice",
+     "version": "version",
+    }),
+    relations: Object.freeze({
+     "customer_order": "CustomerOrder",
+     "customerOrder": "CustomerOrder",
+    }),
+  }),
+});

source/browser-sqlite/orders-lib/src/generated/E.ts

@@ -0,0 +1,859 @@
+import { Platform } from './models/Platform';
+import { OrderStatus } from './models/OrderStatus';
+import { Customer } from './models/Customer';
+import { CustomerOrder } from './models/CustomerOrder';
+import { OrderItem } from './models/OrderItem';
+
+export class TeaQLNotLoadedError extends Error {
+    readonly details: Record<string, unknown>;
+
+    constructor(
+        readonly root: string,
+        readonly accessPath: string,
+        readonly breakPoint: string,
+    ) {
+        const suggestedFix = `select${breakPoint.charAt(0).toUpperCase()}${breakPoint.slice(1)}(...)`;
+        const details = {
+            error: 'TeaQLNotLoadedError',
+            root,
+            accessPath: accessPath.split('.'),
+            breakPoint,
+            missingPreload: [breakPoint],
+            suggestedFix,
+            severity: 'error',
+            humanMessage: `访问 ${root}.${accessPath} 时缺少预加载。请在查询中加入 ${suggestedFix}`,
+        };
+        super(JSON.stringify(details));
+        this.name = 'TeaQLNotLoadedError';
+        this.details = details;
+    }
+}
+
+function expressionPath(prefix: string, field: string): string {
+    return prefix ? `${prefix}.${field}` : field;
+}
+
+export class ValueExpression<T> {
+    constructor(
+        private readonly value: T | null | undefined,
+        private readonly present = true,
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    static missing<T>(): ValueExpression<T> {
+        return new ValueExpression<T>(undefined, false);
+    }
+
+    static notLoaded<T>(error: TeaQLNotLoadedError): ValueExpression<T> {
+        return new ValueExpression<T>(undefined, false, error);
+    }
+
+    eval(): T | null | undefined {
+        if (this.notLoaded) throw this.notLoaded;
+        return this.present ? this.value : undefined;
+    }
+
+    isPresent(): boolean {
+        if (this.notLoaded) throw this.notLoaded;
+        return this.present;
+    }
+
+    orElse(fallback: T): T {
+        const value = this.eval();
+        return this.present && value != null ? value : fallback;
+    }
+}
+
+export class PlatformExpression {
+    constructor(
+        private readonly value: Platform | null | undefined,
+        private readonly root = 'Platform(null)',
+        private readonly path = '',
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    eval(): Platform | null | undefined {
+        if (this.notLoaded) throw this.notLoaded;
+        return this.value;
+    }
+
+    id(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'id');
+        if (!this.value.isLoaded('id')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'id'),
+            );
+        }
+        return new ValueExpression<string>(this.value.id);
+    }
+
+    name(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'name');
+        if (!this.value.isLoaded('name')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'name'),
+            );
+        }
+        return new ValueExpression<string>(this.value.name);
+    }
+
+    version(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<number>();
+        const path = expressionPath(this.path, 'version');
+        if (!this.value.isLoaded('version')) {
+            return ValueExpression.notLoaded<number>(
+                new TeaQLNotLoadedError(this.root, path, 'version'),
+            );
+        }
+        return new ValueExpression<number>(this.value.version);
+    }
+
+
+
+    orderStatusList(): OrderStatusListExpression {
+        const path = expressionPath(this.path, 'orderStatusList');
+        if (this.notLoaded) {
+            return new OrderStatusListExpression([], this.root, path, false, this.notLoaded);
+        }
+        if (!this.value) return OrderStatusListExpression.missing(this.root, path);
+        if (!this.value.isLoaded('orderStatusList')) {
+            return new OrderStatusListExpression([], this.root, path, false,
+                new TeaQLNotLoadedError(this.root, path, 'orderStatusList'));
+        }
+        return new OrderStatusListExpression(
+            this.value.orderStatusList(), this.root, path,
+        );
+    }
+
+    customerList(): CustomerListExpression {
+        const path = expressionPath(this.path, 'customerList');
+        if (this.notLoaded) {
+            return new CustomerListExpression([], this.root, path, false, this.notLoaded);
+        }
+        if (!this.value) return CustomerListExpression.missing(this.root, path);
+        if (!this.value.isLoaded('customerList')) {
+            return new CustomerListExpression([], this.root, path, false,
+                new TeaQLNotLoadedError(this.root, path, 'customerList'));
+        }
+        return new CustomerListExpression(
+            this.value.customerList(), this.root, path,
+        );
+    }
+}
+
+export class OrderStatusExpression {
+    constructor(
+        private readonly value: OrderStatus | null | undefined,
+        private readonly root = 'OrderStatus(null)',
+        private readonly path = '',
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    eval(): OrderStatus | null | undefined {
+        if (this.notLoaded) throw this.notLoaded;
+        return this.value;
+    }
+
+    id(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'id');
+        if (!this.value.isLoaded('id')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'id'),
+            );
+        }
+        return new ValueExpression<string>(this.value.id);
+    }
+
+    name(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'name');
+        if (!this.value.isLoaded('name')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'name'),
+            );
+        }
+        return new ValueExpression<string>(this.value.name);
+    }
+
+    code(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'code');
+        if (!this.value.isLoaded('code')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'code'),
+            );
+        }
+        return new ValueExpression<string>(this.value.code);
+    }
+
+    color(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'color');
+        if (!this.value.isLoaded('color')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'color'),
+            );
+        }
+        return new ValueExpression<string>(this.value.color);
+    }
+
+    displayOrder(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<number>();
+        const path = expressionPath(this.path, 'displayOrder');
+        if (!this.value.isLoaded('displayOrder')) {
+            return ValueExpression.notLoaded<number>(
+                new TeaQLNotLoadedError(this.root, path, 'displayOrder'),
+            );
+        }
+        return new ValueExpression<number>(this.value.displayOrder);
+    }
+
+    version(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<number>();
+        const path = expressionPath(this.path, 'version');
+        if (!this.value.isLoaded('version')) {
+            return ValueExpression.notLoaded<number>(
+                new TeaQLNotLoadedError(this.root, path, 'version'),
+            );
+        }
+        return new ValueExpression<number>(this.value.version);
+    }
+
+    platformId(): ValueExpression<string | number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string | number>();
+        const path = expressionPath(this.path, 'platform');
+        if (!this.value.isLoaded('platform')) {
+            return ValueExpression.notLoaded<string | number>(
+                new TeaQLNotLoadedError(this.root, path, 'platform'),
+            );
+        }
+        return new ValueExpression<string | number>(
+            this.value.platform as string | number | undefined,
+        );
+    }
+
+    platform(): PlatformExpression {
+        const path = expressionPath(this.path, 'platform');
+        if (this.notLoaded) {
+            return new PlatformExpression(undefined, this.root, path, this.notLoaded);
+        }
+        if (!this.value) return new PlatformExpression(undefined, this.root, path);
+        if (!this.value.isLoaded('platform')) {
+            return new PlatformExpression(undefined, this.root, path,
+                new TeaQLNotLoadedError(this.root, path, 'platform'));
+        }
+        const relation = this.value.platform;
+        const target = relation == null
+            ? undefined
+            : relation instanceof Platform
+                ? relation
+                : Platform.fromRecord({ id: relation });
+        return new PlatformExpression(target, this.root, path);
+    }
+
+    customerOrderList(): CustomerOrderListExpression {
+        const path = expressionPath(this.path, 'customerOrderList');
+        if (this.notLoaded) {
+            return new CustomerOrderListExpression([], this.root, path, false, this.notLoaded);
+        }
+        if (!this.value) return CustomerOrderListExpression.missing(this.root, path);
+        if (!this.value.isLoaded('customerOrderList')) {
+            return new CustomerOrderListExpression([], this.root, path, false,
+                new TeaQLNotLoadedError(this.root, path, 'customerOrderList'));
+        }
+        return new CustomerOrderListExpression(
+            this.value.customerOrderList(), this.root, path,
+        );
+    }
+}
+
+export class CustomerExpression {
+    constructor(
+        private readonly value: Customer | null | undefined,
+        private readonly root = 'Customer(null)',
+        private readonly path = '',
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    eval(): Customer | null | undefined {
+        if (this.notLoaded) throw this.notLoaded;
+        return this.value;
+    }
+
+    id(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'id');
+        if (!this.value.isLoaded('id')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'id'),
+            );
+        }
+        return new ValueExpression<string>(this.value.id);
+    }
+
+    name(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'name');
+        if (!this.value.isLoaded('name')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'name'),
+            );
+        }
+        return new ValueExpression<string>(this.value.name);
+    }
+
+    version(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<number>();
+        const path = expressionPath(this.path, 'version');
+        if (!this.value.isLoaded('version')) {
+            return ValueExpression.notLoaded<number>(
+                new TeaQLNotLoadedError(this.root, path, 'version'),
+            );
+        }
+        return new ValueExpression<number>(this.value.version);
+    }
+
+    platformId(): ValueExpression<string | number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string | number>();
+        const path = expressionPath(this.path, 'platform');
+        if (!this.value.isLoaded('platform')) {
+            return ValueExpression.notLoaded<string | number>(
+                new TeaQLNotLoadedError(this.root, path, 'platform'),
+            );
+        }
+        return new ValueExpression<string | number>(
+            this.value.platform as string | number | undefined,
+        );
+    }
+
+    platform(): PlatformExpression {
+        const path = expressionPath(this.path, 'platform');
+        if (this.notLoaded) {
+            return new PlatformExpression(undefined, this.root, path, this.notLoaded);
+        }
+        if (!this.value) return new PlatformExpression(undefined, this.root, path);
+        if (!this.value.isLoaded('platform')) {
+            return new PlatformExpression(undefined, this.root, path,
+                new TeaQLNotLoadedError(this.root, path, 'platform'));
+        }
+        const relation = this.value.platform;
+        const target = relation == null
+            ? undefined
+            : relation instanceof Platform
+                ? relation
+                : Platform.fromRecord({ id: relation });
+        return new PlatformExpression(target, this.root, path);
+    }
+
+    customerOrderList(): CustomerOrderListExpression {
+        const path = expressionPath(this.path, 'customerOrderList');
+        if (this.notLoaded) {
+            return new CustomerOrderListExpression([], this.root, path, false, this.notLoaded);
+        }
+        if (!this.value) return CustomerOrderListExpression.missing(this.root, path);
+        if (!this.value.isLoaded('customerOrderList')) {
+            return new CustomerOrderListExpression([], this.root, path, false,
+                new TeaQLNotLoadedError(this.root, path, 'customerOrderList'));
+        }
+        return new CustomerOrderListExpression(
+            this.value.customerOrderList(), this.root, path,
+        );
+    }
+}
+
+export class CustomerOrderExpression {
+    constructor(
+        private readonly value: CustomerOrder | null | undefined,
+        private readonly root = 'CustomerOrder(null)',
+        private readonly path = '',
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    eval(): CustomerOrder | null | undefined {
+        if (this.notLoaded) throw this.notLoaded;
+        return this.value;
+    }
+
+    id(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'id');
+        if (!this.value.isLoaded('id')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'id'),
+            );
+        }
+        return new ValueExpression<string>(this.value.id);
+    }
+
+    orderNumber(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'orderNumber');
+        if (!this.value.isLoaded('orderNumber')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'orderNumber'),
+            );
+        }
+        return new ValueExpression<string>(this.value.orderNumber);
+    }
+
+    orderDate(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'orderDate');
+        if (!this.value.isLoaded('orderDate')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'orderDate'),
+            );
+        }
+        return new ValueExpression<string>(this.value.orderDate);
+    }
+
+    totalAmount(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<number>();
+        const path = expressionPath(this.path, 'totalAmount');
+        if (!this.value.isLoaded('totalAmount')) {
+            return ValueExpression.notLoaded<number>(
+                new TeaQLNotLoadedError(this.root, path, 'totalAmount'),
+            );
+        }
+        return new ValueExpression<number>(this.value.totalAmount);
+    }
+
+    version(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<number>();
+        const path = expressionPath(this.path, 'version');
+        if (!this.value.isLoaded('version')) {
+            return ValueExpression.notLoaded<number>(
+                new TeaQLNotLoadedError(this.root, path, 'version'),
+            );
+        }
+        return new ValueExpression<number>(this.value.version);
+    }
+
+    customerId(): ValueExpression<string | number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string | number>();
+        const path = expressionPath(this.path, 'customer');
+        if (!this.value.isLoaded('customer')) {
+            return ValueExpression.notLoaded<string | number>(
+                new TeaQLNotLoadedError(this.root, path, 'customer'),
+            );
+        }
+        return new ValueExpression<string | number>(
+            this.value.customer as string | number | undefined,
+        );
+    }
+
+    statusId(): ValueExpression<string | number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string | number>();
+        const path = expressionPath(this.path, 'status');
+        if (!this.value.isLoaded('status')) {
+            return ValueExpression.notLoaded<string | number>(
+                new TeaQLNotLoadedError(this.root, path, 'status'),
+            );
+        }
+        return new ValueExpression<string | number>(
+            this.value.status as string | number | undefined,
+        );
+    }
+
+    customer(): CustomerExpression {
+        const path = expressionPath(this.path, 'customer');
+        if (this.notLoaded) {
+            return new CustomerExpression(undefined, this.root, path, this.notLoaded);
+        }
+        if (!this.value) return new CustomerExpression(undefined, this.root, path);
+        if (!this.value.isLoaded('customer')) {
+            return new CustomerExpression(undefined, this.root, path,
+                new TeaQLNotLoadedError(this.root, path, 'customer'));
+        }
+        const relation = this.value.customer;
+        const target = relation == null
+            ? undefined
+            : relation instanceof Customer
+                ? relation
+                : Customer.fromRecord({ id: relation });
+        return new CustomerExpression(target, this.root, path);
+    }
+
+    status(): OrderStatusExpression {
+        const path = expressionPath(this.path, 'status');
+        if (this.notLoaded) {
+            return new OrderStatusExpression(undefined, this.root, path, this.notLoaded);
+        }
+        if (!this.value) return new OrderStatusExpression(undefined, this.root, path);
+        if (!this.value.isLoaded('status')) {
+            return new OrderStatusExpression(undefined, this.root, path,
+                new TeaQLNotLoadedError(this.root, path, 'status'));
+        }
+        const relation = this.value.status;
+        const target = relation == null
+            ? undefined
+            : relation instanceof OrderStatus
+                ? relation
+                : OrderStatus.fromRecord({ id: relation });
+        return new OrderStatusExpression(target, this.root, path);
+    }
+
+    orderItemList(): OrderItemListExpression {
+        const path = expressionPath(this.path, 'orderItemList');
+        if (this.notLoaded) {
+            return new OrderItemListExpression([], this.root, path, false, this.notLoaded);
+        }
+        if (!this.value) return OrderItemListExpression.missing(this.root, path);
+        if (!this.value.isLoaded('orderItemList')) {
+            return new OrderItemListExpression([], this.root, path, false,
+                new TeaQLNotLoadedError(this.root, path, 'orderItemList'));
+        }
+        return new OrderItemListExpression(
+            this.value.orderItemList(), this.root, path,
+        );
+    }
+}
+
+export class OrderItemExpression {
+    constructor(
+        private readonly value: OrderItem | null | undefined,
+        private readonly root = 'OrderItem(null)',
+        private readonly path = '',
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    eval(): OrderItem | null | undefined {
+        if (this.notLoaded) throw this.notLoaded;
+        return this.value;
+    }
+
+    id(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'id');
+        if (!this.value.isLoaded('id')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'id'),
+            );
+        }
+        return new ValueExpression<string>(this.value.id);
+    }
+
+    productName(): ValueExpression<string> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string>();
+        const path = expressionPath(this.path, 'productName');
+        if (!this.value.isLoaded('productName')) {
+            return ValueExpression.notLoaded<string>(
+                new TeaQLNotLoadedError(this.root, path, 'productName'),
+            );
+        }
+        return new ValueExpression<string>(this.value.productName);
+    }
+
+    quantity(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<number>();
+        const path = expressionPath(this.path, 'quantity');
+        if (!this.value.isLoaded('quantity')) {
+            return ValueExpression.notLoaded<number>(
+                new TeaQLNotLoadedError(this.root, path, 'quantity'),
+            );
+        }
+        return new ValueExpression<number>(this.value.quantity);
+    }
+
+    unitPrice(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<number>();
+        const path = expressionPath(this.path, 'unitPrice');
+        if (!this.value.isLoaded('unitPrice')) {
+            return ValueExpression.notLoaded<number>(
+                new TeaQLNotLoadedError(this.root, path, 'unitPrice'),
+            );
+        }
+        return new ValueExpression<number>(this.value.unitPrice);
+    }
+
+    version(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<number>();
+        const path = expressionPath(this.path, 'version');
+        if (!this.value.isLoaded('version')) {
+            return ValueExpression.notLoaded<number>(
+                new TeaQLNotLoadedError(this.root, path, 'version'),
+            );
+        }
+        return new ValueExpression<number>(this.value.version);
+    }
+
+    customerOrderId(): ValueExpression<string | number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<string | number>(this.notLoaded);
+        if (!this.value) return ValueExpression.missing<string | number>();
+        const path = expressionPath(this.path, 'customerOrder');
+        if (!this.value.isLoaded('customerOrder')) {
+            return ValueExpression.notLoaded<string | number>(
+                new TeaQLNotLoadedError(this.root, path, 'customerOrder'),
+            );
+        }
+        return new ValueExpression<string | number>(
+            this.value.customerOrder as string | number | undefined,
+        );
+    }
+
+    customerOrder(): CustomerOrderExpression {
+        const path = expressionPath(this.path, 'customerOrder');
+        if (this.notLoaded) {
+            return new CustomerOrderExpression(undefined, this.root, path, this.notLoaded);
+        }
+        if (!this.value) return new CustomerOrderExpression(undefined, this.root, path);
+        if (!this.value.isLoaded('customerOrder')) {
+            return new CustomerOrderExpression(undefined, this.root, path,
+                new TeaQLNotLoadedError(this.root, path, 'customerOrder'));
+        }
+        const relation = this.value.customerOrder;
+        const target = relation == null
+            ? undefined
+            : relation instanceof CustomerOrder
+                ? relation
+                : CustomerOrder.fromRecord({ id: relation });
+        return new CustomerOrderExpression(target, this.root, path);
+    }
+
+}
+
+export class PlatformListExpression {
+    constructor(
+        private readonly items: readonly Platform[],
+        private readonly root = 'Platform(null)',
+        private readonly path = '',
+        private readonly present = true,
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    static missing(root?: string, path = ''): PlatformListExpression {
+        return new PlatformListExpression([], root, path, false);
+    }
+
+    size(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        return this.present
+            ? new ValueExpression<number>(this.items.length)
+            : ValueExpression.missing<number>();
+    }
+
+    first(): PlatformExpression {
+        return this.get(0);
+    }
+
+    get(index: number): PlatformExpression {
+        const itemPath = expressionPath(this.path, `get(${index})`);
+        if (this.notLoaded) {
+            return new PlatformExpression(undefined, this.root, itemPath, this.notLoaded);
+        }
+        return !this.present || index < 0 || index >= this.items.length
+            ? new PlatformExpression(undefined, this.root, itemPath)
+            : new PlatformExpression(this.items[index], this.root, itemPath);
+    }
+}
+
+export class OrderStatusListExpression {
+    constructor(
+        private readonly items: readonly OrderStatus[],
+        private readonly root = 'OrderStatus(null)',
+        private readonly path = '',
+        private readonly present = true,
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    static missing(root?: string, path = ''): OrderStatusListExpression {
+        return new OrderStatusListExpression([], root, path, false);
+    }
+
+    size(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        return this.present
+            ? new ValueExpression<number>(this.items.length)
+            : ValueExpression.missing<number>();
+    }
+
+    first(): OrderStatusExpression {
+        return this.get(0);
+    }
+
+    get(index: number): OrderStatusExpression {
+        const itemPath = expressionPath(this.path, `get(${index})`);
+        if (this.notLoaded) {
+            return new OrderStatusExpression(undefined, this.root, itemPath, this.notLoaded);
+        }
+        return !this.present || index < 0 || index >= this.items.length
+            ? new OrderStatusExpression(undefined, this.root, itemPath)
+            : new OrderStatusExpression(this.items[index], this.root, itemPath);
+    }
+}
+
+export class CustomerListExpression {
+    constructor(
+        private readonly items: readonly Customer[],
+        private readonly root = 'Customer(null)',
+        private readonly path = '',
+        private readonly present = true,
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    static missing(root?: string, path = ''): CustomerListExpression {
+        return new CustomerListExpression([], root, path, false);
+    }
+
+    size(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        return this.present
+            ? new ValueExpression<number>(this.items.length)
+            : ValueExpression.missing<number>();
+    }
+
+    first(): CustomerExpression {
+        return this.get(0);
+    }
+
+    get(index: number): CustomerExpression {
+        const itemPath = expressionPath(this.path, `get(${index})`);
+        if (this.notLoaded) {
+            return new CustomerExpression(undefined, this.root, itemPath, this.notLoaded);
+        }
+        return !this.present || index < 0 || index >= this.items.length
+            ? new CustomerExpression(undefined, this.root, itemPath)
+            : new CustomerExpression(this.items[index], this.root, itemPath);
+    }
+}
+
+export class CustomerOrderListExpression {
+    constructor(
+        private readonly items: readonly CustomerOrder[],
+        private readonly root = 'CustomerOrder(null)',
+        private readonly path = '',
+        private readonly present = true,
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    static missing(root?: string, path = ''): CustomerOrderListExpression {
+        return new CustomerOrderListExpression([], root, path, false);
+    }
+
+    size(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        return this.present
+            ? new ValueExpression<number>(this.items.length)
+            : ValueExpression.missing<number>();
+    }
+
+    first(): CustomerOrderExpression {
+        return this.get(0);
+    }
+
+    get(index: number): CustomerOrderExpression {
+        const itemPath = expressionPath(this.path, `get(${index})`);
+        if (this.notLoaded) {
+            return new CustomerOrderExpression(undefined, this.root, itemPath, this.notLoaded);
+        }
+        return !this.present || index < 0 || index >= this.items.length
+            ? new CustomerOrderExpression(undefined, this.root, itemPath)
+            : new CustomerOrderExpression(this.items[index], this.root, itemPath);
+    }
+}
+
+export class OrderItemListExpression {
+    constructor(
+        private readonly items: readonly OrderItem[],
+        private readonly root = 'OrderItem(null)',
+        private readonly path = '',
+        private readonly present = true,
+        private readonly notLoaded?: TeaQLNotLoadedError,
+    ) {}
+
+    static missing(root?: string, path = ''): OrderItemListExpression {
+        return new OrderItemListExpression([], root, path, false);
+    }
+
+    size(): ValueExpression<number> {
+        if (this.notLoaded) return ValueExpression.notLoaded<number>(this.notLoaded);
+        return this.present
+            ? new ValueExpression<number>(this.items.length)
+            : ValueExpression.missing<number>();
+    }
+
+    first(): OrderItemExpression {
+        return this.get(0);
+    }
+
+    get(index: number): OrderItemExpression {
+        const itemPath = expressionPath(this.path, `get(${index})`);
+        if (this.notLoaded) {
+            return new OrderItemExpression(undefined, this.root, itemPath, this.notLoaded);
+        }
+        return !this.present || index < 0 || index >= this.items.length
+            ? new OrderItemExpression(undefined, this.root, itemPath)
+            : new OrderItemExpression(this.items[index], this.root, itemPath);
+    }
+}
+
+export class E {
+    static platform(
+        value: Platform | null | undefined,
+    ): PlatformExpression {
+        return new PlatformExpression(
+            value, `Platform(id=${value?.id ?? 'null'})`,
+        );
+    }
+
+    static orderStatus(
+        value: OrderStatus | null | undefined,
+    ): OrderStatusExpression {
+        return new OrderStatusExpression(
+            value, `OrderStatus(id=${value?.id ?? 'null'})`,
+        );
+    }
+
+    static customer(
+        value: Customer | null | undefined,
+    ): CustomerExpression {
+        return new CustomerExpression(
+            value, `Customer(id=${value?.id ?? 'null'})`,
+        );
+    }
+
+    static customerOrder(
+        value: CustomerOrder | null | undefined,
+    ): CustomerOrderExpression {
+        return new CustomerOrderExpression(
+            value, `CustomerOrder(id=${value?.id ?? 'null'})`,
+        );
+    }
+
+    static orderItem(
+        value: OrderItem | null | undefined,
+    ): OrderItemExpression {
+        return new OrderItemExpression(
+            value, `OrderItem(id=${value?.id ?? 'null'})`,
+        );
+    }
+}

source/browser-sqlite/orders-lib/src/generated/Q.ts

@@ -0,0 +1,44 @@
+import { TeaQLClient } from '../teaql-ts';
+import { PlatformRequest } from './requests/PlatformRequest';
+import { OrderStatusRequest } from './requests/OrderStatusRequest';
+import { CustomerRequest } from './requests/CustomerRequest';
+import { CustomerOrderRequest } from './requests/CustomerOrderRequest';
+import { OrderItemRequest } from './requests/OrderItemRequest';
+
+export class Q {
+    static platforms(): PlatformRequest {
+        return new PlatformRequest(false);
+    }
+
+    static platformsWithMinimalFields(): PlatformRequest {
+        return new PlatformRequest(true);
+    }
+    static orderStatuses(): OrderStatusRequest {
+        return new OrderStatusRequest(false);
+    }
+
+    static orderStatusesWithMinimalFields(): OrderStatusRequest {
+        return new OrderStatusRequest(true);
+    }
+    static customers(): CustomerRequest {
+        return new CustomerRequest(false);
+    }
+
+    static customersWithMinimalFields(): CustomerRequest {
+        return new CustomerRequest(true);
+    }
+    static customerOrders(): CustomerOrderRequest {
+        return new CustomerOrderRequest(false);
+    }
+
+    static customerOrdersWithMinimalFields(): CustomerOrderRequest {
+        return new CustomerOrderRequest(true);
+    }
+    static orderItems(): OrderItemRequest {
+        return new OrderItemRequest(false);
+    }
+
+    static orderItemsWithMinimalFields(): OrderItemRequest {
+        return new OrderItemRequest(true);
+    }
+}

source/browser-sqlite/orders-lib/src/generated/models/Customer.ts

@@ -0,0 +1,252 @@
+import { CheckException, EntityKey, EntityRoot, GraphMutationSession, LoadedScalarSnapshot, MutationIntent, MutationTraceScope, ObjectLocation, TeaQLDataService, UserContext } from '../../teaql-ts';
+import { Platform } from './Platform';
+import { CustomerOrder } from './CustomerOrder';
+
+export class Customer {
+    private static teaqlTemporaryId = 0;
+        id?: string;
+        platform?: Platform | string;
+        name?: string;
+        version?: number;
+
+    constructor(init?: Partial<Customer>) {
+        Object.defineProperty(this, "_action", { value: init && init.id ? "Update" : "Create", writable: true, enumerable: false });
+        Object.defineProperty(this, "_comment", { value: undefined, writable: true, enumerable: false });
+        Object.defineProperty(this, "_fullyLoaded", { value: !init || !init.id, writable: true, enumerable: false });
+        Object.defineProperty(this, "_loadedFields", { value: new Set(Object.keys(init || {})), writable: true, enumerable: false });
+        Object.defineProperty(this, "_root", { value: new EntityRoot(), writable: true, enumerable: false });
+        Object.defineProperty(this, "_ledgerId", { value: init?.id ?? --Customer.teaqlTemporaryId, writable: true, enumerable: false });
+        Object.defineProperty(this, "_customerOrderList", { value: [], writable: true, enumerable: false });
+        if (init) {
+            const fields: Record<string, unknown> = { ...(init as Record<string, unknown>) };
+            delete fields["customerOrderList"];
+            Object.assign(this, fields);
+            if ((init as any).platform && typeof (init as any).platform === "object") {
+                this.platform = (init as any).platform instanceof Platform
+                    ? (init as any).platform
+                    : Platform.fromRecord((init as any).platform);
+                this.markLoaded("platform");
+            }
+            if (Array.isArray((init as any).customerOrderList)) {
+                (this as any)._customerOrderList = (init as any).customerOrderList.map(
+                    (child: unknown) => child instanceof CustomerOrder
+                        ? child
+                        : CustomerOrder.fromRecord(child as Record<string, unknown>),
+                );
+                this.markLoaded("customerOrderList");
+            }
+        }
+        const key = this.teaqlEntityKey();
+        if ((this as any)._action === "Create") (this as any)._root.markAsNew(key);
+        else if ((this as any).version !== undefined) (this as any)._root.setOriginalVersion(key, Number((this as any).version));
+    }
+
+    private teaqlEntityKey(): EntityKey { return { entity: "Customer", id: (this as any)._ledgerId }; }
+    private teaqlAttachRoot(root: EntityRoot): this {
+        if ((this as any)._root !== root) { root.mergeFrom((this as any)._root); (this as any)._root = root; }
+        for (const child of (this as any)._customerOrderList) child.teaqlAttachRoot(root);
+        return this;
+    }
+
+    static fromRecord(record: Record<string, unknown>, root?: EntityRoot): Customer {
+        const entity = new Customer(record as Partial<Customer>);
+        return root ? entity.teaqlAttachRoot(root) : entity;
+    }
+
+    isLoaded(field: string): boolean {
+        return (this as any)._fullyLoaded || (this as any)._loadedFields.has(field);
+    }
+
+    markLoaded(...fields: string[]): this {
+        for (const field of fields) (this as any)._loadedFields.add(field);
+        return this;
+    }
+
+    markLoadedOnly(...fields: string[]): this {
+        (this as any)._fullyLoaded = false;
+        (this as any)._loadedFields = new Set(fields);
+        return this;
+    }
+
+    static refer(id: string | number): Customer {
+        return new Customer({ id: String(id) } as Partial<Customer>);
+    }
+
+    /** @internal Generated Runtime Module fixed-ID construction capability. */
+    static teaqlBootstrapNew(id: string | number): Customer {
+        return new Customer().updateId(String(id));
+    }
+
+    markForDeletion(): this {
+        (this as any)._action = "Delete";
+        (this as any)._root.markAsDeleted(this.teaqlEntityKey());
+        return this;
+    }
+
+    auditAs(comment: string): this {
+        if (!comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() requires a non-empty reason");
+        }
+        (this as any)._comment = comment;
+        return this;
+    }
+
+    async save(context: UserContext): Promise<Customer> {
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return service.executeGraphSave(new MutationIntent((this as any)._comment), async (graph) => {
+            this.teaqlPreflightGraph(context, service, graph);
+            return this.teaqlSaveWithinGraph(context, service, graph);
+        });
+    }
+
+    /** @internal Validates and fixes the complete graph before its first mutation. */
+    teaqlPreflightGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): void {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        if (action === "Update") {
+            const notLoaded = [{ member: "id", canonical: "id" }, { member: "platform", canonical: "platform" }, { member: "name", canonical: "name" }, { member: "version", canonical: "version" }]
+                .find(field => !this.isLoaded(field.member));
+            if (notLoaded) {
+                throw new CheckException([{
+                    ruleId: "invalid_type",
+                    location: ObjectLocation.property(notLoaded.canonical),
+                    message: "Mutation requires a fully loaded entity",
+                }]);
+            }
+        }
+        const request = graph.request({
+            entity: "Customer", action,
+            payload: action === "Update"
+                ? (this as any)._root.change(this.teaqlEntityKey())
+                : this.teaqlMutationPayload(),
+            id: (this as any).id, version: (this as any).version,
+            comment: (this as any)._comment,
+            ledgerKey: this.teaqlEntityKey(), ledgerRoot: (this as any)._root,
+        }, parent, (this as any)._comment).withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        service.preflightMutation(request);
+        const scope = request.scopeFor(this.teaqlEntityKey());
+        for (const [index, child] of (this as any)._customerOrderList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updateCustomer(this);
+            try { child.teaqlPreflightGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("customer_order_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+    }
+
+    /** @internal Used by generated relation cascades inside the root graph transaction. */
+    async teaqlSaveWithinGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): Promise<Customer> {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        const ledgerPayload = (this as any)._root.change(this.teaqlEntityKey());
+        const mutation = {
+            entity: "Customer",
+            action: (this as any)._action,
+            payload: action === "Update" ? ledgerPayload : this.teaqlMutationPayload(),
+            id: (this as any).id,
+            version: (this as any).version,
+            comment: (this as any)._comment
+            ,ledgerKey: this.teaqlEntityKey()
+            ,ledgerRoot: (this as any)._root
+        };
+        const request = graph.request(mutation, parent, (this as any)._comment)
+            .withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        const result = await service.executeMutation(request);
+        for (const [field, value] of Object.entries(mutation.payload as Record<string, unknown>)) {
+            if (field !== "id" && field !== "version") (this as any)._root.set(this.teaqlEntityKey(), field, value);
+        }
+        if (!result.persistedRecord) {
+            throw new Error("Mutation did not return the authoritative persisted record");
+        }
+        const rollbackState = {
+            payload: this.teaqlMutationPayload(),
+            ledgerId: (this as any)._ledgerId,
+            action: (this as any)._action,
+            loadedFields: new Set((this as any)._loadedFields),
+            fullyLoaded: (this as any)._fullyLoaded,
+        };
+        const oldKey = this.teaqlEntityKey();
+        Object.assign(this, result.persistedRecord);
+        (this as any)._ledgerId = (this as any).id ?? (this as any)._ledgerId;
+        const newKey = this.teaqlEntityKey();
+        (this as any)._root.rekey(oldKey, newKey);
+        service.afterGraphRollback(() => {
+            Object.assign(this, rollbackState.payload);
+            (this as any)._ledgerId = rollbackState.ledgerId;
+            (this as any)._action = rollbackState.action;
+            (this as any)._loadedFields = rollbackState.loadedFields;
+            (this as any)._fullyLoaded = rollbackState.fullyLoaded;
+            (this as any)._root.rekey(newKey, oldKey);
+        });
+        (this as any)._loadedFields = new Set(Object.keys(result.persistedRecord));
+        (this as any)._fullyLoaded = false;
+        if (mutation.action !== "Delete") (this as any)._action = "Update";
+        const scope = request.scopeFor(newKey);
+        for (const [index, child] of (this as any)._customerOrderList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updateCustomer(this);
+            try { await child.teaqlSaveWithinGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("customer_order_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+        service.afterGraphCommit(() => {
+            (this as any)._root.clearEntity(newKey);
+            if ((this as any).version !== undefined) (this as any)._root.acceptCommittedVersion(newKey, Number((this as any).version));
+        });
+        return this;
+    }
+
+    private teaqlMutationPayload(): Record<string, unknown> {
+        return {
+            "id": this.id,
+            "platform": this.platform,
+            "name": this.name,
+            "version": this.version
+        };
+    }
+
+    updateId(value: string): this {
+        this.id = value;
+        this.markLoaded("id");
+        (this as any)._root.set(this.teaqlEntityKey(), "id", value);
+        return this;
+    }
+
+    updateName(value: string): this {
+        this.name = value;
+        this.markLoaded("name");
+        (this as any)._root.set(this.teaqlEntityKey(), "name", value);
+        return this;
+    }
+
+    updateVersion(value: number): this {
+        this.version = value;
+        this.markLoaded("version");
+        (this as any)._root.set(this.teaqlEntityKey(), "version", value);
+        return this;
+    }
+    updatePlatform(value: any): this {
+        this.platform = value?.id ?? value;
+        this.markLoaded("platform");
+        (this as any)._root.set(this.teaqlEntityKey(), "platform", this.platform);
+        return this;
+    }
+
+    customerOrderList(): CustomerOrder[] {
+        return (this as any)._customerOrderList;
+    }
+}

source/browser-sqlite/orders-lib/src/generated/models/CustomerOrder.ts

@@ -0,0 +1,305 @@
+import { CheckException, EntityKey, EntityRoot, GraphMutationSession, LoadedScalarSnapshot, MutationIntent, MutationTraceScope, ObjectLocation, TeaQLDataService, UserContext } from '../../teaql-ts';
+import { Customer } from './Customer';
+import { OrderStatus } from './OrderStatus';
+import { OrderItem } from './OrderItem';
+
+export class CustomerOrder {
+    private static teaqlTemporaryId = 0;
+        id?: string;
+        customer?: Customer | string;
+        status?: OrderStatus | string;
+        orderNumber?: string;
+        orderDate?: string;
+        totalAmount?: number;
+        version?: number;
+
+    constructor(init?: Partial<CustomerOrder>) {
+        Object.defineProperty(this, "_action", { value: init && init.id ? "Update" : "Create", writable: true, enumerable: false });
+        Object.defineProperty(this, "_comment", { value: undefined, writable: true, enumerable: false });
+        Object.defineProperty(this, "_fullyLoaded", { value: !init || !init.id, writable: true, enumerable: false });
+        Object.defineProperty(this, "_loadedFields", { value: new Set(Object.keys(init || {})), writable: true, enumerable: false });
+        Object.defineProperty(this, "_root", { value: new EntityRoot(), writable: true, enumerable: false });
+        Object.defineProperty(this, "_ledgerId", { value: init?.id ?? --CustomerOrder.teaqlTemporaryId, writable: true, enumerable: false });
+        Object.defineProperty(this, "_orderItemList", { value: [], writable: true, enumerable: false });
+        if (init) {
+            const fields: Record<string, unknown> = { ...(init as Record<string, unknown>) };
+            delete fields["orderItemList"];
+            Object.assign(this, fields);
+            if ((init as any).customer && typeof (init as any).customer === "object") {
+                this.customer = (init as any).customer instanceof Customer
+                    ? (init as any).customer
+                    : Customer.fromRecord((init as any).customer);
+                this.markLoaded("customer");
+            }
+            if ((init as any).status && typeof (init as any).status === "object") {
+                this.status = (init as any).status instanceof OrderStatus
+                    ? (init as any).status
+                    : OrderStatus.fromRecord((init as any).status);
+                this.markLoaded("status");
+            }
+            if (Array.isArray((init as any).orderItemList)) {
+                (this as any)._orderItemList = (init as any).orderItemList.map(
+                    (child: unknown) => child instanceof OrderItem
+                        ? child
+                        : OrderItem.fromRecord(child as Record<string, unknown>),
+                );
+                this.markLoaded("orderItemList");
+            }
+        }
+        const key = this.teaqlEntityKey();
+        if ((this as any)._action === "Create") (this as any)._root.markAsNew(key);
+        else if ((this as any).version !== undefined) (this as any)._root.setOriginalVersion(key, Number((this as any).version));
+    }
+
+    private teaqlEntityKey(): EntityKey { return { entity: "CustomerOrder", id: (this as any)._ledgerId }; }
+    private teaqlAttachRoot(root: EntityRoot): this {
+        if ((this as any)._root !== root) { root.mergeFrom((this as any)._root); (this as any)._root = root; }
+        for (const child of (this as any)._orderItemList) child.teaqlAttachRoot(root);
+        return this;
+    }
+
+    static fromRecord(record: Record<string, unknown>, root?: EntityRoot): CustomerOrder {
+        const entity = new CustomerOrder(record as Partial<CustomerOrder>);
+        return root ? entity.teaqlAttachRoot(root) : entity;
+    }
+
+    isLoaded(field: string): boolean {
+        return (this as any)._fullyLoaded || (this as any)._loadedFields.has(field);
+    }
+
+    markLoaded(...fields: string[]): this {
+        for (const field of fields) (this as any)._loadedFields.add(field);
+        return this;
+    }
+
+    markLoadedOnly(...fields: string[]): this {
+        (this as any)._fullyLoaded = false;
+        (this as any)._loadedFields = new Set(fields);
+        return this;
+    }
+
+    static refer(id: string | number): CustomerOrder {
+        return new CustomerOrder({ id: String(id) } as Partial<CustomerOrder>);
+    }
+
+    /** @internal Generated Runtime Module fixed-ID construction capability. */
+    static teaqlBootstrapNew(id: string | number): CustomerOrder {
+        return new CustomerOrder().updateId(String(id));
+    }
+
+    markForDeletion(): this {
+        (this as any)._action = "Delete";
+        (this as any)._root.markAsDeleted(this.teaqlEntityKey());
+        return this;
+    }
+
+    auditAs(comment: string): this {
+        if (!comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() requires a non-empty reason");
+        }
+        (this as any)._comment = comment;
+        return this;
+    }
+
+    async save(context: UserContext): Promise<CustomerOrder> {
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return service.executeGraphSave(new MutationIntent((this as any)._comment), async (graph) => {
+            this.teaqlPreflightGraph(context, service, graph);
+            return this.teaqlSaveWithinGraph(context, service, graph);
+        });
+    }
+
+    /** @internal Validates and fixes the complete graph before its first mutation. */
+    teaqlPreflightGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): void {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        if (action === "Update") {
+            const notLoaded = [{ member: "id", canonical: "id" }, { member: "customer", canonical: "customer" }, { member: "status", canonical: "status" }, { member: "orderNumber", canonical: "order_number" }, { member: "orderDate", canonical: "order_date" }, { member: "totalAmount", canonical: "total_amount" }, { member: "version", canonical: "version" }]
+                .find(field => !this.isLoaded(field.member));
+            if (notLoaded) {
+                throw new CheckException([{
+                    ruleId: "invalid_type",
+                    location: ObjectLocation.property(notLoaded.canonical),
+                    message: "Mutation requires a fully loaded entity",
+                }]);
+            }
+        }
+        const request = graph.request({
+            entity: "CustomerOrder", action,
+            payload: action === "Update"
+                ? (this as any)._root.change(this.teaqlEntityKey())
+                : this.teaqlMutationPayload(),
+            id: (this as any).id, version: (this as any).version,
+            comment: (this as any)._comment,
+            ledgerKey: this.teaqlEntityKey(), ledgerRoot: (this as any)._root,
+        }, parent, (this as any)._comment).withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        service.preflightMutation(request);
+        const scope = request.scopeFor(this.teaqlEntityKey());
+        for (const [index, child] of (this as any)._orderItemList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updateCustomerOrder(this);
+            try { child.teaqlPreflightGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("order_item_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+    }
+
+    /** @internal Used by generated relation cascades inside the root graph transaction. */
+    async teaqlSaveWithinGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): Promise<CustomerOrder> {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        const ledgerPayload = (this as any)._root.change(this.teaqlEntityKey());
+        const mutation = {
+            entity: "CustomerOrder",
+            action: (this as any)._action,
+            payload: action === "Update" ? ledgerPayload : this.teaqlMutationPayload(),
+            id: (this as any).id,
+            version: (this as any).version,
+            comment: (this as any)._comment
+            ,ledgerKey: this.teaqlEntityKey()
+            ,ledgerRoot: (this as any)._root
+        };
+        const request = graph.request(mutation, parent, (this as any)._comment)
+            .withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        const result = await service.executeMutation(request);
+        for (const [field, value] of Object.entries(mutation.payload as Record<string, unknown>)) {
+            if (field !== "id" && field !== "version") (this as any)._root.set(this.teaqlEntityKey(), field, value);
+        }
+        if (!result.persistedRecord) {
+            throw new Error("Mutation did not return the authoritative persisted record");
+        }
+        const rollbackState = {
+            payload: this.teaqlMutationPayload(),
+            ledgerId: (this as any)._ledgerId,
+            action: (this as any)._action,
+            loadedFields: new Set((this as any)._loadedFields),
+            fullyLoaded: (this as any)._fullyLoaded,
+        };
+        const oldKey = this.teaqlEntityKey();
+        Object.assign(this, result.persistedRecord);
+        (this as any)._ledgerId = (this as any).id ?? (this as any)._ledgerId;
+        const newKey = this.teaqlEntityKey();
+        (this as any)._root.rekey(oldKey, newKey);
+        service.afterGraphRollback(() => {
+            Object.assign(this, rollbackState.payload);
+            (this as any)._ledgerId = rollbackState.ledgerId;
+            (this as any)._action = rollbackState.action;
+            (this as any)._loadedFields = rollbackState.loadedFields;
+            (this as any)._fullyLoaded = rollbackState.fullyLoaded;
+            (this as any)._root.rekey(newKey, oldKey);
+        });
+        (this as any)._loadedFields = new Set(Object.keys(result.persistedRecord));
+        (this as any)._fullyLoaded = false;
+        if (mutation.action !== "Delete") (this as any)._action = "Update";
+        const scope = request.scopeFor(newKey);
+        for (const [index, child] of (this as any)._orderItemList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updateCustomerOrder(this);
+            try { await child.teaqlSaveWithinGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("order_item_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+        service.afterGraphCommit(() => {
+            (this as any)._root.clearEntity(newKey);
+            if ((this as any).version !== undefined) (this as any)._root.acceptCommittedVersion(newKey, Number((this as any).version));
+        });
+        return this;
+    }
+
+    private teaqlMutationPayload(): Record<string, unknown> {
+        return {
+            "id": this.id,
+            "customer": this.customer,
+            "status": this.status,
+            "order_number": this.orderNumber,
+            "order_date": this.orderDate,
+            "total_amount": this.totalAmount,
+            "version": this.version
+        };
+    }
+
+    updateId(value: string): this {
+        this.id = value;
+        this.markLoaded("id");
+        (this as any)._root.set(this.teaqlEntityKey(), "id", value);
+        return this;
+    }
+
+    updateOrderNumber(value: string): this {
+        this.orderNumber = value;
+        this.markLoaded("orderNumber");
+        (this as any)._root.set(this.teaqlEntityKey(), "order_number", value);
+        return this;
+    }
+
+    updateOrderDate(value: string): this {
+        this.orderDate = value;
+        this.markLoaded("orderDate");
+        (this as any)._root.set(this.teaqlEntityKey(), "order_date", value);
+        return this;
+    }
+
+    updateTotalAmount(value: number): this {
+        this.totalAmount = value;
+        this.markLoaded("totalAmount");
+        (this as any)._root.set(this.teaqlEntityKey(), "total_amount", value);
+        return this;
+    }
+
+    updateVersion(value: number): this {
+        this.version = value;
+        this.markLoaded("version");
+        (this as any)._root.set(this.teaqlEntityKey(), "version", value);
+        return this;
+    }
+    updateCustomer(value: any): this {
+        this.customer = value?.id ?? value;
+        this.markLoaded("customer");
+        (this as any)._root.set(this.teaqlEntityKey(), "customer", this.customer);
+        return this;
+    }
+
+
+    updateStatus(value: any): this {
+        this.status = value?.id ?? value;
+        this.markLoaded("status");
+        (this as any)._root.set(this.teaqlEntityKey(), "status", this.status);
+        return this;
+    }
+    public updateStatusToNew(): CustomerOrder {
+        this.status = "1001";
+        this.markLoaded("status");
+        (this as any)._root.set(this.teaqlEntityKey(), "status", this.status);
+        return this;
+    }
+    public updateStatusToPaid(): CustomerOrder {
+        this.status = "1002";
+        this.markLoaded("status");
+        (this as any)._root.set(this.teaqlEntityKey(), "status", this.status);
+        return this;
+    }
+    public updateStatusToCancelled(): CustomerOrder {
+        this.status = "1003";
+        this.markLoaded("status");
+        (this as any)._root.set(this.teaqlEntityKey(), "status", this.status);
+        return this;
+    }
+
+    orderItemList(): OrderItem[] {
+        return (this as any)._orderItemList;
+    }
+}

source/browser-sqlite/orders-lib/src/generated/models/OrderItem.ts

@@ -0,0 +1,231 @@
+import { CheckException, EntityKey, EntityRoot, GraphMutationSession, LoadedScalarSnapshot, MutationIntent, MutationTraceScope, ObjectLocation, TeaQLDataService, UserContext } from '../../teaql-ts';
+import { CustomerOrder } from './CustomerOrder';
+
+export class OrderItem {
+    private static teaqlTemporaryId = 0;
+        id?: string;
+        customerOrder?: CustomerOrder | string;
+        productName?: string;
+        quantity?: number;
+        unitPrice?: number;
+        version?: number;
+
+    constructor(init?: Partial<OrderItem>) {
+        Object.defineProperty(this, "_action", { value: init && init.id ? "Update" : "Create", writable: true, enumerable: false });
+        Object.defineProperty(this, "_comment", { value: undefined, writable: true, enumerable: false });
+        Object.defineProperty(this, "_fullyLoaded", { value: !init || !init.id, writable: true, enumerable: false });
+        Object.defineProperty(this, "_loadedFields", { value: new Set(Object.keys(init || {})), writable: true, enumerable: false });
+        Object.defineProperty(this, "_root", { value: new EntityRoot(), writable: true, enumerable: false });
+        Object.defineProperty(this, "_ledgerId", { value: init?.id ?? --OrderItem.teaqlTemporaryId, writable: true, enumerable: false });
+        if (init) {
+            const fields: Record<string, unknown> = { ...(init as Record<string, unknown>) };
+            Object.assign(this, fields);
+            if ((init as any).customerOrder && typeof (init as any).customerOrder === "object") {
+                this.customerOrder = (init as any).customerOrder instanceof CustomerOrder
+                    ? (init as any).customerOrder
+                    : CustomerOrder.fromRecord((init as any).customerOrder);
+                this.markLoaded("customerOrder");
+            }
+        }
+        const key = this.teaqlEntityKey();
+        if ((this as any)._action === "Create") (this as any)._root.markAsNew(key);
+        else if ((this as any).version !== undefined) (this as any)._root.setOriginalVersion(key, Number((this as any).version));
+    }
+
+    private teaqlEntityKey(): EntityKey { return { entity: "OrderItem", id: (this as any)._ledgerId }; }
+    private teaqlAttachRoot(root: EntityRoot): this {
+        if ((this as any)._root !== root) { root.mergeFrom((this as any)._root); (this as any)._root = root; }
+        return this;
+    }
+
+    static fromRecord(record: Record<string, unknown>, root?: EntityRoot): OrderItem {
+        const entity = new OrderItem(record as Partial<OrderItem>);
+        return root ? entity.teaqlAttachRoot(root) : entity;
+    }
+
+    isLoaded(field: string): boolean {
+        return (this as any)._fullyLoaded || (this as any)._loadedFields.has(field);
+    }
+
+    markLoaded(...fields: string[]): this {
+        for (const field of fields) (this as any)._loadedFields.add(field);
+        return this;
+    }
+
+    markLoadedOnly(...fields: string[]): this {
+        (this as any)._fullyLoaded = false;
+        (this as any)._loadedFields = new Set(fields);
+        return this;
+    }
+
+    static refer(id: string | number): OrderItem {
+        return new OrderItem({ id: String(id) } as Partial<OrderItem>);
+    }
+
+    /** @internal Generated Runtime Module fixed-ID construction capability. */
+    static teaqlBootstrapNew(id: string | number): OrderItem {
+        return new OrderItem().updateId(String(id));
+    }
+
+    markForDeletion(): this {
+        (this as any)._action = "Delete";
+        (this as any)._root.markAsDeleted(this.teaqlEntityKey());
+        return this;
+    }
+
+    auditAs(comment: string): this {
+        if (!comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() requires a non-empty reason");
+        }
+        (this as any)._comment = comment;
+        return this;
+    }
+
+    async save(context: UserContext): Promise<OrderItem> {
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return service.executeGraphSave(new MutationIntent((this as any)._comment), async (graph) => {
+            this.teaqlPreflightGraph(context, service, graph);
+            return this.teaqlSaveWithinGraph(context, service, graph);
+        });
+    }
+
+    /** @internal Validates and fixes the complete graph before its first mutation. */
+    teaqlPreflightGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): void {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        if (action === "Update") {
+            const notLoaded = [{ member: "id", canonical: "id" }, { member: "customerOrder", canonical: "customer_order" }, { member: "productName", canonical: "product_name" }, { member: "quantity", canonical: "quantity" }, { member: "unitPrice", canonical: "unit_price" }, { member: "version", canonical: "version" }]
+                .find(field => !this.isLoaded(field.member));
+            if (notLoaded) {
+                throw new CheckException([{
+                    ruleId: "invalid_type",
+                    location: ObjectLocation.property(notLoaded.canonical),
+                    message: "Mutation requires a fully loaded entity",
+                }]);
+            }
+        }
+        const request = graph.request({
+            entity: "OrderItem", action,
+            payload: action === "Update"
+                ? (this as any)._root.change(this.teaqlEntityKey())
+                : this.teaqlMutationPayload(),
+            id: (this as any).id, version: (this as any).version,
+            comment: (this as any)._comment,
+            ledgerKey: this.teaqlEntityKey(), ledgerRoot: (this as any)._root,
+        }, parent, (this as any)._comment).withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        service.preflightMutation(request);
+        const scope = request.scopeFor(this.teaqlEntityKey());
+    }
+
+    /** @internal Used by generated relation cascades inside the root graph transaction. */
+    async teaqlSaveWithinGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): Promise<OrderItem> {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        const ledgerPayload = (this as any)._root.change(this.teaqlEntityKey());
+        const mutation = {
+            entity: "OrderItem",
+            action: (this as any)._action,
+            payload: action === "Update" ? ledgerPayload : this.teaqlMutationPayload(),
+            id: (this as any).id,
+            version: (this as any).version,
+            comment: (this as any)._comment
+            ,ledgerKey: this.teaqlEntityKey()
+            ,ledgerRoot: (this as any)._root
+        };
+        const request = graph.request(mutation, parent, (this as any)._comment)
+            .withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        const result = await service.executeMutation(request);
+        for (const [field, value] of Object.entries(mutation.payload as Record<string, unknown>)) {
+            if (field !== "id" && field !== "version") (this as any)._root.set(this.teaqlEntityKey(), field, value);
+        }
+        if (!result.persistedRecord) {
+            throw new Error("Mutation did not return the authoritative persisted record");
+        }
+        const rollbackState = {
+            payload: this.teaqlMutationPayload(),
+            ledgerId: (this as any)._ledgerId,
+            action: (this as any)._action,
+            loadedFields: new Set((this as any)._loadedFields),
+            fullyLoaded: (this as any)._fullyLoaded,
+        };
+        const oldKey = this.teaqlEntityKey();
+        Object.assign(this, result.persistedRecord);
+        (this as any)._ledgerId = (this as any).id ?? (this as any)._ledgerId;
+        const newKey = this.teaqlEntityKey();
+        (this as any)._root.rekey(oldKey, newKey);
+        service.afterGraphRollback(() => {
+            Object.assign(this, rollbackState.payload);
+            (this as any)._ledgerId = rollbackState.ledgerId;
+            (this as any)._action = rollbackState.action;
+            (this as any)._loadedFields = rollbackState.loadedFields;
+            (this as any)._fullyLoaded = rollbackState.fullyLoaded;
+            (this as any)._root.rekey(newKey, oldKey);
+        });
+        (this as any)._loadedFields = new Set(Object.keys(result.persistedRecord));
+        (this as any)._fullyLoaded = false;
+        if (mutation.action !== "Delete") (this as any)._action = "Update";
+        const scope = request.scopeFor(newKey);
+        service.afterGraphCommit(() => {
+            (this as any)._root.clearEntity(newKey);
+            if ((this as any).version !== undefined) (this as any)._root.acceptCommittedVersion(newKey, Number((this as any).version));
+        });
+        return this;
+    }
+
+    private teaqlMutationPayload(): Record<string, unknown> {
+        return {
+            "id": this.id,
+            "customer_order": this.customerOrder,
+            "product_name": this.productName,
+            "quantity": this.quantity,
+            "unit_price": this.unitPrice,
+            "version": this.version
+        };
+    }
+
+    updateId(value: string): this {
+        this.id = value;
+        this.markLoaded("id");
+        (this as any)._root.set(this.teaqlEntityKey(), "id", value);
+        return this;
+    }
+
+    updateProductName(value: string): this {
+        this.productName = value;
+        this.markLoaded("productName");
+        (this as any)._root.set(this.teaqlEntityKey(), "product_name", value);
+        return this;
+    }
+
+    updateQuantity(value: number): this {
+        this.quantity = value;
+        this.markLoaded("quantity");
+        (this as any)._root.set(this.teaqlEntityKey(), "quantity", value);
+        return this;
+    }
+
+    updateUnitPrice(value: number): this {
+        this.unitPrice = value;
+        this.markLoaded("unitPrice");
+        (this as any)._root.set(this.teaqlEntityKey(), "unit_price", value);
+        return this;
+    }
+
+    updateVersion(value: number): this {
+        this.version = value;
+        this.markLoaded("version");
+        (this as any)._root.set(this.teaqlEntityKey(), "version", value);
+        return this;
+    }
+    updateCustomerOrder(value: any): this {
+        this.customerOrder = value?.id ?? value;
+        this.markLoaded("customerOrder");
+        (this as any)._root.set(this.teaqlEntityKey(), "customer_order", this.customerOrder);
+        return this;
+    }
+
+}

source/browser-sqlite/orders-lib/src/generated/models/OrderStatus.ts

@@ -0,0 +1,279 @@
+import { CheckException, EntityKey, EntityRoot, GraphMutationSession, LoadedScalarSnapshot, MutationIntent, MutationTraceScope, ObjectLocation, TeaQLDataService, UserContext } from '../../teaql-ts';
+import { Platform } from './Platform';
+import { CustomerOrder } from './CustomerOrder';
+
+export class OrderStatus {
+    private static teaqlTemporaryId = 0;
+        platform?: Platform | string;
+        id?: string;
+        name?: string;
+        code?: string;
+        color?: string;
+        displayOrder?: number;
+        version?: number;
+
+    constructor(init?: Partial<OrderStatus>) {
+        Object.defineProperty(this, "_action", { value: init && init.id ? "Update" : "Create", writable: true, enumerable: false });
+        Object.defineProperty(this, "_comment", { value: undefined, writable: true, enumerable: false });
+        Object.defineProperty(this, "_fullyLoaded", { value: !init || !init.id, writable: true, enumerable: false });
+        Object.defineProperty(this, "_loadedFields", { value: new Set(Object.keys(init || {})), writable: true, enumerable: false });
+        Object.defineProperty(this, "_root", { value: new EntityRoot(), writable: true, enumerable: false });
+        Object.defineProperty(this, "_ledgerId", { value: init?.id ?? --OrderStatus.teaqlTemporaryId, writable: true, enumerable: false });
+        Object.defineProperty(this, "_customerOrderList", { value: [], writable: true, enumerable: false });
+        if (init) {
+            const fields: Record<string, unknown> = { ...(init as Record<string, unknown>) };
+            delete fields["customerOrderList"];
+            Object.assign(this, fields);
+            if ((init as any).platform && typeof (init as any).platform === "object") {
+                this.platform = (init as any).platform instanceof Platform
+                    ? (init as any).platform
+                    : Platform.fromRecord((init as any).platform);
+                this.markLoaded("platform");
+            }
+            if (Array.isArray((init as any).customerOrderList)) {
+                (this as any)._customerOrderList = (init as any).customerOrderList.map(
+                    (child: unknown) => child instanceof CustomerOrder
+                        ? child
+                        : CustomerOrder.fromRecord(child as Record<string, unknown>),
+                );
+                this.markLoaded("customerOrderList");
+            }
+        }
+        const key = this.teaqlEntityKey();
+        if ((this as any)._action === "Create") (this as any)._root.markAsNew(key);
+        else if ((this as any).version !== undefined) (this as any)._root.setOriginalVersion(key, Number((this as any).version));
+    }
+
+    private teaqlEntityKey(): EntityKey { return { entity: "OrderStatus", id: (this as any)._ledgerId }; }
+    private teaqlAttachRoot(root: EntityRoot): this {
+        if ((this as any)._root !== root) { root.mergeFrom((this as any)._root); (this as any)._root = root; }
+        for (const child of (this as any)._customerOrderList) child.teaqlAttachRoot(root);
+        return this;
+    }
+
+    static fromRecord(record: Record<string, unknown>, root?: EntityRoot): OrderStatus {
+        const entity = new OrderStatus(record as Partial<OrderStatus>);
+        return root ? entity.teaqlAttachRoot(root) : entity;
+    }
+
+    isLoaded(field: string): boolean {
+        return (this as any)._fullyLoaded || (this as any)._loadedFields.has(field);
+    }
+
+    markLoaded(...fields: string[]): this {
+        for (const field of fields) (this as any)._loadedFields.add(field);
+        return this;
+    }
+
+    markLoadedOnly(...fields: string[]): this {
+        (this as any)._fullyLoaded = false;
+        (this as any)._loadedFields = new Set(fields);
+        return this;
+    }
+
+    static refer(id: string | number): OrderStatus {
+        return new OrderStatus({ id: String(id) } as Partial<OrderStatus>);
+    }
+
+    /** @internal Generated Runtime Module fixed-ID construction capability. */
+    static teaqlBootstrapNew(id: string | number): OrderStatus {
+        return new OrderStatus().updateId(String(id));
+    }
+
+    markForDeletion(): this {
+        (this as any)._action = "Delete";
+        (this as any)._root.markAsDeleted(this.teaqlEntityKey());
+        return this;
+    }
+
+    auditAs(comment: string): this {
+        if (!comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() requires a non-empty reason");
+        }
+        (this as any)._comment = comment;
+        return this;
+    }
+
+    async save(context: UserContext): Promise<OrderStatus> {
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return service.executeGraphSave(new MutationIntent((this as any)._comment), async (graph) => {
+            this.teaqlPreflightGraph(context, service, graph);
+            return this.teaqlSaveWithinGraph(context, service, graph);
+        });
+    }
+
+    /** @internal Validates and fixes the complete graph before its first mutation. */
+    teaqlPreflightGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): void {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        if (action === "Update") {
+            const notLoaded = [{ member: "platform", canonical: "platform" }, { member: "id", canonical: "id" }, { member: "name", canonical: "name" }, { member: "code", canonical: "code" }, { member: "color", canonical: "color" }, { member: "displayOrder", canonical: "display_order" }, { member: "version", canonical: "version" }]
+                .find(field => !this.isLoaded(field.member));
+            if (notLoaded) {
+                throw new CheckException([{
+                    ruleId: "invalid_type",
+                    location: ObjectLocation.property(notLoaded.canonical),
+                    message: "Mutation requires a fully loaded entity",
+                }]);
+            }
+        }
+        const request = graph.request({
+            entity: "OrderStatus", action,
+            payload: action === "Update"
+                ? (this as any)._root.change(this.teaqlEntityKey())
+                : this.teaqlMutationPayload(),
+            id: (this as any).id, version: (this as any).version,
+            comment: (this as any)._comment,
+            ledgerKey: this.teaqlEntityKey(), ledgerRoot: (this as any)._root,
+        }, parent, (this as any)._comment).withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        service.preflightMutation(request);
+        const scope = request.scopeFor(this.teaqlEntityKey());
+        for (const [index, child] of (this as any)._customerOrderList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updateStatus(this);
+            try { child.teaqlPreflightGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("customer_order_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+    }
+
+    /** @internal Used by generated relation cascades inside the root graph transaction. */
+    async teaqlSaveWithinGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): Promise<OrderStatus> {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        const ledgerPayload = (this as any)._root.change(this.teaqlEntityKey());
+        const mutation = {
+            entity: "OrderStatus",
+            action: (this as any)._action,
+            payload: action === "Update" ? ledgerPayload : this.teaqlMutationPayload(),
+            id: (this as any).id,
+            version: (this as any).version,
+            comment: (this as any)._comment
+            ,ledgerKey: this.teaqlEntityKey()
+            ,ledgerRoot: (this as any)._root
+        };
+        const request = graph.request(mutation, parent, (this as any)._comment)
+            .withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        const result = await service.executeMutation(request);
+        for (const [field, value] of Object.entries(mutation.payload as Record<string, unknown>)) {
+            if (field !== "id" && field !== "version") (this as any)._root.set(this.teaqlEntityKey(), field, value);
+        }
+        if (!result.persistedRecord) {
+            throw new Error("Mutation did not return the authoritative persisted record");
+        }
+        const rollbackState = {
+            payload: this.teaqlMutationPayload(),
+            ledgerId: (this as any)._ledgerId,
+            action: (this as any)._action,
+            loadedFields: new Set((this as any)._loadedFields),
+            fullyLoaded: (this as any)._fullyLoaded,
+        };
+        const oldKey = this.teaqlEntityKey();
+        Object.assign(this, result.persistedRecord);
+        (this as any)._ledgerId = (this as any).id ?? (this as any)._ledgerId;
+        const newKey = this.teaqlEntityKey();
+        (this as any)._root.rekey(oldKey, newKey);
+        service.afterGraphRollback(() => {
+            Object.assign(this, rollbackState.payload);
+            (this as any)._ledgerId = rollbackState.ledgerId;
+            (this as any)._action = rollbackState.action;
+            (this as any)._loadedFields = rollbackState.loadedFields;
+            (this as any)._fullyLoaded = rollbackState.fullyLoaded;
+            (this as any)._root.rekey(newKey, oldKey);
+        });
+        (this as any)._loadedFields = new Set(Object.keys(result.persistedRecord));
+        (this as any)._fullyLoaded = false;
+        if (mutation.action !== "Delete") (this as any)._action = "Update";
+        const scope = request.scopeFor(newKey);
+        for (const [index, child] of (this as any)._customerOrderList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updateStatus(this);
+            try { await child.teaqlSaveWithinGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("customer_order_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+        service.afterGraphCommit(() => {
+            (this as any)._root.clearEntity(newKey);
+            if ((this as any).version !== undefined) (this as any)._root.acceptCommittedVersion(newKey, Number((this as any).version));
+        });
+        return this;
+    }
+
+    private teaqlMutationPayload(): Record<string, unknown> {
+        return {
+            "platform": this.platform,
+            "id": this.id,
+            "name": this.name,
+            "code": this.code,
+            "color": this.color,
+            "display_order": this.displayOrder,
+            "version": this.version
+        };
+    }
+
+    updateId(value: string): this {
+        this.id = value;
+        this.markLoaded("id");
+        (this as any)._root.set(this.teaqlEntityKey(), "id", value);
+        return this;
+    }
+
+    updateName(value: string): this {
+        this.name = value;
+        this.markLoaded("name");
+        (this as any)._root.set(this.teaqlEntityKey(), "name", value);
+        return this;
+    }
+
+    updateCode(value: string): this {
+        this.code = value;
+        this.markLoaded("code");
+        (this as any)._root.set(this.teaqlEntityKey(), "code", value);
+        return this;
+    }
+
+    updateColor(value: string): this {
+        this.color = value;
+        this.markLoaded("color");
+        (this as any)._root.set(this.teaqlEntityKey(), "color", value);
+        return this;
+    }
+
+    updateDisplayOrder(value: number): this {
+        this.displayOrder = value;
+        this.markLoaded("displayOrder");
+        (this as any)._root.set(this.teaqlEntityKey(), "display_order", value);
+        return this;
+    }
+
+    updateVersion(value: number): this {
+        this.version = value;
+        this.markLoaded("version");
+        (this as any)._root.set(this.teaqlEntityKey(), "version", value);
+        return this;
+    }
+    updatePlatform(value: any): this {
+        this.platform = value?.id ?? value;
+        this.markLoaded("platform");
+        (this as any)._root.set(this.teaqlEntityKey(), "platform", this.platform);
+        return this;
+    }
+
+    customerOrderList(): CustomerOrder[] {
+        return (this as any)._customerOrderList;
+    }
+}

source/browser-sqlite/orders-lib/src/generated/models/Platform.ts

@@ -0,0 +1,276 @@
+import { CheckException, EntityKey, EntityRoot, GraphMutationSession, LoadedScalarSnapshot, MutationIntent, MutationTraceScope, ObjectLocation, TeaQLDataService, UserContext } from '../../teaql-ts';
+import { OrderStatus } from './OrderStatus';
+import { Customer } from './Customer';
+
+export class Platform {
+    private static teaqlTemporaryId = 0;
+        id?: string;
+        name?: string;
+        version?: number;
+
+    constructor(init?: Partial<Platform>) {
+        Object.defineProperty(this, "_action", { value: init && init.id ? "Update" : "Create", writable: true, enumerable: false });
+        Object.defineProperty(this, "_comment", { value: undefined, writable: true, enumerable: false });
+        Object.defineProperty(this, "_fullyLoaded", { value: !init || !init.id, writable: true, enumerable: false });
+        Object.defineProperty(this, "_loadedFields", { value: new Set(Object.keys(init || {})), writable: true, enumerable: false });
+        Object.defineProperty(this, "_root", { value: new EntityRoot(), writable: true, enumerable: false });
+        Object.defineProperty(this, "_ledgerId", { value: init?.id ?? --Platform.teaqlTemporaryId, writable: true, enumerable: false });
+        Object.defineProperty(this, "_orderStatusList", { value: [], writable: true, enumerable: false });
+        Object.defineProperty(this, "_customerList", { value: [], writable: true, enumerable: false });
+        if (init) {
+            const fields: Record<string, unknown> = { ...(init as Record<string, unknown>) };
+            delete fields["orderStatusList"];
+            delete fields["customerList"];
+            Object.assign(this, fields);
+            if (Array.isArray((init as any).orderStatusList)) {
+                (this as any)._orderStatusList = (init as any).orderStatusList.map(
+                    (child: unknown) => child instanceof OrderStatus
+                        ? child
+                        : OrderStatus.fromRecord(child as Record<string, unknown>),
+                );
+                this.markLoaded("orderStatusList");
+            }
+            if (Array.isArray((init as any).customerList)) {
+                (this as any)._customerList = (init as any).customerList.map(
+                    (child: unknown) => child instanceof Customer
+                        ? child
+                        : Customer.fromRecord(child as Record<string, unknown>),
+                );
+                this.markLoaded("customerList");
+            }
+        }
+        const key = this.teaqlEntityKey();
+        if ((this as any)._action === "Create") (this as any)._root.markAsNew(key);
+        else if ((this as any).version !== undefined) (this as any)._root.setOriginalVersion(key, Number((this as any).version));
+    }
+
+    private teaqlEntityKey(): EntityKey { return { entity: "Platform", id: (this as any)._ledgerId }; }
+    private teaqlAttachRoot(root: EntityRoot): this {
+        if ((this as any)._root !== root) { root.mergeFrom((this as any)._root); (this as any)._root = root; }
+        for (const child of (this as any)._orderStatusList) child.teaqlAttachRoot(root);
+        for (const child of (this as any)._customerList) child.teaqlAttachRoot(root);
+        return this;
+    }
+
+    static fromRecord(record: Record<string, unknown>, root?: EntityRoot): Platform {
+        const entity = new Platform(record as Partial<Platform>);
+        return root ? entity.teaqlAttachRoot(root) : entity;
+    }
+
+    isLoaded(field: string): boolean {
+        return (this as any)._fullyLoaded || (this as any)._loadedFields.has(field);
+    }
+
+    markLoaded(...fields: string[]): this {
+        for (const field of fields) (this as any)._loadedFields.add(field);
+        return this;
+    }
+
+    markLoadedOnly(...fields: string[]): this {
+        (this as any)._fullyLoaded = false;
+        (this as any)._loadedFields = new Set(fields);
+        return this;
+    }
+
+    static refer(id: string | number): Platform {
+        return new Platform({ id: String(id) } as Partial<Platform>);
+    }
+
+    /** @internal Generated Runtime Module fixed-ID construction capability. */
+    static teaqlBootstrapNew(id: string | number): Platform {
+        return new Platform().updateId(String(id));
+    }
+
+    markForDeletion(): this {
+        (this as any)._action = "Delete";
+        (this as any)._root.markAsDeleted(this.teaqlEntityKey());
+        return this;
+    }
+
+    auditAs(comment: string): this {
+        if (!comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() requires a non-empty reason");
+        }
+        (this as any)._comment = comment;
+        return this;
+    }
+
+    async save(context: UserContext): Promise<Platform> {
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return service.executeGraphSave(new MutationIntent((this as any)._comment), async (graph) => {
+            this.teaqlPreflightGraph(context, service, graph);
+            return this.teaqlSaveWithinGraph(context, service, graph);
+        });
+    }
+
+    /** @internal Validates and fixes the complete graph before its first mutation. */
+    teaqlPreflightGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): void {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        if (action === "Update") {
+            const notLoaded = [{ member: "id", canonical: "id" }, { member: "name", canonical: "name" }, { member: "version", canonical: "version" }]
+                .find(field => !this.isLoaded(field.member));
+            if (notLoaded) {
+                throw new CheckException([{
+                    ruleId: "invalid_type",
+                    location: ObjectLocation.property(notLoaded.canonical),
+                    message: "Mutation requires a fully loaded entity",
+                }]);
+            }
+        }
+        const request = graph.request({
+            entity: "Platform", action,
+            payload: action === "Update"
+                ? (this as any)._root.change(this.teaqlEntityKey())
+                : this.teaqlMutationPayload(),
+            id: (this as any).id, version: (this as any).version,
+            comment: (this as any)._comment,
+            ledgerKey: this.teaqlEntityKey(), ledgerRoot: (this as any)._root,
+        }, parent, (this as any)._comment).withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        service.preflightMutation(request);
+        const scope = request.scopeFor(this.teaqlEntityKey());
+        for (const [index, child] of (this as any)._orderStatusList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updatePlatform(this);
+            try { child.teaqlPreflightGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("order_status_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+        for (const [index, child] of (this as any)._customerList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updatePlatform(this);
+            try { child.teaqlPreflightGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("customer_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+    }
+
+    /** @internal Used by generated relation cascades inside the root graph transaction. */
+    async teaqlSaveWithinGraph(context: UserContext, service: TeaQLDataService, graph: GraphMutationSession, parent?: MutationTraceScope): Promise<Platform> {
+        if (!parent && !(this as any)._comment?.trim()) {
+            throw new Error("Security audit failure: auditAs() must be called before save()");
+        }
+        const action = (this as any)._action;
+        const ledgerPayload = (this as any)._root.change(this.teaqlEntityKey());
+        const mutation = {
+            entity: "Platform",
+            action: (this as any)._action,
+            payload: action === "Update" ? ledgerPayload : this.teaqlMutationPayload(),
+            id: (this as any).id,
+            version: (this as any).version,
+            comment: (this as any)._comment
+            ,ledgerKey: this.teaqlEntityKey()
+            ,ledgerRoot: (this as any)._root
+        };
+        const request = graph.request(mutation, parent, (this as any)._comment)
+            .withLoadedSnapshot(new LoadedScalarSnapshot(this.teaqlMutationPayload()));
+        const result = await service.executeMutation(request);
+        for (const [field, value] of Object.entries(mutation.payload as Record<string, unknown>)) {
+            if (field !== "id" && field !== "version") (this as any)._root.set(this.teaqlEntityKey(), field, value);
+        }
+        if (!result.persistedRecord) {
+            throw new Error("Mutation did not return the authoritative persisted record");
+        }
+        const rollbackState = {
+            payload: this.teaqlMutationPayload(),
+            ledgerId: (this as any)._ledgerId,
+            action: (this as any)._action,
+            loadedFields: new Set((this as any)._loadedFields),
+            fullyLoaded: (this as any)._fullyLoaded,
+        };
+        const oldKey = this.teaqlEntityKey();
+        Object.assign(this, result.persistedRecord);
+        (this as any)._ledgerId = (this as any).id ?? (this as any)._ledgerId;
+        const newKey = this.teaqlEntityKey();
+        (this as any)._root.rekey(oldKey, newKey);
+        service.afterGraphRollback(() => {
+            Object.assign(this, rollbackState.payload);
+            (this as any)._ledgerId = rollbackState.ledgerId;
+            (this as any)._action = rollbackState.action;
+            (this as any)._loadedFields = rollbackState.loadedFields;
+            (this as any)._fullyLoaded = rollbackState.fullyLoaded;
+            (this as any)._root.rekey(newKey, oldKey);
+        });
+        (this as any)._loadedFields = new Set(Object.keys(result.persistedRecord));
+        (this as any)._fullyLoaded = false;
+        if (mutation.action !== "Delete") (this as any)._action = "Update";
+        const scope = request.scopeFor(newKey);
+        for (const [index, child] of (this as any)._orderStatusList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updatePlatform(this);
+            try { await child.teaqlSaveWithinGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("order_status_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+        for (const [index, child] of (this as any)._customerList.entries()) {
+            child.teaqlAttachRoot((this as any)._root);
+            child.updatePlatform(this);
+            try { await child.teaqlSaveWithinGraph(context, service, graph, scope); }
+            catch (error) {
+                if (!(error instanceof CheckException)) throw error;
+                const prefix = ObjectLocation.property("customer_list").index(index);
+                throw new CheckException(error.violations.map(violation => ({
+                    ...violation, location: violation.location.prefixedBy(prefix),
+                })));
+            }
+        }
+        service.afterGraphCommit(() => {
+            (this as any)._root.clearEntity(newKey);
+            if ((this as any).version !== undefined) (this as any)._root.acceptCommittedVersion(newKey, Number((this as any).version));
+        });
+        return this;
+    }
+
+    private teaqlMutationPayload(): Record<string, unknown> {
+        return {
+            "id": this.id,
+            "name": this.name,
+            "version": this.version
+        };
+    }
+
+    updateId(value: string): this {
+        this.id = value;
+        this.markLoaded("id");
+        (this as any)._root.set(this.teaqlEntityKey(), "id", value);
+        return this;
+    }
+
+    updateName(value: string): this {
+        this.name = value;
+        this.markLoaded("name");
+        (this as any)._root.set(this.teaqlEntityKey(), "name", value);
+        return this;
+    }
+
+    updateVersion(value: number): this {
+        this.version = value;
+        this.markLoaded("version");
+        (this as any)._root.set(this.teaqlEntityKey(), "version", value);
+        return this;
+    }
+    orderStatusList(): OrderStatus[] {
+        return (this as any)._orderStatusList;
+    }
+
+    customerList(): Customer[] {
+        return (this as any)._customerList;
+    }
+}

source/browser-sqlite/orders-lib/src/generated/requests/CustomerOrderRequest.ts

@@ -0,0 +1,1206 @@
+import { EntityRoot, SelectQuery, SmartList, TeaQLDataService, TeaQLPage, UserContext, executeRelationFacets } from '../../teaql-ts';
+import { CustomerOrder } from '../models/CustomerOrder';
+import { mergeGeneratedScalarSearch, DynamicSearchWarning } from 'teaql-ts';
+import { GENERATED_SEARCH_MODELS } from '../../generated-search-models';
+
+
+
+export class CustomerOrderRequest {
+    private query: SelectQuery;
+    private filters: any[] = [];
+    private _purpose: string | undefined;
+    private _comment: string | undefined;
+    private _pageCountAlias: string | undefined;
+    private _pageCountMethod: "count" | "countAs" | undefined;
+    private _dynamicSearchWarnings: DynamicSearchWarning[] = [];
+
+    constructor(minimal = false) {
+        this.query = new SelectQuery("CustomerOrder");
+        this.filters.push({ version: { "$gte": 1 } });
+        if (minimal) {
+            this.selectId();
+            this.selectVersion();
+        }
+        else this.selectSelfFields();
+    }
+
+    comment(c: string): this {
+        this.query.comment(c);
+        this._comment = c;
+        return this;
+    }
+
+    filterByJson(source: unknown, warn?: (warning: DynamicSearchWarning) => void): this {
+        const base = this.query.clone();
+        if (this.filters.length > 0) base.filter({ "$and": this.filters });
+        const merged = mergeGeneratedScalarSearch(base, source, GENERATED_SEARCH_MODELS, warn);
+        this.query = merged.query as SelectQuery;
+        this.filters = this.query.filterCondition ? [this.query.filterCondition] : [];
+        this._dynamicSearchWarnings.push(...merged.warnings);
+        return this;
+    }
+
+    get dynamicSearchWarnings(): readonly DynamicSearchWarning[] {
+        return this._dynamicSearchWarnings.map(warning => ({ ...warning }));
+    }
+
+    purpose(p: string): ExecutableCustomerOrderRequest {
+        this.query.purpose(p);
+        this._purpose = p;
+        return new ExecutableCustomerOrderRequest(
+            (context) => this.executeForListInternal(context),
+            (context) => this.executeForRowsInternal(context),
+            (context, offset, limit) => this.executeForPageInternal(context, offset, limit),
+            (context, chunkSize) => this.executeForStreamInternal(context, chunkSize),
+            () => this.limit(1),
+            (c) => this.comment(c),
+            () => this.ensureIntent());
+    }
+
+    optimizeForContinuousPageFetch(): this {
+        this.query.optimizeForContinuousPageFetch();
+        return this;
+    }
+
+    optimizeForContinuousPageFetchWith(namespace: string, ttlSeconds: number): this {
+        this.query.optimizeForContinuousPageFetchWith(namespace, ttlSeconds);
+        return this;
+    }
+
+    optimizePaginationWithIdSet(): this {
+        this.query.optimizePaginationWithIdSet();
+        return this;
+    }
+
+    optimizePaginationWithIdSetConfig(namespace: string, ttlSeconds: number, maxIds: number): this {
+        this.query.optimizePaginationWithIdSetConfig(namespace, ttlSeconds, maxIds);
+        return this;
+    }
+
+    topNProbeParentThreshold(threshold: number): this {
+        this.query.topNProbeParentThreshold(threshold);
+        return this;
+    }
+
+    limit(n: number): this {
+        this.query.limit(n);
+        return this;
+    }
+
+    offset(n: number): this {
+        this.query.offset(n);
+        return this;
+    }
+
+    toQuery(): SelectQuery {
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+        return this.query;
+    }
+
+    withDeletedRows(): this {
+        this.filters = this.filters.filter(filter => !("version" in filter));
+        return this;
+    }
+
+    deletedRowsOnly(): this {
+        this.withDeletedRows();
+        this.filters.push({ version: { "$lte": -1 } });
+        return this;
+    }
+
+    selectSelfFields(): this {
+        this.query.select(["id", "customer", "status", "orderNumber", "orderDate", "totalAmount", "version"]);
+        return this;
+    }
+
+    selectId(): this {
+        this.query.select(["id"]);
+        return this;
+    }
+
+
+
+    selectOrderNumber(): this {
+        this.query.select(["orderNumber"]);
+        return this;
+    }
+
+    selectOrderDate(): this {
+        this.query.select(["orderDate"]);
+        return this;
+    }
+
+    selectTotalAmount(): this {
+        this.query.select(["totalAmount"]);
+        return this;
+    }
+
+    selectVersion(): this {
+        this.query.select(["version"]);
+        return this;
+    }
+
+
+    selectCustomerWith(request: { toQuery(): SelectQuery }): this {
+        this.query.select(["customer"]);
+        this.query.relationQuery(
+            "customer", request.toQuery(), "customer", "id", false,
+            { kind: "relation-select", method: "selectCustomerWith", relation: "customer" });
+        return this;
+    }
+    selectStatusWith(request: { toQuery(): SelectQuery }): this {
+        this.query.select(["status"]);
+        this.query.relationQuery(
+            "status", request.toQuery(), "status", "id", false,
+            { kind: "relation-select", method: "selectStatusWith", relation: "status" });
+        return this;
+    }
+
+    withCustomerMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "customer": {
+                "$inSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+
+    withoutCustomerMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "customer": {
+                "$notInSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+    withStatusMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "status": {
+                "$inSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+
+    withoutStatusMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "status": {
+                "$notInSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+
+    selectOrderItemListWith(request: { toQuery(): SelectQuery }): this {
+        this.query.relationQuery(
+            "orderItemList", request.toQuery(), "id", "customerOrder", true,
+            { kind: "relation-select", method: "selectOrderItemListWith", relation: "orderItemList" });
+        return this;
+    }
+
+    haveOrderItems(): this {
+        return this.withOrderItemListMatching({
+            toQuery: () => new SelectQuery("OrderItem"),
+        });
+    }
+
+    haveNoOrderItems(): this {
+        return this.withoutOrderItemListMatching({
+            toQuery: () => new SelectQuery("OrderItem"),
+        });
+    }
+
+    withOrderItemListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$inSubquery": {
+                    query: request.toQuery(), field: "customerOrder",
+                },
+            },
+        });
+        return this;
+    }
+
+    withoutOrderItemListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$notInSubquery": {
+                    query: request.toQuery(), field: "customerOrder",
+                },
+            },
+        });
+        return this;
+    }
+
+    countOrderItems(): this {
+        return this.countOrderItemsAs("countOrderItems");
+    }
+
+    countOrderItemsAs(alias: string): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        this.countOrderItemsWith(alias, { toQuery: () => query });
+        this.query.relationAggregates[this.query.relationAggregates.length - 1].operation = {
+            kind: "relation-count", method: "countOrderItemsAs", relation: "orderItemList", alias };
+        return this;
+    }
+
+    countOrderItemsWith(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("Count", "id", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "relation-count", method: "countOrderItemsWith", relation: "orderItemList", alias });
+        return this;
+    }
+
+    minQuantityOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.minQuantityOfOrderItemsAs(
+            "minOfQuantityOfOrderItems", { toQuery: () => query });
+    }
+
+    minQuantityOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("min", "quantity", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "minQuantityOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    maxQuantityOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.maxQuantityOfOrderItemsAs(
+            "maxOfQuantityOfOrderItems", { toQuery: () => query });
+    }
+
+    maxQuantityOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("max", "quantity", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "maxQuantityOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    sumQuantityOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.sumQuantityOfOrderItemsAs(
+            "sumOfQuantityOfOrderItems", { toQuery: () => query });
+    }
+
+    sumQuantityOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("sum", "quantity", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "sumQuantityOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    avgQuantityOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.avgQuantityOfOrderItemsAs(
+            "avgOfQuantityOfOrderItems", { toQuery: () => query });
+    }
+
+    avgQuantityOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("avg", "quantity", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "avgQuantityOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    standardDeviationQuantityOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.standardDeviationQuantityOfOrderItemsAs(
+            "standardDeviationOfQuantityOfOrderItems", { toQuery: () => query });
+    }
+
+    standardDeviationQuantityOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev", "quantity", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "standardDeviationQuantityOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    squareRootOfPopulationStandardDeviationQuantityOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.squareRootOfPopulationStandardDeviationQuantityOfOrderItemsAs(
+            "squareRootOfPopulationStandardDeviationOfQuantityOfOrderItems", { toQuery: () => query });
+    }
+
+    squareRootOfPopulationStandardDeviationQuantityOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev_pop", "quantity", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "squareRootOfPopulationStandardDeviationQuantityOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    sampleVarianceQuantityOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.sampleVarianceQuantityOfOrderItemsAs(
+            "sampleVarianceOfQuantityOfOrderItems", { toQuery: () => query });
+    }
+
+    sampleVarianceQuantityOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_samp", "quantity", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "sampleVarianceQuantityOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    samplePopulationVarianceQuantityOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.samplePopulationVarianceQuantityOfOrderItemsAs(
+            "samplePopulationVarianceOfQuantityOfOrderItems", { toQuery: () => query });
+    }
+
+    samplePopulationVarianceQuantityOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_pop", "quantity", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "samplePopulationVarianceQuantityOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    minUnitPriceOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.minUnitPriceOfOrderItemsAs(
+            "minOfUnitPriceOfOrderItems", { toQuery: () => query });
+    }
+
+    minUnitPriceOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("min", "unitPrice", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "minUnitPriceOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    maxUnitPriceOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.maxUnitPriceOfOrderItemsAs(
+            "maxOfUnitPriceOfOrderItems", { toQuery: () => query });
+    }
+
+    maxUnitPriceOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("max", "unitPrice", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "maxUnitPriceOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    sumUnitPriceOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.sumUnitPriceOfOrderItemsAs(
+            "sumOfUnitPriceOfOrderItems", { toQuery: () => query });
+    }
+
+    sumUnitPriceOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("sum", "unitPrice", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "sumUnitPriceOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    avgUnitPriceOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.avgUnitPriceOfOrderItemsAs(
+            "avgOfUnitPriceOfOrderItems", { toQuery: () => query });
+    }
+
+    avgUnitPriceOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("avg", "unitPrice", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "avgUnitPriceOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    standardDeviationUnitPriceOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.standardDeviationUnitPriceOfOrderItemsAs(
+            "standardDeviationOfUnitPriceOfOrderItems", { toQuery: () => query });
+    }
+
+    standardDeviationUnitPriceOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev", "unitPrice", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "standardDeviationUnitPriceOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    squareRootOfPopulationStandardDeviationUnitPriceOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.squareRootOfPopulationStandardDeviationUnitPriceOfOrderItemsAs(
+            "squareRootOfPopulationStandardDeviationOfUnitPriceOfOrderItems", { toQuery: () => query });
+    }
+
+    squareRootOfPopulationStandardDeviationUnitPriceOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev_pop", "unitPrice", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "squareRootOfPopulationStandardDeviationUnitPriceOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    sampleVarianceUnitPriceOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.sampleVarianceUnitPriceOfOrderItemsAs(
+            "sampleVarianceOfUnitPriceOfOrderItems", { toQuery: () => query });
+    }
+
+    sampleVarianceUnitPriceOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_samp", "unitPrice", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "sampleVarianceUnitPriceOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+    samplePopulationVarianceUnitPriceOfOrderItems(): this {
+        const query = new SelectQuery("OrderItem").filter({ version: { "$gte": 1 } });
+        return this.samplePopulationVarianceUnitPriceOfOrderItemsAs(
+            "samplePopulationVarianceOfUnitPriceOfOrderItems", { toQuery: () => query });
+    }
+
+    samplePopulationVarianceUnitPriceOfOrderItemsAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_pop", "unitPrice", alias);
+        this.query.relationAggregate("orderItemList", alias, query, true,
+            { kind: "aggregate", method: "samplePopulationVarianceUnitPriceOfOrderItemsAs", relation: "orderItemList", alias });
+        return this;
+    }
+
+        withIdIs(val: any): this {
+            this.filters.push({ "id": { "$eq": val } });
+            return this;
+        }
+
+        withIdIsNot(val: any): this {
+            this.filters.push({ "id": { "$ne": val } });
+            return this;
+        }
+
+        withIdIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$in": vals } });
+            return this;
+        }
+
+        withIdNotIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$notIn": vals } });
+            return this;
+        }
+
+        withIdGreaterThan(val: any): this {
+            this.filters.push({ "id": { "$gt": val } });
+            return this;
+        }
+
+        withIdGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$gte": val } });
+            return this;
+        }
+
+        withIdLessThan(val: any): this {
+            this.filters.push({ "id": { "$lt": val } });
+            return this;
+        }
+
+        withIdLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$lte": val } });
+            return this;
+        }
+
+        withIdBetween(lower: any, upper: any): this {
+            this.filters.push({ "id": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withIdIsKnown(): this {
+            this.filters.push({ "id": { "$isNull": false } });
+            return this;
+        }
+
+        withIdIsUnknown(): this {
+            this.filters.push({ "id": { "$isNull": true } });
+            return this;
+        }
+
+        filterByCustomer(val: any): this {
+            this.filters.push({ "customer": { "$eq": val } });
+            return this;
+        }
+
+        filterByCustomerIn(...vals: any[]): this {
+            this.filters.push({ "customer": { "$in": vals } });
+            return this;
+        }
+
+        withCustomerIsKnown(): this {
+            this.filters.push({ "customer": { "$isNull": false } });
+            return this;
+        }
+
+        withCustomerIsUnknown(): this {
+            this.filters.push({ "customer": { "$isNull": true } });
+            return this;
+        }
+
+        filterByStatus(val: any): this {
+            this.filters.push({ "status": { "$eq": val } });
+            return this;
+        }
+
+        filterByStatusIn(...vals: any[]): this {
+            this.filters.push({ "status": { "$in": vals } });
+            return this;
+        }
+
+        withStatusIsKnown(): this {
+            this.filters.push({ "status": { "$isNull": false } });
+            return this;
+        }
+
+        withStatusIsUnknown(): this {
+            this.filters.push({ "status": { "$isNull": true } });
+            return this;
+        }
+        withStatusIsNew(): this {
+            this.filters.push({ "status": { "$eq": "1001" } });
+            return this;
+        }
+        withStatusIsPaid(): this {
+            this.filters.push({ "status": { "$eq": "1002" } });
+            return this;
+        }
+        withStatusIsCancelled(): this {
+            this.filters.push({ "status": { "$eq": "1003" } });
+            return this;
+        }
+
+        withOrderNumberContaining(val: string): this {
+            this.filters.push({ "orderNumber": { "$contains": val } });
+            return this;
+        }
+
+        withOrderNumberIs(val: string): this {
+            this.filters.push({ "orderNumber": { "$eq": val } });
+            return this;
+        }
+
+        withOrderNumberIsNot(val: any): this {
+            this.filters.push({ "orderNumber": { "$ne": val } });
+            return this;
+        }
+
+        withOrderNumberIn(...vals: any[]): this {
+            this.filters.push({ "orderNumber": { "$in": vals } });
+            return this;
+        }
+
+        withOrderNumberNotIn(...vals: any[]): this {
+            this.filters.push({ "orderNumber": { "$notIn": vals } });
+            return this;
+        }
+
+        withOrderNumberGreaterThan(val: any): this {
+            this.filters.push({ "orderNumber": { "$gt": val } });
+            return this;
+        }
+
+        withOrderNumberGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "orderNumber": { "$gte": val } });
+            return this;
+        }
+
+        withOrderNumberLessThan(val: any): this {
+            this.filters.push({ "orderNumber": { "$lt": val } });
+            return this;
+        }
+
+        withOrderNumberLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "orderNumber": { "$lte": val } });
+            return this;
+        }
+
+        withOrderNumberBetween(lower: any, upper: any): this {
+            this.filters.push({ "orderNumber": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withOrderNumberIsKnown(): this {
+            this.filters.push({ "orderNumber": { "$isNull": false } });
+            return this;
+        }
+
+        withOrderNumberIsUnknown(): this {
+            this.filters.push({ "orderNumber": { "$isNull": true } });
+            return this;
+        }
+        withOrderNumberNotContaining(val: string): this {
+            this.filters.push({ "orderNumber": { "$notContains": val } });
+            return this;
+        }
+
+        withOrderNumberStartingWith(val: string): this {
+            this.filters.push({ "orderNumber": { "$startsWith": val } });
+            return this;
+        }
+
+        withOrderNumberNotStartingWith(val: string): this {
+            this.filters.push({ "orderNumber": { "$notStartsWith": val } });
+            return this;
+        }
+
+        withOrderNumberEndingWith(val: string): this {
+            this.filters.push({ "orderNumber": { "$endsWith": val } });
+            return this;
+        }
+
+        withOrderNumberNotEndingWith(val: string): this {
+            this.filters.push({ "orderNumber": { "$notEndsWith": val } });
+            return this;
+        }
+
+        withOrderNumberSoundingLike(val: string): this {
+            this.filters.push({ "orderNumber": { "$soundLike": val } });
+            return this;
+        }
+
+        withOrderDateIs(val: any): this {
+            this.filters.push({ "orderDate": { "$eq": val } });
+            return this;
+        }
+
+        withOrderDateIsNot(val: any): this {
+            this.filters.push({ "orderDate": { "$ne": val } });
+            return this;
+        }
+
+        withOrderDateIn(...vals: any[]): this {
+            this.filters.push({ "orderDate": { "$in": vals } });
+            return this;
+        }
+
+        withOrderDateNotIn(...vals: any[]): this {
+            this.filters.push({ "orderDate": { "$notIn": vals } });
+            return this;
+        }
+
+        withOrderDateGreaterThan(val: any): this {
+            this.filters.push({ "orderDate": { "$gt": val } });
+            return this;
+        }
+
+        withOrderDateGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "orderDate": { "$gte": val } });
+            return this;
+        }
+
+        withOrderDateLessThan(val: any): this {
+            this.filters.push({ "orderDate": { "$lt": val } });
+            return this;
+        }
+
+        withOrderDateLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "orderDate": { "$lte": val } });
+            return this;
+        }
+
+        withOrderDateBetween(lower: any, upper: any): this {
+            this.filters.push({ "orderDate": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withOrderDateIsKnown(): this {
+            this.filters.push({ "orderDate": { "$isNull": false } });
+            return this;
+        }
+
+        withOrderDateIsUnknown(): this {
+            this.filters.push({ "orderDate": { "$isNull": true } });
+            return this;
+        }
+
+        withTotalAmountIs(val: any): this {
+            this.filters.push({ "totalAmount": { "$eq": val } });
+            return this;
+        }
+
+        withTotalAmountIsNot(val: any): this {
+            this.filters.push({ "totalAmount": { "$ne": val } });
+            return this;
+        }
+
+        withTotalAmountIn(...vals: any[]): this {
+            this.filters.push({ "totalAmount": { "$in": vals } });
+            return this;
+        }
+
+        withTotalAmountNotIn(...vals: any[]): this {
+            this.filters.push({ "totalAmount": { "$notIn": vals } });
+            return this;
+        }
+
+        withTotalAmountGreaterThan(val: any): this {
+            this.filters.push({ "totalAmount": { "$gt": val } });
+            return this;
+        }
+
+        withTotalAmountGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "totalAmount": { "$gte": val } });
+            return this;
+        }
+
+        withTotalAmountLessThan(val: any): this {
+            this.filters.push({ "totalAmount": { "$lt": val } });
+            return this;
+        }
+
+        withTotalAmountLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "totalAmount": { "$lte": val } });
+            return this;
+        }
+
+        withTotalAmountBetween(lower: any, upper: any): this {
+            this.filters.push({ "totalAmount": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withTotalAmountIsKnown(): this {
+            this.filters.push({ "totalAmount": { "$isNull": false } });
+            return this;
+        }
+
+        withTotalAmountIsUnknown(): this {
+            this.filters.push({ "totalAmount": { "$isNull": true } });
+            return this;
+        }
+
+        withVersionIs(val: any): this {
+            this.filters.push({ "version": { "$eq": val } });
+            return this;
+        }
+
+        withVersionIsNot(val: any): this {
+            this.filters.push({ "version": { "$ne": val } });
+            return this;
+        }
+
+        withVersionIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$in": vals } });
+            return this;
+        }
+
+        withVersionNotIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$notIn": vals } });
+            return this;
+        }
+
+        withVersionGreaterThan(val: any): this {
+            this.filters.push({ "version": { "$gt": val } });
+            return this;
+        }
+
+        withVersionGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$gte": val } });
+            return this;
+        }
+
+        withVersionLessThan(val: any): this {
+            this.filters.push({ "version": { "$lt": val } });
+            return this;
+        }
+
+        withVersionLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$lte": val } });
+            return this;
+        }
+
+        withVersionBetween(lower: any, upper: any): this {
+            this.filters.push({ "version": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withVersionIsKnown(): this {
+            this.filters.push({ "version": { "$isNull": false } });
+            return this;
+        }
+
+        withVersionIsUnknown(): this {
+            this.filters.push({ "version": { "$isNull": true } });
+            return this;
+        }
+
+    orderByIdAscending(): this {
+        this.query.orderBy("id", "asc");
+        return this;
+    }
+
+    orderByIdDescending(): this {
+        this.query.orderBy("id", "desc");
+        return this;
+    }
+
+
+
+    orderByOrderNumberAscending(): this {
+        this.query.orderBy("orderNumber", "asc");
+        return this;
+    }
+
+    orderByOrderNumberDescending(): this {
+        this.query.orderBy("orderNumber", "desc");
+        return this;
+    }
+
+    orderByOrderDateAscending(): this {
+        this.query.orderBy("orderDate", "asc");
+        return this;
+    }
+
+    orderByOrderDateDescending(): this {
+        this.query.orderBy("orderDate", "desc");
+        return this;
+    }
+
+    orderByTotalAmountAscending(): this {
+        this.query.orderBy("totalAmount", "asc");
+        return this;
+    }
+
+    orderByTotalAmountDescending(): this {
+        this.query.orderBy("totalAmount", "desc");
+        return this;
+    }
+
+    orderByVersionAscending(): this {
+        this.query.orderBy("version", "asc");
+        return this;
+    }
+
+    orderByVersionDescending(): this {
+        this.query.orderBy("version", "desc");
+        return this;
+    }
+
+
+    // --- Aggregations ---
+    count(): this {
+        this.query.aggregate("Count", "id", "count");
+        this._pageCountAlias = "count";
+        this._pageCountMethod = "count";
+        return this;
+    }
+
+    countAs(retName: string): this {
+        this.query.aggregate("Count", "id", retName);
+        this._pageCountAlias = retName;
+        this._pageCountMethod = "countAs";
+        return this;
+    }
+
+    minTotalAmount(): this {
+        return this.minTotalAmountAs("minOfTotalAmount");
+    }
+
+    minTotalAmountAs(retName: string): this {
+        this.query.aggregate("min", "totalAmount", retName);
+        return this;
+    }
+    maxTotalAmount(): this {
+        return this.maxTotalAmountAs("maxOfTotalAmount");
+    }
+
+    maxTotalAmountAs(retName: string): this {
+        this.query.aggregate("max", "totalAmount", retName);
+        return this;
+    }
+    sumTotalAmount(): this {
+        return this.sumTotalAmountAs("sumOfTotalAmount");
+    }
+
+    sumTotalAmountAs(retName: string): this {
+        this.query.aggregate("sum", "totalAmount", retName);
+        return this;
+    }
+    avgTotalAmount(): this {
+        return this.avgTotalAmountAs("avgOfTotalAmount");
+    }
+
+    avgTotalAmountAs(retName: string): this {
+        this.query.aggregate("avg", "totalAmount", retName);
+        return this;
+    }
+    standardDeviationTotalAmount(): this {
+        return this.standardDeviationTotalAmountAs("standardDeviationOfTotalAmount");
+    }
+
+    standardDeviationTotalAmountAs(retName: string): this {
+        this.query.aggregate("stddev", "totalAmount", retName);
+        return this;
+    }
+    squareRootOfPopulationStandardDeviationTotalAmount(): this {
+        return this.squareRootOfPopulationStandardDeviationTotalAmountAs("squareRootOfPopulationStandardDeviationOfTotalAmount");
+    }
+
+    squareRootOfPopulationStandardDeviationTotalAmountAs(retName: string): this {
+        this.query.aggregate("stddev_pop", "totalAmount", retName);
+        return this;
+    }
+    sampleVarianceTotalAmount(): this {
+        return this.sampleVarianceTotalAmountAs("sampleVarianceOfTotalAmount");
+    }
+
+    sampleVarianceTotalAmountAs(retName: string): this {
+        this.query.aggregate("var_samp", "totalAmount", retName);
+        return this;
+    }
+    samplePopulationVarianceTotalAmount(): this {
+        return this.samplePopulationVarianceTotalAmountAs("samplePopulationVarianceOfTotalAmount");
+    }
+
+    samplePopulationVarianceTotalAmountAs(retName: string): this {
+        this.query.aggregate("var_pop", "totalAmount", retName);
+        return this;
+    }
+
+    // --- Group By ---
+    groupById(): this {
+        this.query.groupBy("id");
+        return this;
+    }
+
+    groupByIdAs(retName: string): this {
+        this.query.groupBy("id"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByCustomer(): this {
+        this.query.groupBy("customer");
+        return this;
+    }
+
+    groupByCustomerAs(retName: string): this {
+        this.query.groupBy("customer"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByStatus(): this {
+        this.query.groupBy("status");
+        return this;
+    }
+
+    groupByStatusAs(retName: string): this {
+        this.query.groupBy("status"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByOrderNumber(): this {
+        this.query.groupBy("orderNumber");
+        return this;
+    }
+
+    groupByOrderNumberAs(retName: string): this {
+        this.query.groupBy("orderNumber"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByOrderDate(): this {
+        this.query.groupBy("orderDate");
+        return this;
+    }
+
+    groupByOrderDateAs(retName: string): this {
+        this.query.groupBy("orderDate"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByTotalAmount(): this {
+        this.query.groupBy("totalAmount");
+        return this;
+    }
+
+    groupByTotalAmountAs(retName: string): this {
+        this.query.groupBy("totalAmount"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByVersion(): this {
+        this.query.groupBy("version");
+        return this;
+    }
+
+    groupByVersionAs(retName: string): this {
+        this.query.groupBy("version"); // In TS we don't alias group by yet natively
+        return this;
+    }
+
+    // --- Facets ---
+    facetByCustomerAs(
+        facetName: string,
+        request: { toQuery(): SelectQuery },
+        includeAllFacets = true,
+    ): this {
+        this.query.facetBy(facetName, "customer", request, includeAllFacets,
+            { kind: "facet", method: "facetByCustomerAs", relation: "customer", alias: facetName });
+        return this;
+    }
+
+    facetByStatusAs(
+        facetName: string,
+        request: { toQuery(): SelectQuery },
+        includeAllFacets = true,
+    ): this {
+        this.query.facetBy(facetName, "status", request, includeAllFacets,
+            { kind: "facet", method: "facetByStatusAs", relation: "status", alias: facetName });
+        return this;
+    }
+
+
+    private async executeForListInternal(context: UserContext): Promise<SmartList<CustomerOrder>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const rows = await service.executeQuery(context.prepareQuery(this.query));
+        const queryRoot = new EntityRoot();
+        const aggregateOnly = this.query.aggregateItems.length > 0 && this.query.groupByItems.length === 0;
+        const data = aggregateOnly ? [] : rows.map((row: unknown) =>
+            row instanceof CustomerOrder
+                ? row
+                : CustomerOrder.fromRecord(row as Record<string, unknown>, queryRoot));
+        const result = new SmartList<CustomerOrder>(data);
+        if (aggregateOnly && rows[0]) Object.assign(result.aggregations, rows[0]);
+
+        if (this.query.facets.length > 0) {
+            result.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+
+        return result;
+    }
+
+    private async executeForRowsInternal(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return new SmartList<Record<string, unknown>>(
+            await service.executeQuery(context.prepareQuery(this.query)) as Record<string, unknown>[]);
+    }
+
+    private async executeForPageInternal(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<CustomerOrder>> {
+        this.ensureIntent();
+        this.query.offset(offset).limit(limit);
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const useIdSet = this.query.localIdSetPaginationOptions() !== undefined;
+        const countOperation = { kind: "named-count" as const,
+            method: this._pageCountMethod ?? "count",
+            ...(this._pageCountMethod === "countAs" ? { alias: this._pageCountAlias } : {}) };
+        const totalCountBeforeRows = useIdSet ? undefined : await service.executeCount(
+            this.query, this._pageCountAlias, countOperation);
+        const pageQuery = this.query.clone();
+        // A page count describes the full filtered set, not an aggregate-only page row.
+        pageQuery.aggregateItems = pageQuery.aggregateItems.filter(item =>
+            !(String(item.function).toLowerCase() === "count" && item.alias === this._pageCountAlias));
+        const rows = await service.executeQuery(context.prepareQuery(pageQuery));
+        const totalCount = useIdSet && context.idSetPaginationCountAccuracy === "EXACT"
+            ? context.idSetPaginationCount!
+            : (totalCountBeforeRows ?? await service.executeCount(this.query, this._pageCountAlias, countOperation));
+        const queryRoot = new EntityRoot();
+        const data = new SmartList(rows.map((row: unknown) =>
+            row instanceof CustomerOrder
+                ? row
+                : CustomerOrder.fromRecord(row as Record<string, unknown>, queryRoot)));
+        data.totalCount = totalCount;
+        if (this._pageCountAlias !== undefined) data.aggregations[this._pageCountAlias] = totalCount;
+        if (this.query.facets.length > 0) {
+            data.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+        return { data, totalCount, offset, limit };
+    }
+
+    private async *executeForStreamInternal(context: UserContext, chunkSize: number): AsyncIterable<CustomerOrder> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const queryRoot = new EntityRoot();
+        for await (const chunk of service.executeForStream(this.query, chunkSize)) {
+            for (const entity of chunk) {
+                yield entity instanceof CustomerOrder
+                    ? entity
+                    : CustomerOrder.fromRecord(entity as Record<string, unknown>, queryRoot);
+            }
+        }
+    }
+
+    private ensureIntent(): void {
+        if (!this._comment?.trim()) {
+            throw new Error("Security audit failure: non-empty comment() is required before execution");
+        }
+        if (!this._purpose?.trim()) {
+            throw new Error("Security audit failure: non-empty purpose() is required before execution");
+        }
+    }
+
+}
+
+export class ExecutableCustomerOrderRequest {
+    constructor(
+        private readonly execute: (context: UserContext) => Promise<SmartList<CustomerOrder>>,
+        private readonly executeRows: (context: UserContext) => Promise<SmartList<Record<string, unknown>>>,
+        private readonly page: (
+            context: UserContext, offset: number, limit: number,
+        ) => Promise<TeaQLPage<CustomerOrder>>,
+        private readonly stream: (context: UserContext, chunkSize: number) => AsyncIterable<CustomerOrder>,
+        private readonly limitOne: () => void,
+        private readonly addComment: (comment: string) => void,
+        private readonly ensureIntent: () => void,
+    ) {}
+
+    comment(c: string): this {
+        this.addComment(c);
+        return this;
+    }
+
+    newEntity(context: UserContext): CustomerOrder {
+        this.ensureIntent();
+        return new CustomerOrder();
+    }
+
+    executeForList(context: UserContext): Promise<SmartList<CustomerOrder>> {
+        this.ensureIntent();
+        return this.execute(context);
+    }
+
+    executeForRows(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        return this.executeRows(context);
+    }
+
+    executeForPage(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<CustomerOrder>> {
+        this.ensureIntent();
+        return this.page(context, offset, limit);
+    }
+
+    executeForStream(context: UserContext, chunkSize = 1000): AsyncIterable<CustomerOrder> {
+        this.ensureIntent();
+        return this.stream(context, chunkSize);
+    }
+
+    async executeForOne(context: UserContext): Promise<CustomerOrder | undefined> {
+        this.limitOne();
+        return (await this.executeForList(context))[0];
+    }
+}

source/browser-sqlite/orders-lib/src/generated/requests/CustomerRequest.ts

@@ -0,0 +1,795 @@
+import { EntityRoot, SelectQuery, SmartList, TeaQLDataService, TeaQLPage, UserContext, executeRelationFacets } from '../../teaql-ts';
+import { Customer } from '../models/Customer';
+import { mergeGeneratedScalarSearch, DynamicSearchWarning } from 'teaql-ts';
+import { GENERATED_SEARCH_MODELS } from '../../generated-search-models';
+
+
+
+export class CustomerRequest {
+    private query: SelectQuery;
+    private filters: any[] = [];
+    private _purpose: string | undefined;
+    private _comment: string | undefined;
+    private _pageCountAlias: string | undefined;
+    private _pageCountMethod: "count" | "countAs" | undefined;
+    private _dynamicSearchWarnings: DynamicSearchWarning[] = [];
+
+    constructor(minimal = false) {
+        this.query = new SelectQuery("Customer");
+        this.filters.push({ version: { "$gte": 1 } });
+        if (minimal) {
+            this.selectId();
+            this.selectVersion();
+        }
+        else this.selectSelfFields();
+    }
+
+    comment(c: string): this {
+        this.query.comment(c);
+        this._comment = c;
+        return this;
+    }
+
+    filterByJson(source: unknown, warn?: (warning: DynamicSearchWarning) => void): this {
+        const base = this.query.clone();
+        if (this.filters.length > 0) base.filter({ "$and": this.filters });
+        const merged = mergeGeneratedScalarSearch(base, source, GENERATED_SEARCH_MODELS, warn);
+        this.query = merged.query as SelectQuery;
+        this.filters = this.query.filterCondition ? [this.query.filterCondition] : [];
+        this._dynamicSearchWarnings.push(...merged.warnings);
+        return this;
+    }
+
+    get dynamicSearchWarnings(): readonly DynamicSearchWarning[] {
+        return this._dynamicSearchWarnings.map(warning => ({ ...warning }));
+    }
+
+    purpose(p: string): ExecutableCustomerRequest {
+        this.query.purpose(p);
+        this._purpose = p;
+        return new ExecutableCustomerRequest(
+            (context) => this.executeForListInternal(context),
+            (context) => this.executeForRowsInternal(context),
+            (context, offset, limit) => this.executeForPageInternal(context, offset, limit),
+            (context, chunkSize) => this.executeForStreamInternal(context, chunkSize),
+            () => this.limit(1),
+            (c) => this.comment(c),
+            () => this.ensureIntent());
+    }
+
+    optimizeForContinuousPageFetch(): this {
+        this.query.optimizeForContinuousPageFetch();
+        return this;
+    }
+
+    optimizeForContinuousPageFetchWith(namespace: string, ttlSeconds: number): this {
+        this.query.optimizeForContinuousPageFetchWith(namespace, ttlSeconds);
+        return this;
+    }
+
+    optimizePaginationWithIdSet(): this {
+        this.query.optimizePaginationWithIdSet();
+        return this;
+    }
+
+    optimizePaginationWithIdSetConfig(namespace: string, ttlSeconds: number, maxIds: number): this {
+        this.query.optimizePaginationWithIdSetConfig(namespace, ttlSeconds, maxIds);
+        return this;
+    }
+
+    topNProbeParentThreshold(threshold: number): this {
+        this.query.topNProbeParentThreshold(threshold);
+        return this;
+    }
+
+    limit(n: number): this {
+        this.query.limit(n);
+        return this;
+    }
+
+    offset(n: number): this {
+        this.query.offset(n);
+        return this;
+    }
+
+    toQuery(): SelectQuery {
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+        return this.query;
+    }
+
+    withDeletedRows(): this {
+        this.filters = this.filters.filter(filter => !("version" in filter));
+        return this;
+    }
+
+    deletedRowsOnly(): this {
+        this.withDeletedRows();
+        this.filters.push({ version: { "$lte": -1 } });
+        return this;
+    }
+
+    selectSelfFields(): this {
+        this.query.select(["id", "platform", "name", "version"]);
+        return this;
+    }
+
+    selectId(): this {
+        this.query.select(["id"]);
+        return this;
+    }
+
+
+    selectName(): this {
+        this.query.select(["name"]);
+        return this;
+    }
+
+    selectVersion(): this {
+        this.query.select(["version"]);
+        return this;
+    }
+
+
+    selectPlatformWith(request: { toQuery(): SelectQuery }): this {
+        this.query.select(["platform"]);
+        this.query.relationQuery(
+            "platform", request.toQuery(), "platform", "id", false,
+            { kind: "relation-select", method: "selectPlatformWith", relation: "platform" });
+        return this;
+    }
+
+    withPlatformMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "platform": {
+                "$inSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+
+    withoutPlatformMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "platform": {
+                "$notInSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+
+    selectCustomerOrderListWith(request: { toQuery(): SelectQuery }): this {
+        this.query.relationQuery(
+            "customerOrderList", request.toQuery(), "id", "customer", true,
+            { kind: "relation-select", method: "selectCustomerOrderListWith", relation: "customerOrderList" });
+        return this;
+    }
+
+    haveCustomerOrders(): this {
+        return this.withCustomerOrderListMatching({
+            toQuery: () => new SelectQuery("CustomerOrder"),
+        });
+    }
+
+    haveNoCustomerOrders(): this {
+        return this.withoutCustomerOrderListMatching({
+            toQuery: () => new SelectQuery("CustomerOrder"),
+        });
+    }
+
+    withCustomerOrderListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$inSubquery": {
+                    query: request.toQuery(), field: "customer",
+                },
+            },
+        });
+        return this;
+    }
+
+    withoutCustomerOrderListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$notInSubquery": {
+                    query: request.toQuery(), field: "customer",
+                },
+            },
+        });
+        return this;
+    }
+
+    countCustomerOrders(): this {
+        return this.countCustomerOrdersAs("countCustomerOrders");
+    }
+
+    countCustomerOrdersAs(alias: string): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        this.countCustomerOrdersWith(alias, { toQuery: () => query });
+        this.query.relationAggregates[this.query.relationAggregates.length - 1].operation = {
+            kind: "relation-count", method: "countCustomerOrdersAs", relation: "customerOrderList", alias };
+        return this;
+    }
+
+    countCustomerOrdersWith(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("Count", "id", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "relation-count", method: "countCustomerOrdersWith", relation: "customerOrderList", alias });
+        return this;
+    }
+
+    minTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.minTotalAmountOfCustomerOrdersAs(
+            "minOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    minTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("min", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "minTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    maxTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.maxTotalAmountOfCustomerOrdersAs(
+            "maxOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    maxTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("max", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "maxTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    sumTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.sumTotalAmountOfCustomerOrdersAs(
+            "sumOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    sumTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("sum", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "sumTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    avgTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.avgTotalAmountOfCustomerOrdersAs(
+            "avgOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    avgTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("avg", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "avgTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    standardDeviationTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.standardDeviationTotalAmountOfCustomerOrdersAs(
+            "standardDeviationOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    standardDeviationTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "standardDeviationTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    squareRootOfPopulationStandardDeviationTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.squareRootOfPopulationStandardDeviationTotalAmountOfCustomerOrdersAs(
+            "squareRootOfPopulationStandardDeviationOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    squareRootOfPopulationStandardDeviationTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev_pop", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "squareRootOfPopulationStandardDeviationTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    sampleVarianceTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.sampleVarianceTotalAmountOfCustomerOrdersAs(
+            "sampleVarianceOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    sampleVarianceTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_samp", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "sampleVarianceTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    samplePopulationVarianceTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.samplePopulationVarianceTotalAmountOfCustomerOrdersAs(
+            "samplePopulationVarianceOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    samplePopulationVarianceTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_pop", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "samplePopulationVarianceTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+
+        withIdIs(val: any): this {
+            this.filters.push({ "id": { "$eq": val } });
+            return this;
+        }
+
+        withIdIsNot(val: any): this {
+            this.filters.push({ "id": { "$ne": val } });
+            return this;
+        }
+
+        withIdIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$in": vals } });
+            return this;
+        }
+
+        withIdNotIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$notIn": vals } });
+            return this;
+        }
+
+        withIdGreaterThan(val: any): this {
+            this.filters.push({ "id": { "$gt": val } });
+            return this;
+        }
+
+        withIdGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$gte": val } });
+            return this;
+        }
+
+        withIdLessThan(val: any): this {
+            this.filters.push({ "id": { "$lt": val } });
+            return this;
+        }
+
+        withIdLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$lte": val } });
+            return this;
+        }
+
+        withIdBetween(lower: any, upper: any): this {
+            this.filters.push({ "id": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withIdIsKnown(): this {
+            this.filters.push({ "id": { "$isNull": false } });
+            return this;
+        }
+
+        withIdIsUnknown(): this {
+            this.filters.push({ "id": { "$isNull": true } });
+            return this;
+        }
+
+        filterByPlatform(val: any): this {
+            this.filters.push({ "platform": { "$eq": val } });
+            return this;
+        }
+
+        filterByPlatformIn(...vals: any[]): this {
+            this.filters.push({ "platform": { "$in": vals } });
+            return this;
+        }
+
+        withPlatformIsKnown(): this {
+            this.filters.push({ "platform": { "$isNull": false } });
+            return this;
+        }
+
+        withPlatformIsUnknown(): this {
+            this.filters.push({ "platform": { "$isNull": true } });
+            return this;
+        }
+
+        withNameContaining(val: string): this {
+            this.filters.push({ "name": { "$contains": val } });
+            return this;
+        }
+
+        withNameIs(val: string): this {
+            this.filters.push({ "name": { "$eq": val } });
+            return this;
+        }
+
+        withNameIsNot(val: any): this {
+            this.filters.push({ "name": { "$ne": val } });
+            return this;
+        }
+
+        withNameIn(...vals: any[]): this {
+            this.filters.push({ "name": { "$in": vals } });
+            return this;
+        }
+
+        withNameNotIn(...vals: any[]): this {
+            this.filters.push({ "name": { "$notIn": vals } });
+            return this;
+        }
+
+        withNameGreaterThan(val: any): this {
+            this.filters.push({ "name": { "$gt": val } });
+            return this;
+        }
+
+        withNameGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "name": { "$gte": val } });
+            return this;
+        }
+
+        withNameLessThan(val: any): this {
+            this.filters.push({ "name": { "$lt": val } });
+            return this;
+        }
+
+        withNameLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "name": { "$lte": val } });
+            return this;
+        }
+
+        withNameBetween(lower: any, upper: any): this {
+            this.filters.push({ "name": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withNameIsKnown(): this {
+            this.filters.push({ "name": { "$isNull": false } });
+            return this;
+        }
+
+        withNameIsUnknown(): this {
+            this.filters.push({ "name": { "$isNull": true } });
+            return this;
+        }
+        withNameNotContaining(val: string): this {
+            this.filters.push({ "name": { "$notContains": val } });
+            return this;
+        }
+
+        withNameStartingWith(val: string): this {
+            this.filters.push({ "name": { "$startsWith": val } });
+            return this;
+        }
+
+        withNameNotStartingWith(val: string): this {
+            this.filters.push({ "name": { "$notStartsWith": val } });
+            return this;
+        }
+
+        withNameEndingWith(val: string): this {
+            this.filters.push({ "name": { "$endsWith": val } });
+            return this;
+        }
+
+        withNameNotEndingWith(val: string): this {
+            this.filters.push({ "name": { "$notEndsWith": val } });
+            return this;
+        }
+
+        withNameSoundingLike(val: string): this {
+            this.filters.push({ "name": { "$soundLike": val } });
+            return this;
+        }
+
+        withVersionIs(val: any): this {
+            this.filters.push({ "version": { "$eq": val } });
+            return this;
+        }
+
+        withVersionIsNot(val: any): this {
+            this.filters.push({ "version": { "$ne": val } });
+            return this;
+        }
+
+        withVersionIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$in": vals } });
+            return this;
+        }
+
+        withVersionNotIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$notIn": vals } });
+            return this;
+        }
+
+        withVersionGreaterThan(val: any): this {
+            this.filters.push({ "version": { "$gt": val } });
+            return this;
+        }
+
+        withVersionGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$gte": val } });
+            return this;
+        }
+
+        withVersionLessThan(val: any): this {
+            this.filters.push({ "version": { "$lt": val } });
+            return this;
+        }
+
+        withVersionLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$lte": val } });
+            return this;
+        }
+
+        withVersionBetween(lower: any, upper: any): this {
+            this.filters.push({ "version": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withVersionIsKnown(): this {
+            this.filters.push({ "version": { "$isNull": false } });
+            return this;
+        }
+
+        withVersionIsUnknown(): this {
+            this.filters.push({ "version": { "$isNull": true } });
+            return this;
+        }
+
+    orderByIdAscending(): this {
+        this.query.orderBy("id", "asc");
+        return this;
+    }
+
+    orderByIdDescending(): this {
+        this.query.orderBy("id", "desc");
+        return this;
+    }
+
+
+    orderByNameAscending(): this {
+        this.query.orderBy("name", "asc");
+        return this;
+    }
+
+    orderByNameDescending(): this {
+        this.query.orderBy("name", "desc");
+        return this;
+    }
+
+    orderByVersionAscending(): this {
+        this.query.orderBy("version", "asc");
+        return this;
+    }
+
+    orderByVersionDescending(): this {
+        this.query.orderBy("version", "desc");
+        return this;
+    }
+
+
+    // --- Aggregations ---
+    count(): this {
+        this.query.aggregate("Count", "id", "count");
+        this._pageCountAlias = "count";
+        this._pageCountMethod = "count";
+        return this;
+    }
+
+    countAs(retName: string): this {
+        this.query.aggregate("Count", "id", retName);
+        this._pageCountAlias = retName;
+        this._pageCountMethod = "countAs";
+        return this;
+    }
+
+
+    // --- Group By ---
+    groupById(): this {
+        this.query.groupBy("id");
+        return this;
+    }
+
+    groupByIdAs(retName: string): this {
+        this.query.groupBy("id"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByPlatform(): this {
+        this.query.groupBy("platform");
+        return this;
+    }
+
+    groupByPlatformAs(retName: string): this {
+        this.query.groupBy("platform"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByName(): this {
+        this.query.groupBy("name");
+        return this;
+    }
+
+    groupByNameAs(retName: string): this {
+        this.query.groupBy("name"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByVersion(): this {
+        this.query.groupBy("version");
+        return this;
+    }
+
+    groupByVersionAs(retName: string): this {
+        this.query.groupBy("version"); // In TS we don't alias group by yet natively
+        return this;
+    }
+
+    // --- Facets ---
+    facetByPlatformAs(
+        facetName: string,
+        request: { toQuery(): SelectQuery },
+        includeAllFacets = true,
+    ): this {
+        this.query.facetBy(facetName, "platform", request, includeAllFacets,
+            { kind: "facet", method: "facetByPlatformAs", relation: "platform", alias: facetName });
+        return this;
+    }
+
+
+    private async executeForListInternal(context: UserContext): Promise<SmartList<Customer>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const rows = await service.executeQuery(context.prepareQuery(this.query));
+        const queryRoot = new EntityRoot();
+        const aggregateOnly = this.query.aggregateItems.length > 0 && this.query.groupByItems.length === 0;
+        const data = aggregateOnly ? [] : rows.map((row: unknown) =>
+            row instanceof Customer
+                ? row
+                : Customer.fromRecord(row as Record<string, unknown>, queryRoot));
+        const result = new SmartList<Customer>(data);
+        if (aggregateOnly && rows[0]) Object.assign(result.aggregations, rows[0]);
+
+        if (this.query.facets.length > 0) {
+            result.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+
+        return result;
+    }
+
+    private async executeForRowsInternal(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return new SmartList<Record<string, unknown>>(
+            await service.executeQuery(context.prepareQuery(this.query)) as Record<string, unknown>[]);
+    }
+
+    private async executeForPageInternal(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<Customer>> {
+        this.ensureIntent();
+        this.query.offset(offset).limit(limit);
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const useIdSet = this.query.localIdSetPaginationOptions() !== undefined;
+        const countOperation = { kind: "named-count" as const,
+            method: this._pageCountMethod ?? "count",
+            ...(this._pageCountMethod === "countAs" ? { alias: this._pageCountAlias } : {}) };
+        const totalCountBeforeRows = useIdSet ? undefined : await service.executeCount(
+            this.query, this._pageCountAlias, countOperation);
+        const pageQuery = this.query.clone();
+        // A page count describes the full filtered set, not an aggregate-only page row.
+        pageQuery.aggregateItems = pageQuery.aggregateItems.filter(item =>
+            !(String(item.function).toLowerCase() === "count" && item.alias === this._pageCountAlias));
+        const rows = await service.executeQuery(context.prepareQuery(pageQuery));
+        const totalCount = useIdSet && context.idSetPaginationCountAccuracy === "EXACT"
+            ? context.idSetPaginationCount!
+            : (totalCountBeforeRows ?? await service.executeCount(this.query, this._pageCountAlias, countOperation));
+        const queryRoot = new EntityRoot();
+        const data = new SmartList(rows.map((row: unknown) =>
+            row instanceof Customer
+                ? row
+                : Customer.fromRecord(row as Record<string, unknown>, queryRoot)));
+        data.totalCount = totalCount;
+        if (this._pageCountAlias !== undefined) data.aggregations[this._pageCountAlias] = totalCount;
+        if (this.query.facets.length > 0) {
+            data.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+        return { data, totalCount, offset, limit };
+    }
+
+    private async *executeForStreamInternal(context: UserContext, chunkSize: number): AsyncIterable<Customer> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const queryRoot = new EntityRoot();
+        for await (const chunk of service.executeForStream(this.query, chunkSize)) {
+            for (const entity of chunk) {
+                yield entity instanceof Customer
+                    ? entity
+                    : Customer.fromRecord(entity as Record<string, unknown>, queryRoot);
+            }
+        }
+    }
+
+    private ensureIntent(): void {
+        if (!this._comment?.trim()) {
+            throw new Error("Security audit failure: non-empty comment() is required before execution");
+        }
+        if (!this._purpose?.trim()) {
+            throw new Error("Security audit failure: non-empty purpose() is required before execution");
+        }
+    }
+
+}
+
+export class ExecutableCustomerRequest {
+    constructor(
+        private readonly execute: (context: UserContext) => Promise<SmartList<Customer>>,
+        private readonly executeRows: (context: UserContext) => Promise<SmartList<Record<string, unknown>>>,
+        private readonly page: (
+            context: UserContext, offset: number, limit: number,
+        ) => Promise<TeaQLPage<Customer>>,
+        private readonly stream: (context: UserContext, chunkSize: number) => AsyncIterable<Customer>,
+        private readonly limitOne: () => void,
+        private readonly addComment: (comment: string) => void,
+        private readonly ensureIntent: () => void,
+    ) {}
+
+    comment(c: string): this {
+        this.addComment(c);
+        return this;
+    }
+
+    newEntity(context: UserContext): Customer {
+        this.ensureIntent();
+        return new Customer();
+    }
+
+    executeForList(context: UserContext): Promise<SmartList<Customer>> {
+        this.ensureIntent();
+        return this.execute(context);
+    }
+
+    executeForRows(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        return this.executeRows(context);
+    }
+
+    executeForPage(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<Customer>> {
+        this.ensureIntent();
+        return this.page(context, offset, limit);
+    }
+
+    executeForStream(context: UserContext, chunkSize = 1000): AsyncIterable<Customer> {
+        this.ensureIntent();
+        return this.stream(context, chunkSize);
+    }
+
+    async executeForOne(context: UserContext): Promise<Customer | undefined> {
+        this.limitOne();
+        return (await this.executeForList(context))[0];
+    }
+}

source/browser-sqlite/orders-lib/src/generated/requests/OrderItemRequest.ts

@@ -0,0 +1,909 @@
+import { EntityRoot, SelectQuery, SmartList, TeaQLDataService, TeaQLPage, UserContext, executeRelationFacets } from '../../teaql-ts';
+import { OrderItem } from '../models/OrderItem';
+import { mergeGeneratedScalarSearch, DynamicSearchWarning } from 'teaql-ts';
+import { GENERATED_SEARCH_MODELS } from '../../generated-search-models';
+
+
+
+export class OrderItemRequest {
+    private query: SelectQuery;
+    private filters: any[] = [];
+    private _purpose: string | undefined;
+    private _comment: string | undefined;
+    private _pageCountAlias: string | undefined;
+    private _pageCountMethod: "count" | "countAs" | undefined;
+    private _dynamicSearchWarnings: DynamicSearchWarning[] = [];
+
+    constructor(minimal = false) {
+        this.query = new SelectQuery("OrderItem");
+        this.filters.push({ version: { "$gte": 1 } });
+        if (minimal) {
+            this.selectId();
+            this.selectVersion();
+        }
+        else this.selectSelfFields();
+    }
+
+    comment(c: string): this {
+        this.query.comment(c);
+        this._comment = c;
+        return this;
+    }
+
+    filterByJson(source: unknown, warn?: (warning: DynamicSearchWarning) => void): this {
+        const base = this.query.clone();
+        if (this.filters.length > 0) base.filter({ "$and": this.filters });
+        const merged = mergeGeneratedScalarSearch(base, source, GENERATED_SEARCH_MODELS, warn);
+        this.query = merged.query as SelectQuery;
+        this.filters = this.query.filterCondition ? [this.query.filterCondition] : [];
+        this._dynamicSearchWarnings.push(...merged.warnings);
+        return this;
+    }
+
+    get dynamicSearchWarnings(): readonly DynamicSearchWarning[] {
+        return this._dynamicSearchWarnings.map(warning => ({ ...warning }));
+    }
+
+    purpose(p: string): ExecutableOrderItemRequest {
+        this.query.purpose(p);
+        this._purpose = p;
+        return new ExecutableOrderItemRequest(
+            (context) => this.executeForListInternal(context),
+            (context) => this.executeForRowsInternal(context),
+            (context, offset, limit) => this.executeForPageInternal(context, offset, limit),
+            (context, chunkSize) => this.executeForStreamInternal(context, chunkSize),
+            () => this.limit(1),
+            (c) => this.comment(c),
+            () => this.ensureIntent());
+    }
+
+    optimizeForContinuousPageFetch(): this {
+        this.query.optimizeForContinuousPageFetch();
+        return this;
+    }
+
+    optimizeForContinuousPageFetchWith(namespace: string, ttlSeconds: number): this {
+        this.query.optimizeForContinuousPageFetchWith(namespace, ttlSeconds);
+        return this;
+    }
+
+    optimizePaginationWithIdSet(): this {
+        this.query.optimizePaginationWithIdSet();
+        return this;
+    }
+
+    optimizePaginationWithIdSetConfig(namespace: string, ttlSeconds: number, maxIds: number): this {
+        this.query.optimizePaginationWithIdSetConfig(namespace, ttlSeconds, maxIds);
+        return this;
+    }
+
+    topNProbeParentThreshold(threshold: number): this {
+        this.query.topNProbeParentThreshold(threshold);
+        return this;
+    }
+
+    limit(n: number): this {
+        this.query.limit(n);
+        return this;
+    }
+
+    offset(n: number): this {
+        this.query.offset(n);
+        return this;
+    }
+
+    toQuery(): SelectQuery {
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+        return this.query;
+    }
+
+    withDeletedRows(): this {
+        this.filters = this.filters.filter(filter => !("version" in filter));
+        return this;
+    }
+
+    deletedRowsOnly(): this {
+        this.withDeletedRows();
+        this.filters.push({ version: { "$lte": -1 } });
+        return this;
+    }
+
+    selectSelfFields(): this {
+        this.query.select(["id", "customerOrder", "productName", "quantity", "unitPrice", "version"]);
+        return this;
+    }
+
+    selectId(): this {
+        this.query.select(["id"]);
+        return this;
+    }
+
+
+    selectProductName(): this {
+        this.query.select(["productName"]);
+        return this;
+    }
+
+    selectQuantity(): this {
+        this.query.select(["quantity"]);
+        return this;
+    }
+
+    selectUnitPrice(): this {
+        this.query.select(["unitPrice"]);
+        return this;
+    }
+
+    selectVersion(): this {
+        this.query.select(["version"]);
+        return this;
+    }
+
+
+    selectCustomerOrderWith(request: { toQuery(): SelectQuery }): this {
+        this.query.select(["customerOrder"]);
+        this.query.relationQuery(
+            "customerOrder", request.toQuery(), "customerOrder", "id", false,
+            { kind: "relation-select", method: "selectCustomerOrderWith", relation: "customerOrder" });
+        return this;
+    }
+
+    withCustomerOrderMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "customerOrder": {
+                "$inSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+
+    withoutCustomerOrderMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "customerOrder": {
+                "$notInSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+
+
+
+
+        withIdIs(val: any): this {
+            this.filters.push({ "id": { "$eq": val } });
+            return this;
+        }
+
+        withIdIsNot(val: any): this {
+            this.filters.push({ "id": { "$ne": val } });
+            return this;
+        }
+
+        withIdIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$in": vals } });
+            return this;
+        }
+
+        withIdNotIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$notIn": vals } });
+            return this;
+        }
+
+        withIdGreaterThan(val: any): this {
+            this.filters.push({ "id": { "$gt": val } });
+            return this;
+        }
+
+        withIdGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$gte": val } });
+            return this;
+        }
+
+        withIdLessThan(val: any): this {
+            this.filters.push({ "id": { "$lt": val } });
+            return this;
+        }
+
+        withIdLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$lte": val } });
+            return this;
+        }
+
+        withIdBetween(lower: any, upper: any): this {
+            this.filters.push({ "id": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withIdIsKnown(): this {
+            this.filters.push({ "id": { "$isNull": false } });
+            return this;
+        }
+
+        withIdIsUnknown(): this {
+            this.filters.push({ "id": { "$isNull": true } });
+            return this;
+        }
+
+        filterByCustomerOrder(val: any): this {
+            this.filters.push({ "customerOrder": { "$eq": val } });
+            return this;
+        }
+
+        filterByCustomerOrderIn(...vals: any[]): this {
+            this.filters.push({ "customerOrder": { "$in": vals } });
+            return this;
+        }
+
+        withCustomerOrderIsKnown(): this {
+            this.filters.push({ "customerOrder": { "$isNull": false } });
+            return this;
+        }
+
+        withCustomerOrderIsUnknown(): this {
+            this.filters.push({ "customerOrder": { "$isNull": true } });
+            return this;
+        }
+
+        withProductNameContaining(val: string): this {
+            this.filters.push({ "productName": { "$contains": val } });
+            return this;
+        }
+
+        withProductNameIs(val: string): this {
+            this.filters.push({ "productName": { "$eq": val } });
+            return this;
+        }
+
+        withProductNameIsNot(val: any): this {
+            this.filters.push({ "productName": { "$ne": val } });
+            return this;
+        }
+
+        withProductNameIn(...vals: any[]): this {
+            this.filters.push({ "productName": { "$in": vals } });
+            return this;
+        }
+
+        withProductNameNotIn(...vals: any[]): this {
+            this.filters.push({ "productName": { "$notIn": vals } });
+            return this;
+        }
+
+        withProductNameGreaterThan(val: any): this {
+            this.filters.push({ "productName": { "$gt": val } });
+            return this;
+        }
+
+        withProductNameGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "productName": { "$gte": val } });
+            return this;
+        }
+
+        withProductNameLessThan(val: any): this {
+            this.filters.push({ "productName": { "$lt": val } });
+            return this;
+        }
+
+        withProductNameLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "productName": { "$lte": val } });
+            return this;
+        }
+
+        withProductNameBetween(lower: any, upper: any): this {
+            this.filters.push({ "productName": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withProductNameIsKnown(): this {
+            this.filters.push({ "productName": { "$isNull": false } });
+            return this;
+        }
+
+        withProductNameIsUnknown(): this {
+            this.filters.push({ "productName": { "$isNull": true } });
+            return this;
+        }
+        withProductNameNotContaining(val: string): this {
+            this.filters.push({ "productName": { "$notContains": val } });
+            return this;
+        }
+
+        withProductNameStartingWith(val: string): this {
+            this.filters.push({ "productName": { "$startsWith": val } });
+            return this;
+        }
+
+        withProductNameNotStartingWith(val: string): this {
+            this.filters.push({ "productName": { "$notStartsWith": val } });
+            return this;
+        }
+
+        withProductNameEndingWith(val: string): this {
+            this.filters.push({ "productName": { "$endsWith": val } });
+            return this;
+        }
+
+        withProductNameNotEndingWith(val: string): this {
+            this.filters.push({ "productName": { "$notEndsWith": val } });
+            return this;
+        }
+
+        withProductNameSoundingLike(val: string): this {
+            this.filters.push({ "productName": { "$soundLike": val } });
+            return this;
+        }
+
+        withQuantityIs(val: any): this {
+            this.filters.push({ "quantity": { "$eq": val } });
+            return this;
+        }
+
+        withQuantityIsNot(val: any): this {
+            this.filters.push({ "quantity": { "$ne": val } });
+            return this;
+        }
+
+        withQuantityIn(...vals: any[]): this {
+            this.filters.push({ "quantity": { "$in": vals } });
+            return this;
+        }
+
+        withQuantityNotIn(...vals: any[]): this {
+            this.filters.push({ "quantity": { "$notIn": vals } });
+            return this;
+        }
+
+        withQuantityGreaterThan(val: any): this {
+            this.filters.push({ "quantity": { "$gt": val } });
+            return this;
+        }
+
+        withQuantityGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "quantity": { "$gte": val } });
+            return this;
+        }
+
+        withQuantityLessThan(val: any): this {
+            this.filters.push({ "quantity": { "$lt": val } });
+            return this;
+        }
+
+        withQuantityLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "quantity": { "$lte": val } });
+            return this;
+        }
+
+        withQuantityBetween(lower: any, upper: any): this {
+            this.filters.push({ "quantity": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withQuantityIsKnown(): this {
+            this.filters.push({ "quantity": { "$isNull": false } });
+            return this;
+        }
+
+        withQuantityIsUnknown(): this {
+            this.filters.push({ "quantity": { "$isNull": true } });
+            return this;
+        }
+
+        withUnitPriceIs(val: any): this {
+            this.filters.push({ "unitPrice": { "$eq": val } });
+            return this;
+        }
+
+        withUnitPriceIsNot(val: any): this {
+            this.filters.push({ "unitPrice": { "$ne": val } });
+            return this;
+        }
+
+        withUnitPriceIn(...vals: any[]): this {
+            this.filters.push({ "unitPrice": { "$in": vals } });
+            return this;
+        }
+
+        withUnitPriceNotIn(...vals: any[]): this {
+            this.filters.push({ "unitPrice": { "$notIn": vals } });
+            return this;
+        }
+
+        withUnitPriceGreaterThan(val: any): this {
+            this.filters.push({ "unitPrice": { "$gt": val } });
+            return this;
+        }
+
+        withUnitPriceGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "unitPrice": { "$gte": val } });
+            return this;
+        }
+
+        withUnitPriceLessThan(val: any): this {
+            this.filters.push({ "unitPrice": { "$lt": val } });
+            return this;
+        }
+
+        withUnitPriceLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "unitPrice": { "$lte": val } });
+            return this;
+        }
+
+        withUnitPriceBetween(lower: any, upper: any): this {
+            this.filters.push({ "unitPrice": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withUnitPriceIsKnown(): this {
+            this.filters.push({ "unitPrice": { "$isNull": false } });
+            return this;
+        }
+
+        withUnitPriceIsUnknown(): this {
+            this.filters.push({ "unitPrice": { "$isNull": true } });
+            return this;
+        }
+
+        withVersionIs(val: any): this {
+            this.filters.push({ "version": { "$eq": val } });
+            return this;
+        }
+
+        withVersionIsNot(val: any): this {
+            this.filters.push({ "version": { "$ne": val } });
+            return this;
+        }
+
+        withVersionIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$in": vals } });
+            return this;
+        }
+
+        withVersionNotIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$notIn": vals } });
+            return this;
+        }
+
+        withVersionGreaterThan(val: any): this {
+            this.filters.push({ "version": { "$gt": val } });
+            return this;
+        }
+
+        withVersionGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$gte": val } });
+            return this;
+        }
+
+        withVersionLessThan(val: any): this {
+            this.filters.push({ "version": { "$lt": val } });
+            return this;
+        }
+
+        withVersionLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$lte": val } });
+            return this;
+        }
+
+        withVersionBetween(lower: any, upper: any): this {
+            this.filters.push({ "version": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withVersionIsKnown(): this {
+            this.filters.push({ "version": { "$isNull": false } });
+            return this;
+        }
+
+        withVersionIsUnknown(): this {
+            this.filters.push({ "version": { "$isNull": true } });
+            return this;
+        }
+
+    orderByIdAscending(): this {
+        this.query.orderBy("id", "asc");
+        return this;
+    }
+
+    orderByIdDescending(): this {
+        this.query.orderBy("id", "desc");
+        return this;
+    }
+
+
+    orderByProductNameAscending(): this {
+        this.query.orderBy("productName", "asc");
+        return this;
+    }
+
+    orderByProductNameDescending(): this {
+        this.query.orderBy("productName", "desc");
+        return this;
+    }
+
+    orderByQuantityAscending(): this {
+        this.query.orderBy("quantity", "asc");
+        return this;
+    }
+
+    orderByQuantityDescending(): this {
+        this.query.orderBy("quantity", "desc");
+        return this;
+    }
+
+    orderByUnitPriceAscending(): this {
+        this.query.orderBy("unitPrice", "asc");
+        return this;
+    }
+
+    orderByUnitPriceDescending(): this {
+        this.query.orderBy("unitPrice", "desc");
+        return this;
+    }
+
+    orderByVersionAscending(): this {
+        this.query.orderBy("version", "asc");
+        return this;
+    }
+
+    orderByVersionDescending(): this {
+        this.query.orderBy("version", "desc");
+        return this;
+    }
+
+
+    // --- Aggregations ---
+    count(): this {
+        this.query.aggregate("Count", "id", "count");
+        this._pageCountAlias = "count";
+        this._pageCountMethod = "count";
+        return this;
+    }
+
+    countAs(retName: string): this {
+        this.query.aggregate("Count", "id", retName);
+        this._pageCountAlias = retName;
+        this._pageCountMethod = "countAs";
+        return this;
+    }
+
+    minQuantity(): this {
+        return this.minQuantityAs("minOfQuantity");
+    }
+
+    minQuantityAs(retName: string): this {
+        this.query.aggregate("min", "quantity", retName);
+        return this;
+    }
+    maxQuantity(): this {
+        return this.maxQuantityAs("maxOfQuantity");
+    }
+
+    maxQuantityAs(retName: string): this {
+        this.query.aggregate("max", "quantity", retName);
+        return this;
+    }
+    sumQuantity(): this {
+        return this.sumQuantityAs("sumOfQuantity");
+    }
+
+    sumQuantityAs(retName: string): this {
+        this.query.aggregate("sum", "quantity", retName);
+        return this;
+    }
+    avgQuantity(): this {
+        return this.avgQuantityAs("avgOfQuantity");
+    }
+
+    avgQuantityAs(retName: string): this {
+        this.query.aggregate("avg", "quantity", retName);
+        return this;
+    }
+    standardDeviationQuantity(): this {
+        return this.standardDeviationQuantityAs("standardDeviationOfQuantity");
+    }
+
+    standardDeviationQuantityAs(retName: string): this {
+        this.query.aggregate("stddev", "quantity", retName);
+        return this;
+    }
+    squareRootOfPopulationStandardDeviationQuantity(): this {
+        return this.squareRootOfPopulationStandardDeviationQuantityAs("squareRootOfPopulationStandardDeviationOfQuantity");
+    }
+
+    squareRootOfPopulationStandardDeviationQuantityAs(retName: string): this {
+        this.query.aggregate("stddev_pop", "quantity", retName);
+        return this;
+    }
+    sampleVarianceQuantity(): this {
+        return this.sampleVarianceQuantityAs("sampleVarianceOfQuantity");
+    }
+
+    sampleVarianceQuantityAs(retName: string): this {
+        this.query.aggregate("var_samp", "quantity", retName);
+        return this;
+    }
+    samplePopulationVarianceQuantity(): this {
+        return this.samplePopulationVarianceQuantityAs("samplePopulationVarianceOfQuantity");
+    }
+
+    samplePopulationVarianceQuantityAs(retName: string): this {
+        this.query.aggregate("var_pop", "quantity", retName);
+        return this;
+    }
+    minUnitPrice(): this {
+        return this.minUnitPriceAs("minOfUnitPrice");
+    }
+
+    minUnitPriceAs(retName: string): this {
+        this.query.aggregate("min", "unitPrice", retName);
+        return this;
+    }
+    maxUnitPrice(): this {
+        return this.maxUnitPriceAs("maxOfUnitPrice");
+    }
+
+    maxUnitPriceAs(retName: string): this {
+        this.query.aggregate("max", "unitPrice", retName);
+        return this;
+    }
+    sumUnitPrice(): this {
+        return this.sumUnitPriceAs("sumOfUnitPrice");
+    }
+
+    sumUnitPriceAs(retName: string): this {
+        this.query.aggregate("sum", "unitPrice", retName);
+        return this;
+    }
+    avgUnitPrice(): this {
+        return this.avgUnitPriceAs("avgOfUnitPrice");
+    }
+
+    avgUnitPriceAs(retName: string): this {
+        this.query.aggregate("avg", "unitPrice", retName);
+        return this;
+    }
+    standardDeviationUnitPrice(): this {
+        return this.standardDeviationUnitPriceAs("standardDeviationOfUnitPrice");
+    }
+
+    standardDeviationUnitPriceAs(retName: string): this {
+        this.query.aggregate("stddev", "unitPrice", retName);
+        return this;
+    }
+    squareRootOfPopulationStandardDeviationUnitPrice(): this {
+        return this.squareRootOfPopulationStandardDeviationUnitPriceAs("squareRootOfPopulationStandardDeviationOfUnitPrice");
+    }
+
+    squareRootOfPopulationStandardDeviationUnitPriceAs(retName: string): this {
+        this.query.aggregate("stddev_pop", "unitPrice", retName);
+        return this;
+    }
+    sampleVarianceUnitPrice(): this {
+        return this.sampleVarianceUnitPriceAs("sampleVarianceOfUnitPrice");
+    }
+
+    sampleVarianceUnitPriceAs(retName: string): this {
+        this.query.aggregate("var_samp", "unitPrice", retName);
+        return this;
+    }
+    samplePopulationVarianceUnitPrice(): this {
+        return this.samplePopulationVarianceUnitPriceAs("samplePopulationVarianceOfUnitPrice");
+    }
+
+    samplePopulationVarianceUnitPriceAs(retName: string): this {
+        this.query.aggregate("var_pop", "unitPrice", retName);
+        return this;
+    }
+
+    // --- Group By ---
+    groupById(): this {
+        this.query.groupBy("id");
+        return this;
+    }
+
+    groupByIdAs(retName: string): this {
+        this.query.groupBy("id"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByCustomerOrder(): this {
+        this.query.groupBy("customerOrder");
+        return this;
+    }
+
+    groupByCustomerOrderAs(retName: string): this {
+        this.query.groupBy("customerOrder"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByProductName(): this {
+        this.query.groupBy("productName");
+        return this;
+    }
+
+    groupByProductNameAs(retName: string): this {
+        this.query.groupBy("productName"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByQuantity(): this {
+        this.query.groupBy("quantity");
+        return this;
+    }
+
+    groupByQuantityAs(retName: string): this {
+        this.query.groupBy("quantity"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByUnitPrice(): this {
+        this.query.groupBy("unitPrice");
+        return this;
+    }
+
+    groupByUnitPriceAs(retName: string): this {
+        this.query.groupBy("unitPrice"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByVersion(): this {
+        this.query.groupBy("version");
+        return this;
+    }
+
+    groupByVersionAs(retName: string): this {
+        this.query.groupBy("version"); // In TS we don't alias group by yet natively
+        return this;
+    }
+
+    // --- Facets ---
+    facetByCustomerOrderAs(
+        facetName: string,
+        request: { toQuery(): SelectQuery },
+        includeAllFacets = true,
+    ): this {
+        this.query.facetBy(facetName, "customerOrder", request, includeAllFacets,
+            { kind: "facet", method: "facetByCustomerOrderAs", relation: "customerOrder", alias: facetName });
+        return this;
+    }
+
+
+    private async executeForListInternal(context: UserContext): Promise<SmartList<OrderItem>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const rows = await service.executeQuery(context.prepareQuery(this.query));
+        const queryRoot = new EntityRoot();
+        const aggregateOnly = this.query.aggregateItems.length > 0 && this.query.groupByItems.length === 0;
+        const data = aggregateOnly ? [] : rows.map((row: unknown) =>
+            row instanceof OrderItem
+                ? row
+                : OrderItem.fromRecord(row as Record<string, unknown>, queryRoot));
+        const result = new SmartList<OrderItem>(data);
+        if (aggregateOnly && rows[0]) Object.assign(result.aggregations, rows[0]);
+
+        if (this.query.facets.length > 0) {
+            result.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+
+        return result;
+    }
+
+    private async executeForRowsInternal(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return new SmartList<Record<string, unknown>>(
+            await service.executeQuery(context.prepareQuery(this.query)) as Record<string, unknown>[]);
+    }
+
+    private async executeForPageInternal(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<OrderItem>> {
+        this.ensureIntent();
+        this.query.offset(offset).limit(limit);
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const useIdSet = this.query.localIdSetPaginationOptions() !== undefined;
+        const countOperation = { kind: "named-count" as const,
+            method: this._pageCountMethod ?? "count",
+            ...(this._pageCountMethod === "countAs" ? { alias: this._pageCountAlias } : {}) };
+        const totalCountBeforeRows = useIdSet ? undefined : await service.executeCount(
+            this.query, this._pageCountAlias, countOperation);
+        const pageQuery = this.query.clone();
+        // A page count describes the full filtered set, not an aggregate-only page row.
+        pageQuery.aggregateItems = pageQuery.aggregateItems.filter(item =>
+            !(String(item.function).toLowerCase() === "count" && item.alias === this._pageCountAlias));
+        const rows = await service.executeQuery(context.prepareQuery(pageQuery));
+        const totalCount = useIdSet && context.idSetPaginationCountAccuracy === "EXACT"
+            ? context.idSetPaginationCount!
+            : (totalCountBeforeRows ?? await service.executeCount(this.query, this._pageCountAlias, countOperation));
+        const queryRoot = new EntityRoot();
+        const data = new SmartList(rows.map((row: unknown) =>
+            row instanceof OrderItem
+                ? row
+                : OrderItem.fromRecord(row as Record<string, unknown>, queryRoot)));
+        data.totalCount = totalCount;
+        if (this._pageCountAlias !== undefined) data.aggregations[this._pageCountAlias] = totalCount;
+        if (this.query.facets.length > 0) {
+            data.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+        return { data, totalCount, offset, limit };
+    }
+
+    private async *executeForStreamInternal(context: UserContext, chunkSize: number): AsyncIterable<OrderItem> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const queryRoot = new EntityRoot();
+        for await (const chunk of service.executeForStream(this.query, chunkSize)) {
+            for (const entity of chunk) {
+                yield entity instanceof OrderItem
+                    ? entity
+                    : OrderItem.fromRecord(entity as Record<string, unknown>, queryRoot);
+            }
+        }
+    }
+
+    private ensureIntent(): void {
+        if (!this._comment?.trim()) {
+            throw new Error("Security audit failure: non-empty comment() is required before execution");
+        }
+        if (!this._purpose?.trim()) {
+            throw new Error("Security audit failure: non-empty purpose() is required before execution");
+        }
+    }
+
+}
+
+export class ExecutableOrderItemRequest {
+    constructor(
+        private readonly execute: (context: UserContext) => Promise<SmartList<OrderItem>>,
+        private readonly executeRows: (context: UserContext) => Promise<SmartList<Record<string, unknown>>>,
+        private readonly page: (
+            context: UserContext, offset: number, limit: number,
+        ) => Promise<TeaQLPage<OrderItem>>,
+        private readonly stream: (context: UserContext, chunkSize: number) => AsyncIterable<OrderItem>,
+        private readonly limitOne: () => void,
+        private readonly addComment: (comment: string) => void,
+        private readonly ensureIntent: () => void,
+    ) {}
+
+    comment(c: string): this {
+        this.addComment(c);
+        return this;
+    }
+
+    newEntity(context: UserContext): OrderItem {
+        this.ensureIntent();
+        return new OrderItem();
+    }
+
+    executeForList(context: UserContext): Promise<SmartList<OrderItem>> {
+        this.ensureIntent();
+        return this.execute(context);
+    }
+
+    executeForRows(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        return this.executeRows(context);
+    }
+
+    executeForPage(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<OrderItem>> {
+        this.ensureIntent();
+        return this.page(context, offset, limit);
+    }
+
+    executeForStream(context: UserContext, chunkSize = 1000): AsyncIterable<OrderItem> {
+        this.ensureIntent();
+        return this.stream(context, chunkSize);
+    }
+
+    async executeForOne(context: UserContext): Promise<OrderItem | undefined> {
+        this.limitOne();
+        return (await this.executeForList(context))[0];
+    }
+}

source/browser-sqlite/orders-lib/src/generated/requests/OrderStatusRequest.ts

@@ -0,0 +1,1162 @@
+import { EntityRoot, SelectQuery, SmartList, TeaQLDataService, TeaQLPage, UserContext, executeRelationFacets } from '../../teaql-ts';
+import { OrderStatus } from '../models/OrderStatus';
+import { mergeGeneratedScalarSearch, DynamicSearchWarning } from 'teaql-ts';
+import { GENERATED_SEARCH_MODELS } from '../../generated-search-models';
+
+
+
+export class OrderStatusRequest {
+    private query: SelectQuery;
+    private filters: any[] = [];
+    private _purpose: string | undefined;
+    private _comment: string | undefined;
+    private _pageCountAlias: string | undefined;
+    private _pageCountMethod: "count" | "countAs" | undefined;
+    private _dynamicSearchWarnings: DynamicSearchWarning[] = [];
+
+    constructor(minimal = false) {
+        this.query = new SelectQuery("OrderStatus");
+        this.filters.push({ version: { "$gte": 1 } });
+        if (minimal) {
+            this.selectId();
+            this.selectVersion();
+        }
+        else this.selectSelfFields();
+    }
+
+    comment(c: string): this {
+        this.query.comment(c);
+        this._comment = c;
+        return this;
+    }
+
+    filterByJson(source: unknown, warn?: (warning: DynamicSearchWarning) => void): this {
+        const base = this.query.clone();
+        if (this.filters.length > 0) base.filter({ "$and": this.filters });
+        const merged = mergeGeneratedScalarSearch(base, source, GENERATED_SEARCH_MODELS, warn);
+        this.query = merged.query as SelectQuery;
+        this.filters = this.query.filterCondition ? [this.query.filterCondition] : [];
+        this._dynamicSearchWarnings.push(...merged.warnings);
+        return this;
+    }
+
+    get dynamicSearchWarnings(): readonly DynamicSearchWarning[] {
+        return this._dynamicSearchWarnings.map(warning => ({ ...warning }));
+    }
+
+    purpose(p: string): ExecutableOrderStatusRequest {
+        this.query.purpose(p);
+        this._purpose = p;
+        return new ExecutableOrderStatusRequest(
+            (context) => this.executeForListInternal(context),
+            (context) => this.executeForRowsInternal(context),
+            (context, offset, limit) => this.executeForPageInternal(context, offset, limit),
+            (context, chunkSize) => this.executeForStreamInternal(context, chunkSize),
+            () => this.limit(1),
+            (c) => this.comment(c),
+            () => this.ensureIntent());
+    }
+
+    optimizeForContinuousPageFetch(): this {
+        this.query.optimizeForContinuousPageFetch();
+        return this;
+    }
+
+    optimizeForContinuousPageFetchWith(namespace: string, ttlSeconds: number): this {
+        this.query.optimizeForContinuousPageFetchWith(namespace, ttlSeconds);
+        return this;
+    }
+
+    optimizePaginationWithIdSet(): this {
+        this.query.optimizePaginationWithIdSet();
+        return this;
+    }
+
+    optimizePaginationWithIdSetConfig(namespace: string, ttlSeconds: number, maxIds: number): this {
+        this.query.optimizePaginationWithIdSetConfig(namespace, ttlSeconds, maxIds);
+        return this;
+    }
+
+    topNProbeParentThreshold(threshold: number): this {
+        this.query.topNProbeParentThreshold(threshold);
+        return this;
+    }
+
+    limit(n: number): this {
+        this.query.limit(n);
+        return this;
+    }
+
+    offset(n: number): this {
+        this.query.offset(n);
+        return this;
+    }
+
+    toQuery(): SelectQuery {
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+        return this.query;
+    }
+
+    withDeletedRows(): this {
+        this.filters = this.filters.filter(filter => !("version" in filter));
+        return this;
+    }
+
+    deletedRowsOnly(): this {
+        this.withDeletedRows();
+        this.filters.push({ version: { "$lte": -1 } });
+        return this;
+    }
+
+    selectSelfFields(): this {
+        this.query.select(["platform", "id", "name", "code", "color", "displayOrder", "version"]);
+        return this;
+    }
+
+    selectId(): this {
+        this.query.select(["id"]);
+        return this;
+    }
+
+    selectName(): this {
+        this.query.select(["name"]);
+        return this;
+    }
+
+    selectCode(): this {
+        this.query.select(["code"]);
+        return this;
+    }
+
+    selectColor(): this {
+        this.query.select(["color"]);
+        return this;
+    }
+
+    selectDisplayOrder(): this {
+        this.query.select(["displayOrder"]);
+        return this;
+    }
+
+    selectVersion(): this {
+        this.query.select(["version"]);
+        return this;
+    }
+
+
+    selectPlatformWith(request: { toQuery(): SelectQuery }): this {
+        this.query.select(["platform"]);
+        this.query.relationQuery(
+            "platform", request.toQuery(), "platform", "id", false,
+            { kind: "relation-select", method: "selectPlatformWith", relation: "platform" });
+        return this;
+    }
+
+    withPlatformMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "platform": {
+                "$inSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+
+    withoutPlatformMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "platform": {
+                "$notInSubquery": { query: request.toQuery(), field: "id" },
+            },
+        });
+        return this;
+    }
+
+    selectCustomerOrderListWith(request: { toQuery(): SelectQuery }): this {
+        this.query.relationQuery(
+            "customerOrderList", request.toQuery(), "id", "status", true,
+            { kind: "relation-select", method: "selectCustomerOrderListWith", relation: "customerOrderList" });
+        return this;
+    }
+
+    haveCustomerOrders(): this {
+        return this.withCustomerOrderListMatching({
+            toQuery: () => new SelectQuery("CustomerOrder"),
+        });
+    }
+
+    haveNoCustomerOrders(): this {
+        return this.withoutCustomerOrderListMatching({
+            toQuery: () => new SelectQuery("CustomerOrder"),
+        });
+    }
+
+    withCustomerOrderListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$inSubquery": {
+                    query: request.toQuery(), field: "status",
+                },
+            },
+        });
+        return this;
+    }
+
+    withoutCustomerOrderListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$notInSubquery": {
+                    query: request.toQuery(), field: "status",
+                },
+            },
+        });
+        return this;
+    }
+
+    countCustomerOrders(): this {
+        return this.countCustomerOrdersAs("countCustomerOrders");
+    }
+
+    countCustomerOrdersAs(alias: string): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        this.countCustomerOrdersWith(alias, { toQuery: () => query });
+        this.query.relationAggregates[this.query.relationAggregates.length - 1].operation = {
+            kind: "relation-count", method: "countCustomerOrdersAs", relation: "customerOrderList", alias };
+        return this;
+    }
+
+    countCustomerOrdersWith(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("Count", "id", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "relation-count", method: "countCustomerOrdersWith", relation: "customerOrderList", alias });
+        return this;
+    }
+
+    minTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.minTotalAmountOfCustomerOrdersAs(
+            "minOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    minTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("min", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "minTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    maxTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.maxTotalAmountOfCustomerOrdersAs(
+            "maxOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    maxTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("max", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "maxTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    sumTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.sumTotalAmountOfCustomerOrdersAs(
+            "sumOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    sumTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("sum", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "sumTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    avgTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.avgTotalAmountOfCustomerOrdersAs(
+            "avgOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    avgTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("avg", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "avgTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    standardDeviationTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.standardDeviationTotalAmountOfCustomerOrdersAs(
+            "standardDeviationOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    standardDeviationTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "standardDeviationTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    squareRootOfPopulationStandardDeviationTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.squareRootOfPopulationStandardDeviationTotalAmountOfCustomerOrdersAs(
+            "squareRootOfPopulationStandardDeviationOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    squareRootOfPopulationStandardDeviationTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev_pop", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "squareRootOfPopulationStandardDeviationTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    sampleVarianceTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.sampleVarianceTotalAmountOfCustomerOrdersAs(
+            "sampleVarianceOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    sampleVarianceTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_samp", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "sampleVarianceTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+    samplePopulationVarianceTotalAmountOfCustomerOrders(): this {
+        const query = new SelectQuery("CustomerOrder").filter({ version: { "$gte": 1 } });
+        return this.samplePopulationVarianceTotalAmountOfCustomerOrdersAs(
+            "samplePopulationVarianceOfTotalAmountOfCustomerOrders", { toQuery: () => query });
+    }
+
+    samplePopulationVarianceTotalAmountOfCustomerOrdersAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_pop", "totalAmount", alias);
+        this.query.relationAggregate("customerOrderList", alias, query, true,
+            { kind: "aggregate", method: "samplePopulationVarianceTotalAmountOfCustomerOrdersAs", relation: "customerOrderList", alias });
+        return this;
+    }
+
+        filterByPlatform(val: any): this {
+            this.filters.push({ "platform": { "$eq": val } });
+            return this;
+        }
+
+        filterByPlatformIn(...vals: any[]): this {
+            this.filters.push({ "platform": { "$in": vals } });
+            return this;
+        }
+
+        withPlatformIsKnown(): this {
+            this.filters.push({ "platform": { "$isNull": false } });
+            return this;
+        }
+
+        withPlatformIsUnknown(): this {
+            this.filters.push({ "platform": { "$isNull": true } });
+            return this;
+        }
+
+        withIdIs(val: any): this {
+            this.filters.push({ "id": { "$eq": val } });
+            return this;
+        }
+
+        withIdIsNot(val: any): this {
+            this.filters.push({ "id": { "$ne": val } });
+            return this;
+        }
+
+        withIdIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$in": vals } });
+            return this;
+        }
+
+        withIdNotIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$notIn": vals } });
+            return this;
+        }
+
+        withIdGreaterThan(val: any): this {
+            this.filters.push({ "id": { "$gt": val } });
+            return this;
+        }
+
+        withIdGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$gte": val } });
+            return this;
+        }
+
+        withIdLessThan(val: any): this {
+            this.filters.push({ "id": { "$lt": val } });
+            return this;
+        }
+
+        withIdLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$lte": val } });
+            return this;
+        }
+
+        withIdBetween(lower: any, upper: any): this {
+            this.filters.push({ "id": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withIdIsKnown(): this {
+            this.filters.push({ "id": { "$isNull": false } });
+            return this;
+        }
+
+        withIdIsUnknown(): this {
+            this.filters.push({ "id": { "$isNull": true } });
+            return this;
+        }
+
+        withNameContaining(val: string): this {
+            this.filters.push({ "name": { "$contains": val } });
+            return this;
+        }
+
+        withNameIs(val: string): this {
+            this.filters.push({ "name": { "$eq": val } });
+            return this;
+        }
+
+        withNameIsNot(val: any): this {
+            this.filters.push({ "name": { "$ne": val } });
+            return this;
+        }
+
+        withNameIn(...vals: any[]): this {
+            this.filters.push({ "name": { "$in": vals } });
+            return this;
+        }
+
+        withNameNotIn(...vals: any[]): this {
+            this.filters.push({ "name": { "$notIn": vals } });
+            return this;
+        }
+
+        withNameGreaterThan(val: any): this {
+            this.filters.push({ "name": { "$gt": val } });
+            return this;
+        }
+
+        withNameGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "name": { "$gte": val } });
+            return this;
+        }
+
+        withNameLessThan(val: any): this {
+            this.filters.push({ "name": { "$lt": val } });
+            return this;
+        }
+
+        withNameLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "name": { "$lte": val } });
+            return this;
+        }
+
+        withNameBetween(lower: any, upper: any): this {
+            this.filters.push({ "name": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withNameIsKnown(): this {
+            this.filters.push({ "name": { "$isNull": false } });
+            return this;
+        }
+
+        withNameIsUnknown(): this {
+            this.filters.push({ "name": { "$isNull": true } });
+            return this;
+        }
+        withNameNotContaining(val: string): this {
+            this.filters.push({ "name": { "$notContains": val } });
+            return this;
+        }
+
+        withNameStartingWith(val: string): this {
+            this.filters.push({ "name": { "$startsWith": val } });
+            return this;
+        }
+
+        withNameNotStartingWith(val: string): this {
+            this.filters.push({ "name": { "$notStartsWith": val } });
+            return this;
+        }
+
+        withNameEndingWith(val: string): this {
+            this.filters.push({ "name": { "$endsWith": val } });
+            return this;
+        }
+
+        withNameNotEndingWith(val: string): this {
+            this.filters.push({ "name": { "$notEndsWith": val } });
+            return this;
+        }
+
+        withNameSoundingLike(val: string): this {
+            this.filters.push({ "name": { "$soundLike": val } });
+            return this;
+        }
+
+        withCodeContaining(val: string): this {
+            this.filters.push({ "code": { "$contains": val } });
+            return this;
+        }
+
+        withCodeIs(val: string): this {
+            this.filters.push({ "code": { "$eq": val } });
+            return this;
+        }
+
+        withCodeIsNot(val: any): this {
+            this.filters.push({ "code": { "$ne": val } });
+            return this;
+        }
+
+        withCodeIn(...vals: any[]): this {
+            this.filters.push({ "code": { "$in": vals } });
+            return this;
+        }
+
+        withCodeNotIn(...vals: any[]): this {
+            this.filters.push({ "code": { "$notIn": vals } });
+            return this;
+        }
+
+        withCodeGreaterThan(val: any): this {
+            this.filters.push({ "code": { "$gt": val } });
+            return this;
+        }
+
+        withCodeGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "code": { "$gte": val } });
+            return this;
+        }
+
+        withCodeLessThan(val: any): this {
+            this.filters.push({ "code": { "$lt": val } });
+            return this;
+        }
+
+        withCodeLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "code": { "$lte": val } });
+            return this;
+        }
+
+        withCodeBetween(lower: any, upper: any): this {
+            this.filters.push({ "code": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withCodeIsKnown(): this {
+            this.filters.push({ "code": { "$isNull": false } });
+            return this;
+        }
+
+        withCodeIsUnknown(): this {
+            this.filters.push({ "code": { "$isNull": true } });
+            return this;
+        }
+        withCodeNotContaining(val: string): this {
+            this.filters.push({ "code": { "$notContains": val } });
+            return this;
+        }
+
+        withCodeStartingWith(val: string): this {
+            this.filters.push({ "code": { "$startsWith": val } });
+            return this;
+        }
+
+        withCodeNotStartingWith(val: string): this {
+            this.filters.push({ "code": { "$notStartsWith": val } });
+            return this;
+        }
+
+        withCodeEndingWith(val: string): this {
+            this.filters.push({ "code": { "$endsWith": val } });
+            return this;
+        }
+
+        withCodeNotEndingWith(val: string): this {
+            this.filters.push({ "code": { "$notEndsWith": val } });
+            return this;
+        }
+
+        withCodeSoundingLike(val: string): this {
+            this.filters.push({ "code": { "$soundLike": val } });
+            return this;
+        }
+
+        withColorContaining(val: string): this {
+            this.filters.push({ "color": { "$contains": val } });
+            return this;
+        }
+
+        withColorIs(val: string): this {
+            this.filters.push({ "color": { "$eq": val } });
+            return this;
+        }
+
+        withColorIsNot(val: any): this {
+            this.filters.push({ "color": { "$ne": val } });
+            return this;
+        }
+
+        withColorIn(...vals: any[]): this {
+            this.filters.push({ "color": { "$in": vals } });
+            return this;
+        }
+
+        withColorNotIn(...vals: any[]): this {
+            this.filters.push({ "color": { "$notIn": vals } });
+            return this;
+        }
+
+        withColorGreaterThan(val: any): this {
+            this.filters.push({ "color": { "$gt": val } });
+            return this;
+        }
+
+        withColorGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "color": { "$gte": val } });
+            return this;
+        }
+
+        withColorLessThan(val: any): this {
+            this.filters.push({ "color": { "$lt": val } });
+            return this;
+        }
+
+        withColorLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "color": { "$lte": val } });
+            return this;
+        }
+
+        withColorBetween(lower: any, upper: any): this {
+            this.filters.push({ "color": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withColorIsKnown(): this {
+            this.filters.push({ "color": { "$isNull": false } });
+            return this;
+        }
+
+        withColorIsUnknown(): this {
+            this.filters.push({ "color": { "$isNull": true } });
+            return this;
+        }
+        withColorNotContaining(val: string): this {
+            this.filters.push({ "color": { "$notContains": val } });
+            return this;
+        }
+
+        withColorStartingWith(val: string): this {
+            this.filters.push({ "color": { "$startsWith": val } });
+            return this;
+        }
+
+        withColorNotStartingWith(val: string): this {
+            this.filters.push({ "color": { "$notStartsWith": val } });
+            return this;
+        }
+
+        withColorEndingWith(val: string): this {
+            this.filters.push({ "color": { "$endsWith": val } });
+            return this;
+        }
+
+        withColorNotEndingWith(val: string): this {
+            this.filters.push({ "color": { "$notEndsWith": val } });
+            return this;
+        }
+
+        withColorSoundingLike(val: string): this {
+            this.filters.push({ "color": { "$soundLike": val } });
+            return this;
+        }
+
+        withDisplayOrderIs(val: any): this {
+            this.filters.push({ "displayOrder": { "$eq": val } });
+            return this;
+        }
+
+        withDisplayOrderIsNot(val: any): this {
+            this.filters.push({ "displayOrder": { "$ne": val } });
+            return this;
+        }
+
+        withDisplayOrderIn(...vals: any[]): this {
+            this.filters.push({ "displayOrder": { "$in": vals } });
+            return this;
+        }
+
+        withDisplayOrderNotIn(...vals: any[]): this {
+            this.filters.push({ "displayOrder": { "$notIn": vals } });
+            return this;
+        }
+
+        withDisplayOrderGreaterThan(val: any): this {
+            this.filters.push({ "displayOrder": { "$gt": val } });
+            return this;
+        }
+
+        withDisplayOrderGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "displayOrder": { "$gte": val } });
+            return this;
+        }
+
+        withDisplayOrderLessThan(val: any): this {
+            this.filters.push({ "displayOrder": { "$lt": val } });
+            return this;
+        }
+
+        withDisplayOrderLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "displayOrder": { "$lte": val } });
+            return this;
+        }
+
+        withDisplayOrderBetween(lower: any, upper: any): this {
+            this.filters.push({ "displayOrder": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withDisplayOrderIsKnown(): this {
+            this.filters.push({ "displayOrder": { "$isNull": false } });
+            return this;
+        }
+
+        withDisplayOrderIsUnknown(): this {
+            this.filters.push({ "displayOrder": { "$isNull": true } });
+            return this;
+        }
+
+        withVersionIs(val: any): this {
+            this.filters.push({ "version": { "$eq": val } });
+            return this;
+        }
+
+        withVersionIsNot(val: any): this {
+            this.filters.push({ "version": { "$ne": val } });
+            return this;
+        }
+
+        withVersionIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$in": vals } });
+            return this;
+        }
+
+        withVersionNotIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$notIn": vals } });
+            return this;
+        }
+
+        withVersionGreaterThan(val: any): this {
+            this.filters.push({ "version": { "$gt": val } });
+            return this;
+        }
+
+        withVersionGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$gte": val } });
+            return this;
+        }
+
+        withVersionLessThan(val: any): this {
+            this.filters.push({ "version": { "$lt": val } });
+            return this;
+        }
+
+        withVersionLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$lte": val } });
+            return this;
+        }
+
+        withVersionBetween(lower: any, upper: any): this {
+            this.filters.push({ "version": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withVersionIsKnown(): this {
+            this.filters.push({ "version": { "$isNull": false } });
+            return this;
+        }
+
+        withVersionIsUnknown(): this {
+            this.filters.push({ "version": { "$isNull": true } });
+            return this;
+        }
+
+    orderByIdAscending(): this {
+        this.query.orderBy("id", "asc");
+        return this;
+    }
+
+    orderByIdDescending(): this {
+        this.query.orderBy("id", "desc");
+        return this;
+    }
+
+    orderByNameAscending(): this {
+        this.query.orderBy("name", "asc");
+        return this;
+    }
+
+    orderByNameDescending(): this {
+        this.query.orderBy("name", "desc");
+        return this;
+    }
+
+    orderByCodeAscending(): this {
+        this.query.orderBy("code", "asc");
+        return this;
+    }
+
+    orderByCodeDescending(): this {
+        this.query.orderBy("code", "desc");
+        return this;
+    }
+
+    orderByColorAscending(): this {
+        this.query.orderBy("color", "asc");
+        return this;
+    }
+
+    orderByColorDescending(): this {
+        this.query.orderBy("color", "desc");
+        return this;
+    }
+
+    orderByDisplayOrderAscending(): this {
+        this.query.orderBy("displayOrder", "asc");
+        return this;
+    }
+
+    orderByDisplayOrderDescending(): this {
+        this.query.orderBy("displayOrder", "desc");
+        return this;
+    }
+
+    orderByVersionAscending(): this {
+        this.query.orderBy("version", "asc");
+        return this;
+    }
+
+    orderByVersionDescending(): this {
+        this.query.orderBy("version", "desc");
+        return this;
+    }
+
+
+    // --- Aggregations ---
+    count(): this {
+        this.query.aggregate("Count", "id", "count");
+        this._pageCountAlias = "count";
+        this._pageCountMethod = "count";
+        return this;
+    }
+
+    countAs(retName: string): this {
+        this.query.aggregate("Count", "id", retName);
+        this._pageCountAlias = retName;
+        this._pageCountMethod = "countAs";
+        return this;
+    }
+
+    minDisplayOrder(): this {
+        return this.minDisplayOrderAs("minOfDisplayOrder");
+    }
+
+    minDisplayOrderAs(retName: string): this {
+        this.query.aggregate("min", "displayOrder", retName);
+        return this;
+    }
+    maxDisplayOrder(): this {
+        return this.maxDisplayOrderAs("maxOfDisplayOrder");
+    }
+
+    maxDisplayOrderAs(retName: string): this {
+        this.query.aggregate("max", "displayOrder", retName);
+        return this;
+    }
+    sumDisplayOrder(): this {
+        return this.sumDisplayOrderAs("sumOfDisplayOrder");
+    }
+
+    sumDisplayOrderAs(retName: string): this {
+        this.query.aggregate("sum", "displayOrder", retName);
+        return this;
+    }
+    avgDisplayOrder(): this {
+        return this.avgDisplayOrderAs("avgOfDisplayOrder");
+    }
+
+    avgDisplayOrderAs(retName: string): this {
+        this.query.aggregate("avg", "displayOrder", retName);
+        return this;
+    }
+    standardDeviationDisplayOrder(): this {
+        return this.standardDeviationDisplayOrderAs("standardDeviationOfDisplayOrder");
+    }
+
+    standardDeviationDisplayOrderAs(retName: string): this {
+        this.query.aggregate("stddev", "displayOrder", retName);
+        return this;
+    }
+    squareRootOfPopulationStandardDeviationDisplayOrder(): this {
+        return this.squareRootOfPopulationStandardDeviationDisplayOrderAs("squareRootOfPopulationStandardDeviationOfDisplayOrder");
+    }
+
+    squareRootOfPopulationStandardDeviationDisplayOrderAs(retName: string): this {
+        this.query.aggregate("stddev_pop", "displayOrder", retName);
+        return this;
+    }
+    sampleVarianceDisplayOrder(): this {
+        return this.sampleVarianceDisplayOrderAs("sampleVarianceOfDisplayOrder");
+    }
+
+    sampleVarianceDisplayOrderAs(retName: string): this {
+        this.query.aggregate("var_samp", "displayOrder", retName);
+        return this;
+    }
+    samplePopulationVarianceDisplayOrder(): this {
+        return this.samplePopulationVarianceDisplayOrderAs("samplePopulationVarianceOfDisplayOrder");
+    }
+
+    samplePopulationVarianceDisplayOrderAs(retName: string): this {
+        this.query.aggregate("var_pop", "displayOrder", retName);
+        return this;
+    }
+
+    // --- Group By ---
+    groupByPlatform(): this {
+        this.query.groupBy("platform");
+        return this;
+    }
+
+    groupByPlatformAs(retName: string): this {
+        this.query.groupBy("platform"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupById(): this {
+        this.query.groupBy("id");
+        return this;
+    }
+
+    groupByIdAs(retName: string): this {
+        this.query.groupBy("id"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByName(): this {
+        this.query.groupBy("name");
+        return this;
+    }
+
+    groupByNameAs(retName: string): this {
+        this.query.groupBy("name"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByCode(): this {
+        this.query.groupBy("code");
+        return this;
+    }
+
+    groupByCodeAs(retName: string): this {
+        this.query.groupBy("code"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByColor(): this {
+        this.query.groupBy("color");
+        return this;
+    }
+
+    groupByColorAs(retName: string): this {
+        this.query.groupBy("color"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByDisplayOrder(): this {
+        this.query.groupBy("displayOrder");
+        return this;
+    }
+
+    groupByDisplayOrderAs(retName: string): this {
+        this.query.groupBy("displayOrder"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByVersion(): this {
+        this.query.groupBy("version");
+        return this;
+    }
+
+    groupByVersionAs(retName: string): this {
+        this.query.groupBy("version"); // In TS we don't alias group by yet natively
+        return this;
+    }
+
+    // --- Facets ---
+    facetByPlatformAs(
+        facetName: string,
+        request: { toQuery(): SelectQuery },
+        includeAllFacets = true,
+    ): this {
+        this.query.facetBy(facetName, "platform", request, includeAllFacets,
+            { kind: "facet", method: "facetByPlatformAs", relation: "platform", alias: facetName });
+        return this;
+    }
+
+
+    private async executeForListInternal(context: UserContext): Promise<SmartList<OrderStatus>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const rows = await service.executeQuery(context.prepareQuery(this.query));
+        const queryRoot = new EntityRoot();
+        const aggregateOnly = this.query.aggregateItems.length > 0 && this.query.groupByItems.length === 0;
+        const data = aggregateOnly ? [] : rows.map((row: unknown) =>
+            row instanceof OrderStatus
+                ? row
+                : OrderStatus.fromRecord(row as Record<string, unknown>, queryRoot));
+        const result = new SmartList<OrderStatus>(data);
+        if (aggregateOnly && rows[0]) Object.assign(result.aggregations, rows[0]);
+
+        if (this.query.facets.length > 0) {
+            result.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+
+        return result;
+    }
+
+    private async executeForRowsInternal(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return new SmartList<Record<string, unknown>>(
+            await service.executeQuery(context.prepareQuery(this.query)) as Record<string, unknown>[]);
+    }
+
+    private async executeForPageInternal(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<OrderStatus>> {
+        this.ensureIntent();
+        this.query.offset(offset).limit(limit);
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const useIdSet = this.query.localIdSetPaginationOptions() !== undefined;
+        const countOperation = { kind: "named-count" as const,
+            method: this._pageCountMethod ?? "count",
+            ...(this._pageCountMethod === "countAs" ? { alias: this._pageCountAlias } : {}) };
+        const totalCountBeforeRows = useIdSet ? undefined : await service.executeCount(
+            this.query, this._pageCountAlias, countOperation);
+        const pageQuery = this.query.clone();
+        // A page count describes the full filtered set, not an aggregate-only page row.
+        pageQuery.aggregateItems = pageQuery.aggregateItems.filter(item =>
+            !(String(item.function).toLowerCase() === "count" && item.alias === this._pageCountAlias));
+        const rows = await service.executeQuery(context.prepareQuery(pageQuery));
+        const totalCount = useIdSet && context.idSetPaginationCountAccuracy === "EXACT"
+            ? context.idSetPaginationCount!
+            : (totalCountBeforeRows ?? await service.executeCount(this.query, this._pageCountAlias, countOperation));
+        const queryRoot = new EntityRoot();
+        const data = new SmartList(rows.map((row: unknown) =>
+            row instanceof OrderStatus
+                ? row
+                : OrderStatus.fromRecord(row as Record<string, unknown>, queryRoot)));
+        data.totalCount = totalCount;
+        if (this._pageCountAlias !== undefined) data.aggregations[this._pageCountAlias] = totalCount;
+        if (this.query.facets.length > 0) {
+            data.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+        return { data, totalCount, offset, limit };
+    }
+
+    private async *executeForStreamInternal(context: UserContext, chunkSize: number): AsyncIterable<OrderStatus> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const queryRoot = new EntityRoot();
+        for await (const chunk of service.executeForStream(this.query, chunkSize)) {
+            for (const entity of chunk) {
+                yield entity instanceof OrderStatus
+                    ? entity
+                    : OrderStatus.fromRecord(entity as Record<string, unknown>, queryRoot);
+            }
+        }
+    }
+
+    private ensureIntent(): void {
+        if (!this._comment?.trim()) {
+            throw new Error("Security audit failure: non-empty comment() is required before execution");
+        }
+        if (!this._purpose?.trim()) {
+            throw new Error("Security audit failure: non-empty purpose() is required before execution");
+        }
+    }
+
+}
+
+export class ExecutableOrderStatusRequest {
+    constructor(
+        private readonly execute: (context: UserContext) => Promise<SmartList<OrderStatus>>,
+        private readonly executeRows: (context: UserContext) => Promise<SmartList<Record<string, unknown>>>,
+        private readonly page: (
+            context: UserContext, offset: number, limit: number,
+        ) => Promise<TeaQLPage<OrderStatus>>,
+        private readonly stream: (context: UserContext, chunkSize: number) => AsyncIterable<OrderStatus>,
+        private readonly limitOne: () => void,
+        private readonly addComment: (comment: string) => void,
+        private readonly ensureIntent: () => void,
+    ) {}
+
+    comment(c: string): this {
+        this.addComment(c);
+        return this;
+    }
+
+    newEntity(context: UserContext): OrderStatus {
+        this.ensureIntent();
+        return new OrderStatus();
+    }
+
+    executeForList(context: UserContext): Promise<SmartList<OrderStatus>> {
+        this.ensureIntent();
+        return this.execute(context);
+    }
+
+    executeForRows(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        return this.executeRows(context);
+    }
+
+    executeForPage(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<OrderStatus>> {
+        this.ensureIntent();
+        return this.page(context, offset, limit);
+    }
+
+    executeForStream(context: UserContext, chunkSize = 1000): AsyncIterable<OrderStatus> {
+        this.ensureIntent();
+        return this.stream(context, chunkSize);
+    }
+
+    async executeForOne(context: UserContext): Promise<OrderStatus | undefined> {
+        this.limitOne();
+        return (await this.executeForList(context))[0];
+    }
+}

source/browser-sqlite/orders-lib/src/generated/requests/PlatformRequest.ts

@@ -0,0 +1,791 @@
+import { EntityRoot, SelectQuery, SmartList, TeaQLDataService, TeaQLPage, UserContext, executeRelationFacets } from '../../teaql-ts';
+import { Platform } from '../models/Platform';
+import { mergeGeneratedScalarSearch, DynamicSearchWarning } from 'teaql-ts';
+import { GENERATED_SEARCH_MODELS } from '../../generated-search-models';
+
+
+
+export class PlatformRequest {
+    private query: SelectQuery;
+    private filters: any[] = [];
+    private _purpose: string | undefined;
+    private _comment: string | undefined;
+    private _pageCountAlias: string | undefined;
+    private _pageCountMethod: "count" | "countAs" | undefined;
+    private _dynamicSearchWarnings: DynamicSearchWarning[] = [];
+
+    constructor(minimal = false) {
+        this.query = new SelectQuery("Platform");
+        this.filters.push({ version: { "$gte": 1 } });
+        if (minimal) {
+            this.selectId();
+            this.selectVersion();
+        }
+        else this.selectSelfFields();
+    }
+
+    comment(c: string): this {
+        this.query.comment(c);
+        this._comment = c;
+        return this;
+    }
+
+    filterByJson(source: unknown, warn?: (warning: DynamicSearchWarning) => void): this {
+        const base = this.query.clone();
+        if (this.filters.length > 0) base.filter({ "$and": this.filters });
+        const merged = mergeGeneratedScalarSearch(base, source, GENERATED_SEARCH_MODELS, warn);
+        this.query = merged.query as SelectQuery;
+        this.filters = this.query.filterCondition ? [this.query.filterCondition] : [];
+        this._dynamicSearchWarnings.push(...merged.warnings);
+        return this;
+    }
+
+    get dynamicSearchWarnings(): readonly DynamicSearchWarning[] {
+        return this._dynamicSearchWarnings.map(warning => ({ ...warning }));
+    }
+
+    purpose(p: string): ExecutablePlatformRequest {
+        this.query.purpose(p);
+        this._purpose = p;
+        return new ExecutablePlatformRequest(
+            (context) => this.executeForListInternal(context),
+            (context) => this.executeForRowsInternal(context),
+            (context, offset, limit) => this.executeForPageInternal(context, offset, limit),
+            (context, chunkSize) => this.executeForStreamInternal(context, chunkSize),
+            () => this.limit(1),
+            (c) => this.comment(c),
+            () => this.ensureIntent());
+    }
+
+    optimizeForContinuousPageFetch(): this {
+        this.query.optimizeForContinuousPageFetch();
+        return this;
+    }
+
+    optimizeForContinuousPageFetchWith(namespace: string, ttlSeconds: number): this {
+        this.query.optimizeForContinuousPageFetchWith(namespace, ttlSeconds);
+        return this;
+    }
+
+    optimizePaginationWithIdSet(): this {
+        this.query.optimizePaginationWithIdSet();
+        return this;
+    }
+
+    optimizePaginationWithIdSetConfig(namespace: string, ttlSeconds: number, maxIds: number): this {
+        this.query.optimizePaginationWithIdSetConfig(namespace, ttlSeconds, maxIds);
+        return this;
+    }
+
+    topNProbeParentThreshold(threshold: number): this {
+        this.query.topNProbeParentThreshold(threshold);
+        return this;
+    }
+
+    limit(n: number): this {
+        this.query.limit(n);
+        return this;
+    }
+
+    offset(n: number): this {
+        this.query.offset(n);
+        return this;
+    }
+
+    toQuery(): SelectQuery {
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+        return this.query;
+    }
+
+    withDeletedRows(): this {
+        this.filters = this.filters.filter(filter => !("version" in filter));
+        return this;
+    }
+
+    deletedRowsOnly(): this {
+        this.withDeletedRows();
+        this.filters.push({ version: { "$lte": -1 } });
+        return this;
+    }
+
+    selectSelfFields(): this {
+        this.query.select(["id", "name", "version"]);
+        return this;
+    }
+
+    selectId(): this {
+        this.query.select(["id"]);
+        return this;
+    }
+
+    selectName(): this {
+        this.query.select(["name"]);
+        return this;
+    }
+
+    selectVersion(): this {
+        this.query.select(["version"]);
+        return this;
+    }
+
+
+
+
+    selectOrderStatusListWith(request: { toQuery(): SelectQuery }): this {
+        this.query.relationQuery(
+            "orderStatusList", request.toQuery(), "id", "platform", true,
+            { kind: "relation-select", method: "selectOrderStatusListWith", relation: "orderStatusList" });
+        return this;
+    }
+    selectCustomerListWith(request: { toQuery(): SelectQuery }): this {
+        this.query.relationQuery(
+            "customerList", request.toQuery(), "id", "platform", true,
+            { kind: "relation-select", method: "selectCustomerListWith", relation: "customerList" });
+        return this;
+    }
+
+    haveOrderStatuses(): this {
+        return this.withOrderStatusListMatching({
+            toQuery: () => new SelectQuery("OrderStatus"),
+        });
+    }
+
+    haveNoOrderStatuses(): this {
+        return this.withoutOrderStatusListMatching({
+            toQuery: () => new SelectQuery("OrderStatus"),
+        });
+    }
+
+    withOrderStatusListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$inSubquery": {
+                    query: request.toQuery(), field: "platform",
+                },
+            },
+        });
+        return this;
+    }
+
+    withoutOrderStatusListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$notInSubquery": {
+                    query: request.toQuery(), field: "platform",
+                },
+            },
+        });
+        return this;
+    }
+    haveCustomers(): this {
+        return this.withCustomerListMatching({
+            toQuery: () => new SelectQuery("Customer"),
+        });
+    }
+
+    haveNoCustomers(): this {
+        return this.withoutCustomerListMatching({
+            toQuery: () => new SelectQuery("Customer"),
+        });
+    }
+
+    withCustomerListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$inSubquery": {
+                    query: request.toQuery(), field: "platform",
+                },
+            },
+        });
+        return this;
+    }
+
+    withoutCustomerListMatching(request: { toQuery(): SelectQuery }): this {
+        this.filters.push({
+            "id": {
+                "$notInSubquery": {
+                    query: request.toQuery(), field: "platform",
+                },
+            },
+        });
+        return this;
+    }
+
+    countOrderStatuses(): this {
+        return this.countOrderStatusesAs("countOrderStatuses");
+    }
+
+    countOrderStatusesAs(alias: string): this {
+        const query = new SelectQuery("OrderStatus").filter({ version: { "$gte": 1 } });
+        this.countOrderStatusesWith(alias, { toQuery: () => query });
+        this.query.relationAggregates[this.query.relationAggregates.length - 1].operation = {
+            kind: "relation-count", method: "countOrderStatusesAs", relation: "orderStatusList", alias };
+        return this;
+    }
+
+    countOrderStatusesWith(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("Count", "id", alias);
+        this.query.relationAggregate("orderStatusList", alias, query, true,
+            { kind: "relation-count", method: "countOrderStatusesWith", relation: "orderStatusList", alias });
+        return this;
+    }
+
+    minDisplayOrderOfOrderStatuses(): this {
+        const query = new SelectQuery("OrderStatus").filter({ version: { "$gte": 1 } });
+        return this.minDisplayOrderOfOrderStatusesAs(
+            "minOfDisplayOrderOfOrderStatuses", { toQuery: () => query });
+    }
+
+    minDisplayOrderOfOrderStatusesAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("min", "displayOrder", alias);
+        this.query.relationAggregate("orderStatusList", alias, query, true,
+            { kind: "aggregate", method: "minDisplayOrderOfOrderStatusesAs", relation: "orderStatusList", alias });
+        return this;
+    }
+    maxDisplayOrderOfOrderStatuses(): this {
+        const query = new SelectQuery("OrderStatus").filter({ version: { "$gte": 1 } });
+        return this.maxDisplayOrderOfOrderStatusesAs(
+            "maxOfDisplayOrderOfOrderStatuses", { toQuery: () => query });
+    }
+
+    maxDisplayOrderOfOrderStatusesAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("max", "displayOrder", alias);
+        this.query.relationAggregate("orderStatusList", alias, query, true,
+            { kind: "aggregate", method: "maxDisplayOrderOfOrderStatusesAs", relation: "orderStatusList", alias });
+        return this;
+    }
+    sumDisplayOrderOfOrderStatuses(): this {
+        const query = new SelectQuery("OrderStatus").filter({ version: { "$gte": 1 } });
+        return this.sumDisplayOrderOfOrderStatusesAs(
+            "sumOfDisplayOrderOfOrderStatuses", { toQuery: () => query });
+    }
+
+    sumDisplayOrderOfOrderStatusesAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("sum", "displayOrder", alias);
+        this.query.relationAggregate("orderStatusList", alias, query, true,
+            { kind: "aggregate", method: "sumDisplayOrderOfOrderStatusesAs", relation: "orderStatusList", alias });
+        return this;
+    }
+    avgDisplayOrderOfOrderStatuses(): this {
+        const query = new SelectQuery("OrderStatus").filter({ version: { "$gte": 1 } });
+        return this.avgDisplayOrderOfOrderStatusesAs(
+            "avgOfDisplayOrderOfOrderStatuses", { toQuery: () => query });
+    }
+
+    avgDisplayOrderOfOrderStatusesAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("avg", "displayOrder", alias);
+        this.query.relationAggregate("orderStatusList", alias, query, true,
+            { kind: "aggregate", method: "avgDisplayOrderOfOrderStatusesAs", relation: "orderStatusList", alias });
+        return this;
+    }
+    standardDeviationDisplayOrderOfOrderStatuses(): this {
+        const query = new SelectQuery("OrderStatus").filter({ version: { "$gte": 1 } });
+        return this.standardDeviationDisplayOrderOfOrderStatusesAs(
+            "standardDeviationOfDisplayOrderOfOrderStatuses", { toQuery: () => query });
+    }
+
+    standardDeviationDisplayOrderOfOrderStatusesAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev", "displayOrder", alias);
+        this.query.relationAggregate("orderStatusList", alias, query, true,
+            { kind: "aggregate", method: "standardDeviationDisplayOrderOfOrderStatusesAs", relation: "orderStatusList", alias });
+        return this;
+    }
+    squareRootOfPopulationStandardDeviationDisplayOrderOfOrderStatuses(): this {
+        const query = new SelectQuery("OrderStatus").filter({ version: { "$gte": 1 } });
+        return this.squareRootOfPopulationStandardDeviationDisplayOrderOfOrderStatusesAs(
+            "squareRootOfPopulationStandardDeviationOfDisplayOrderOfOrderStatuses", { toQuery: () => query });
+    }
+
+    squareRootOfPopulationStandardDeviationDisplayOrderOfOrderStatusesAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("stddev_pop", "displayOrder", alias);
+        this.query.relationAggregate("orderStatusList", alias, query, true,
+            { kind: "aggregate", method: "squareRootOfPopulationStandardDeviationDisplayOrderOfOrderStatusesAs", relation: "orderStatusList", alias });
+        return this;
+    }
+    sampleVarianceDisplayOrderOfOrderStatuses(): this {
+        const query = new SelectQuery("OrderStatus").filter({ version: { "$gte": 1 } });
+        return this.sampleVarianceDisplayOrderOfOrderStatusesAs(
+            "sampleVarianceOfDisplayOrderOfOrderStatuses", { toQuery: () => query });
+    }
+
+    sampleVarianceDisplayOrderOfOrderStatusesAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_samp", "displayOrder", alias);
+        this.query.relationAggregate("orderStatusList", alias, query, true,
+            { kind: "aggregate", method: "sampleVarianceDisplayOrderOfOrderStatusesAs", relation: "orderStatusList", alias });
+        return this;
+    }
+    samplePopulationVarianceDisplayOrderOfOrderStatuses(): this {
+        const query = new SelectQuery("OrderStatus").filter({ version: { "$gte": 1 } });
+        return this.samplePopulationVarianceDisplayOrderOfOrderStatusesAs(
+            "samplePopulationVarianceOfDisplayOrderOfOrderStatuses", { toQuery: () => query });
+    }
+
+    samplePopulationVarianceDisplayOrderOfOrderStatusesAs(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("var_pop", "displayOrder", alias);
+        this.query.relationAggregate("orderStatusList", alias, query, true,
+            { kind: "aggregate", method: "samplePopulationVarianceDisplayOrderOfOrderStatusesAs", relation: "orderStatusList", alias });
+        return this;
+    }
+    countCustomers(): this {
+        return this.countCustomersAs("countCustomers");
+    }
+
+    countCustomersAs(alias: string): this {
+        const query = new SelectQuery("Customer").filter({ version: { "$gte": 1 } });
+        this.countCustomersWith(alias, { toQuery: () => query });
+        this.query.relationAggregates[this.query.relationAggregates.length - 1].operation = {
+            kind: "relation-count", method: "countCustomersAs", relation: "customerList", alias };
+        return this;
+    }
+
+    countCustomersWith(alias: string, child: { toQuery(): SelectQuery }): this {
+        const query = child.toQuery().clone();
+        query.aggregateItems = [];
+        query.aggregate("Count", "id", alias);
+        this.query.relationAggregate("customerList", alias, query, true,
+            { kind: "relation-count", method: "countCustomersWith", relation: "customerList", alias });
+        return this;
+    }
+
+
+
+        withIdIs(val: any): this {
+            this.filters.push({ "id": { "$eq": val } });
+            return this;
+        }
+
+        withIdIsNot(val: any): this {
+            this.filters.push({ "id": { "$ne": val } });
+            return this;
+        }
+
+        withIdIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$in": vals } });
+            return this;
+        }
+
+        withIdNotIn(...vals: any[]): this {
+            this.filters.push({ "id": { "$notIn": vals } });
+            return this;
+        }
+
+        withIdGreaterThan(val: any): this {
+            this.filters.push({ "id": { "$gt": val } });
+            return this;
+        }
+
+        withIdGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$gte": val } });
+            return this;
+        }
+
+        withIdLessThan(val: any): this {
+            this.filters.push({ "id": { "$lt": val } });
+            return this;
+        }
+
+        withIdLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "id": { "$lte": val } });
+            return this;
+        }
+
+        withIdBetween(lower: any, upper: any): this {
+            this.filters.push({ "id": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withIdIsKnown(): this {
+            this.filters.push({ "id": { "$isNull": false } });
+            return this;
+        }
+
+        withIdIsUnknown(): this {
+            this.filters.push({ "id": { "$isNull": true } });
+            return this;
+        }
+
+        withNameContaining(val: string): this {
+            this.filters.push({ "name": { "$contains": val } });
+            return this;
+        }
+
+        withNameIs(val: string): this {
+            this.filters.push({ "name": { "$eq": val } });
+            return this;
+        }
+
+        withNameIsNot(val: any): this {
+            this.filters.push({ "name": { "$ne": val } });
+            return this;
+        }
+
+        withNameIn(...vals: any[]): this {
+            this.filters.push({ "name": { "$in": vals } });
+            return this;
+        }
+
+        withNameNotIn(...vals: any[]): this {
+            this.filters.push({ "name": { "$notIn": vals } });
+            return this;
+        }
+
+        withNameGreaterThan(val: any): this {
+            this.filters.push({ "name": { "$gt": val } });
+            return this;
+        }
+
+        withNameGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "name": { "$gte": val } });
+            return this;
+        }
+
+        withNameLessThan(val: any): this {
+            this.filters.push({ "name": { "$lt": val } });
+            return this;
+        }
+
+        withNameLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "name": { "$lte": val } });
+            return this;
+        }
+
+        withNameBetween(lower: any, upper: any): this {
+            this.filters.push({ "name": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withNameIsKnown(): this {
+            this.filters.push({ "name": { "$isNull": false } });
+            return this;
+        }
+
+        withNameIsUnknown(): this {
+            this.filters.push({ "name": { "$isNull": true } });
+            return this;
+        }
+        withNameNotContaining(val: string): this {
+            this.filters.push({ "name": { "$notContains": val } });
+            return this;
+        }
+
+        withNameStartingWith(val: string): this {
+            this.filters.push({ "name": { "$startsWith": val } });
+            return this;
+        }
+
+        withNameNotStartingWith(val: string): this {
+            this.filters.push({ "name": { "$notStartsWith": val } });
+            return this;
+        }
+
+        withNameEndingWith(val: string): this {
+            this.filters.push({ "name": { "$endsWith": val } });
+            return this;
+        }
+
+        withNameNotEndingWith(val: string): this {
+            this.filters.push({ "name": { "$notEndsWith": val } });
+            return this;
+        }
+
+        withNameSoundingLike(val: string): this {
+            this.filters.push({ "name": { "$soundLike": val } });
+            return this;
+        }
+
+        withVersionIs(val: any): this {
+            this.filters.push({ "version": { "$eq": val } });
+            return this;
+        }
+
+        withVersionIsNot(val: any): this {
+            this.filters.push({ "version": { "$ne": val } });
+            return this;
+        }
+
+        withVersionIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$in": vals } });
+            return this;
+        }
+
+        withVersionNotIn(...vals: any[]): this {
+            this.filters.push({ "version": { "$notIn": vals } });
+            return this;
+        }
+
+        withVersionGreaterThan(val: any): this {
+            this.filters.push({ "version": { "$gt": val } });
+            return this;
+        }
+
+        withVersionGreaterThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$gte": val } });
+            return this;
+        }
+
+        withVersionLessThan(val: any): this {
+            this.filters.push({ "version": { "$lt": val } });
+            return this;
+        }
+
+        withVersionLessThanOrEqualTo(val: any): this {
+            this.filters.push({ "version": { "$lte": val } });
+            return this;
+        }
+
+        withVersionBetween(lower: any, upper: any): this {
+            this.filters.push({ "version": { "$between": [lower, upper] } });
+            return this;
+        }
+
+        withVersionIsKnown(): this {
+            this.filters.push({ "version": { "$isNull": false } });
+            return this;
+        }
+
+        withVersionIsUnknown(): this {
+            this.filters.push({ "version": { "$isNull": true } });
+            return this;
+        }
+
+    orderByIdAscending(): this {
+        this.query.orderBy("id", "asc");
+        return this;
+    }
+
+    orderByIdDescending(): this {
+        this.query.orderBy("id", "desc");
+        return this;
+    }
+
+    orderByNameAscending(): this {
+        this.query.orderBy("name", "asc");
+        return this;
+    }
+
+    orderByNameDescending(): this {
+        this.query.orderBy("name", "desc");
+        return this;
+    }
+
+    orderByVersionAscending(): this {
+        this.query.orderBy("version", "asc");
+        return this;
+    }
+
+    orderByVersionDescending(): this {
+        this.query.orderBy("version", "desc");
+        return this;
+    }
+
+
+    // --- Aggregations ---
+    count(): this {
+        this.query.aggregate("Count", "id", "count");
+        this._pageCountAlias = "count";
+        this._pageCountMethod = "count";
+        return this;
+    }
+
+    countAs(retName: string): this {
+        this.query.aggregate("Count", "id", retName);
+        this._pageCountAlias = retName;
+        this._pageCountMethod = "countAs";
+        return this;
+    }
+
+
+    // --- Group By ---
+    groupById(): this {
+        this.query.groupBy("id");
+        return this;
+    }
+
+    groupByIdAs(retName: string): this {
+        this.query.groupBy("id"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByName(): this {
+        this.query.groupBy("name");
+        return this;
+    }
+
+    groupByNameAs(retName: string): this {
+        this.query.groupBy("name"); // In TS we don't alias group by yet natively
+        return this;
+    }
+    groupByVersion(): this {
+        this.query.groupBy("version");
+        return this;
+    }
+
+    groupByVersionAs(retName: string): this {
+        this.query.groupBy("version"); // In TS we don't alias group by yet natively
+        return this;
+    }
+
+    // --- Facets ---
+
+    private async executeForListInternal(context: UserContext): Promise<SmartList<Platform>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) {
+            this.query.filter({ "$and": this.filters });
+        }
+
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const rows = await service.executeQuery(context.prepareQuery(this.query));
+        const queryRoot = new EntityRoot();
+        const aggregateOnly = this.query.aggregateItems.length > 0 && this.query.groupByItems.length === 0;
+        const data = aggregateOnly ? [] : rows.map((row: unknown) =>
+            row instanceof Platform
+                ? row
+                : Platform.fromRecord(row as Record<string, unknown>, queryRoot));
+        const result = new SmartList<Platform>(data);
+        if (aggregateOnly && rows[0]) Object.assign(result.aggregations, rows[0]);
+
+        if (this.query.facets.length > 0) {
+            result.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+
+        return result;
+    }
+
+    private async executeForRowsInternal(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        return new SmartList<Record<string, unknown>>(
+            await service.executeQuery(context.prepareQuery(this.query)) as Record<string, unknown>[]);
+    }
+
+    private async executeForPageInternal(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<Platform>> {
+        this.ensureIntent();
+        this.query.offset(offset).limit(limit);
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const useIdSet = this.query.localIdSetPaginationOptions() !== undefined;
+        const countOperation = { kind: "named-count" as const,
+            method: this._pageCountMethod ?? "count",
+            ...(this._pageCountMethod === "countAs" ? { alias: this._pageCountAlias } : {}) };
+        const totalCountBeforeRows = useIdSet ? undefined : await service.executeCount(
+            this.query, this._pageCountAlias, countOperation);
+        const pageQuery = this.query.clone();
+        // A page count describes the full filtered set, not an aggregate-only page row.
+        pageQuery.aggregateItems = pageQuery.aggregateItems.filter(item =>
+            !(String(item.function).toLowerCase() === "count" && item.alias === this._pageCountAlias));
+        const rows = await service.executeQuery(context.prepareQuery(pageQuery));
+        const totalCount = useIdSet && context.idSetPaginationCountAccuracy === "EXACT"
+            ? context.idSetPaginationCount!
+            : (totalCountBeforeRows ?? await service.executeCount(this.query, this._pageCountAlias, countOperation));
+        const queryRoot = new EntityRoot();
+        const data = new SmartList(rows.map((row: unknown) =>
+            row instanceof Platform
+                ? row
+                : Platform.fromRecord(row as Record<string, unknown>, queryRoot)));
+        data.totalCount = totalCount;
+        if (this._pageCountAlias !== undefined) data.aggregations[this._pageCountAlias] = totalCount;
+        if (this.query.facets.length > 0) {
+            data.facets = await executeRelationFacets(
+                service, (query: any) => context.prepareQuery(query), this.query, this.query.facets);
+        }
+        return { data, totalCount, offset, limit };
+    }
+
+    private async *executeForStreamInternal(context: UserContext, chunkSize: number): AsyncIterable<Platform> {
+        this.ensureIntent();
+        if (this.filters.length > 0) this.query.filter({ "$and": this.filters });
+        const service = context.requireResource<TeaQLDataService>("dataService");
+        const queryRoot = new EntityRoot();
+        for await (const chunk of service.executeForStream(this.query, chunkSize)) {
+            for (const entity of chunk) {
+                yield entity instanceof Platform
+                    ? entity
+                    : Platform.fromRecord(entity as Record<string, unknown>, queryRoot);
+            }
+        }
+    }
+
+    private ensureIntent(): void {
+        if (!this._comment?.trim()) {
+            throw new Error("Security audit failure: non-empty comment() is required before execution");
+        }
+        if (!this._purpose?.trim()) {
+            throw new Error("Security audit failure: non-empty purpose() is required before execution");
+        }
+    }
+
+}
+
+export class ExecutablePlatformRequest {
+    constructor(
+        private readonly execute: (context: UserContext) => Promise<SmartList<Platform>>,
+        private readonly executeRows: (context: UserContext) => Promise<SmartList<Record<string, unknown>>>,
+        private readonly page: (
+            context: UserContext, offset: number, limit: number,
+        ) => Promise<TeaQLPage<Platform>>,
+        private readonly stream: (context: UserContext, chunkSize: number) => AsyncIterable<Platform>,
+        private readonly limitOne: () => void,
+        private readonly addComment: (comment: string) => void,
+        private readonly ensureIntent: () => void,
+    ) {}
+
+    comment(c: string): this {
+        this.addComment(c);
+        return this;
+    }
+
+    newEntity(context: UserContext): Platform {
+        this.ensureIntent();
+        return new Platform();
+    }
+
+    executeForList(context: UserContext): Promise<SmartList<Platform>> {
+        this.ensureIntent();
+        return this.execute(context);
+    }
+
+    executeForRows(context: UserContext): Promise<SmartList<Record<string, unknown>>> {
+        this.ensureIntent();
+        return this.executeRows(context);
+    }
+
+    executeForPage(
+        context: UserContext, offset: number, limit: number,
+    ): Promise<TeaQLPage<Platform>> {
+        this.ensureIntent();
+        return this.page(context, offset, limit);
+    }
+
+    executeForStream(context: UserContext, chunkSize = 1000): AsyncIterable<Platform> {
+        this.ensureIntent();
+        return this.stream(context, chunkSize);
+    }
+
+    async executeForOne(context: UserContext): Promise<Platform | undefined> {
+        this.limitOne();
+        return (await this.executeForList(context))[0];
+    }
+}

source/browser-sqlite/orders-lib/src/runtime-module.ts

@@ -0,0 +1,150 @@
+import { ObjectLocation, RuntimeModule } from "teaql-ts";
+import { ENTITY_SCHEMAS } from "./teaql-schemas";
+import { ensureGeneratedBootstrap } from "./generated-bootstrap";
+
+/** Generated canonical KSML to selected-wire mapping. Never infer this from TS members. */
+export const GENERATED_WIRE_MODEL_METADATA = Object.freeze({
+  profile: "camelCase" as const,
+  entities: Object.freeze({
+    "Platform": Object.freeze({
+      entityType: "Platform",
+      profile: "camelCase" as const,
+      fields: Object.freeze({
+        "id": Object.freeze({ canonicalName: "id", wireName: "id", aliases: Object.freeze([] as string[]) }),
+        "name": Object.freeze({ canonicalName: "name", wireName: "name", aliases: Object.freeze([] as string[]) }),
+        "version": Object.freeze({ canonicalName: "version", wireName: "version", aliases: Object.freeze([] as string[]) })
+      }),
+    }),
+    "OrderStatus": Object.freeze({
+      entityType: "OrderStatus",
+      profile: "camelCase" as const,
+      fields: Object.freeze({
+        "platform": Object.freeze({ canonicalName: "platform", wireName: "platform", aliases: Object.freeze([] as string[]) }),
+        "id": Object.freeze({ canonicalName: "id", wireName: "id", aliases: Object.freeze([] as string[]) }),
+        "name": Object.freeze({ canonicalName: "name", wireName: "name", aliases: Object.freeze([] as string[]) }),
+        "code": Object.freeze({ canonicalName: "code", wireName: "code", aliases: Object.freeze([] as string[]) }),
+        "color": Object.freeze({ canonicalName: "color", wireName: "color", aliases: Object.freeze([] as string[]) }),
+        "display_order": Object.freeze({ canonicalName: "display_order", wireName: "displayOrder", aliases: Object.freeze([] as string[]) }),
+        "version": Object.freeze({ canonicalName: "version", wireName: "version", aliases: Object.freeze([] as string[]) })
+      }),
+    }),
+    "Customer": Object.freeze({
+      entityType: "Customer",
+      profile: "camelCase" as const,
+      fields: Object.freeze({
+        "id": Object.freeze({ canonicalName: "id", wireName: "id", aliases: Object.freeze([] as string[]) }),
+        "platform": Object.freeze({ canonicalName: "platform", wireName: "platform", aliases: Object.freeze([] as string[]) }),
+        "name": Object.freeze({ canonicalName: "name", wireName: "name", aliases: Object.freeze([] as string[]) }),
+        "version": Object.freeze({ canonicalName: "version", wireName: "version", aliases: Object.freeze([] as string[]) })
+      }),
+    }),
+    "CustomerOrder": Object.freeze({
+      entityType: "CustomerOrder",
+      profile: "camelCase" as const,
+      fields: Object.freeze({
+        "id": Object.freeze({ canonicalName: "id", wireName: "id", aliases: Object.freeze([] as string[]) }),
+        "customer": Object.freeze({ canonicalName: "customer", wireName: "customer", aliases: Object.freeze([] as string[]) }),
+        "status": Object.freeze({ canonicalName: "status", wireName: "status", aliases: Object.freeze([] as string[]) }),
+        "order_number": Object.freeze({ canonicalName: "order_number", wireName: "orderNumber", aliases: Object.freeze([] as string[]) }),
+        "order_date": Object.freeze({ canonicalName: "order_date", wireName: "orderDate", aliases: Object.freeze([] as string[]) }),
+        "total_amount": Object.freeze({ canonicalName: "total_amount", wireName: "totalAmount", aliases: Object.freeze([] as string[]) }),
+        "version": Object.freeze({ canonicalName: "version", wireName: "version", aliases: Object.freeze([] as string[]) })
+      }),
+    }),
+    "OrderItem": Object.freeze({
+      entityType: "OrderItem",
+      profile: "camelCase" as const,
+      fields: Object.freeze({
+        "id": Object.freeze({ canonicalName: "id", wireName: "id", aliases: Object.freeze([] as string[]) }),
+        "customer_order": Object.freeze({ canonicalName: "customer_order", wireName: "customerOrder", aliases: Object.freeze([] as string[]) }),
+        "product_name": Object.freeze({ canonicalName: "product_name", wireName: "productName", aliases: Object.freeze([] as string[]) }),
+        "quantity": Object.freeze({ canonicalName: "quantity", wireName: "quantity", aliases: Object.freeze([] as string[]) }),
+        "unit_price": Object.freeze({ canonicalName: "unit_price", wireName: "unitPrice", aliases: Object.freeze([] as string[]) }),
+        "version": Object.freeze({ canonicalName: "version", wireName: "version", aliases: Object.freeze([] as string[]) })
+      }),
+    })
+  }),
+});
+
+/** Passive generated metadata manifest. It never modifies the database schema. */
+export const GENERATED_RUNTIME_MODULE = new RuntimeModule(ENTITY_SCHEMAS, {
+  "Platform": {
+    checkAndFix(context, mutation, results) {
+      const now = context.getResource("fixTime");
+      if ((mutation.action === "Create" && mutation.payload["name"] === undefined) || mutation.payload["name"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("name") });
+      if (mutation.payload["name"] != null && [...String(mutation.payload["name"])].length > 100) results.push({ ruleId: "max_length", location: ObjectLocation.property("name"), inputValue: mutation.payload["name"], systemValue: 100 });
+
+
+    },
+  },
+  "OrderStatus": {
+    checkAndFix(context, mutation, results) {
+      const now = context.getResource("fixTime");
+      if ((mutation.action === "Create" && mutation.payload["platform"] === undefined) || mutation.payload["platform"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("platform") });
+
+
+      if ((mutation.action === "Create" && mutation.payload["name"] === undefined) || mutation.payload["name"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("name") });
+      if (mutation.payload["name"] != null && [...String(mutation.payload["name"])].length > 100) results.push({ ruleId: "max_length", location: ObjectLocation.property("name"), inputValue: mutation.payload["name"], systemValue: 100 });
+
+      if ((mutation.action === "Create" && mutation.payload["code"] === undefined) || mutation.payload["code"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("code") });
+      if (mutation.payload["code"] != null && [...String(mutation.payload["code"])].length > 100) results.push({ ruleId: "max_length", location: ObjectLocation.property("code"), inputValue: mutation.payload["code"], systemValue: 100 });
+
+      if ((mutation.action === "Create" && mutation.payload["color"] === undefined) || mutation.payload["color"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("color") });
+      if (mutation.payload["color"] != null && [...String(mutation.payload["color"])].length > 100) results.push({ ruleId: "max_length", location: ObjectLocation.property("color"), inputValue: mutation.payload["color"], systemValue: 100 });
+
+      if ((mutation.action === "Create" && mutation.payload["display_order"] === undefined) || mutation.payload["display_order"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("display_order") });
+
+
+    },
+  },
+  "Customer": {
+    checkAndFix(context, mutation, results) {
+      const now = context.getResource("fixTime");
+      if ((mutation.action === "Create" && mutation.payload["platform"] === undefined) || mutation.payload["platform"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("platform") });
+
+      if ((mutation.action === "Create" && mutation.payload["name"] === undefined) || mutation.payload["name"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("name") });
+      if (mutation.payload["name"] != null && [...String(mutation.payload["name"])].length > 100) results.push({ ruleId: "max_length", location: ObjectLocation.property("name"), inputValue: mutation.payload["name"], systemValue: 100 });
+
+
+    },
+  },
+  "CustomerOrder": {
+    checkAndFix(context, mutation, results) {
+      const now = context.getResource("fixTime");
+      if ((mutation.action === "Create" && mutation.payload["customer"] === undefined) || mutation.payload["customer"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("customer") });
+
+      if ((mutation.action === "Create" && mutation.payload["status"] === undefined) || mutation.payload["status"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("status") });
+
+      if ((mutation.action === "Create" && mutation.payload["order_number"] === undefined) || mutation.payload["order_number"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("order_number") });
+      if (mutation.payload["order_number"] != null && [...String(mutation.payload["order_number"])].length > 100) results.push({ ruleId: "max_length", location: ObjectLocation.property("order_number"), inputValue: mutation.payload["order_number"], systemValue: 100 });
+
+      if ((mutation.action === "Create" && mutation.payload["order_date"] === undefined) || mutation.payload["order_date"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("order_date") });
+
+      if ((mutation.action === "Create" && mutation.payload["total_amount"] === undefined) || mutation.payload["total_amount"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("total_amount") });
+
+
+    },
+  },
+  "OrderItem": {
+    checkAndFix(context, mutation, results) {
+      const now = context.getResource("fixTime");
+      if ((mutation.action === "Create" && mutation.payload["customer_order"] === undefined) || mutation.payload["customer_order"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("customer_order") });
+
+      if ((mutation.action === "Create" && mutation.payload["product_name"] === undefined) || mutation.payload["product_name"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("product_name") });
+      if (mutation.payload["product_name"] != null && [...String(mutation.payload["product_name"])].length > 100) results.push({ ruleId: "max_length", location: ObjectLocation.property("product_name"), inputValue: mutation.payload["product_name"], systemValue: 100 });
+
+      if ((mutation.action === "Create" && mutation.payload["quantity"] === undefined) || mutation.payload["quantity"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("quantity") });
+
+      if ((mutation.action === "Create" && mutation.payload["unit_price"] === undefined) || mutation.payload["unit_price"] === null) results.push({ ruleId: "required", location: ObjectLocation.property("unit_price") });
+
+
+    },
+  }
+}, { ...{
+  defaultDomainRoot: { entity: "Platform", id: "1", values: { "name": "Commerce Test Platform" } },
+  constants: [
+    { entity: "OrderStatus", id: "1001", values: { "platform": "1", "name": "New", "code": "NEW", "color": "#94A3B8", "displayOrder": 1 } },
+    { entity: "OrderStatus", id: "1002", values: { "platform": "1", "name": "Paid", "code": "PAID", "color": "#22C55E", "displayOrder": 2 } },
+    { entity: "OrderStatus", id: "1003", values: { "platform": "1", "name": "Cancelled", "code": "CANCELLED", "color": "#EF4444", "displayOrder": 3 } }
+  ]
+}, ensure: ensureGeneratedBootstrap });

source/browser-sqlite/orders-lib/src/teaql-schemas.ts

@@ -0,0 +1,34 @@
+import { EntitySchema } from "teaql-ts/sql/core";
+
+export const ENTITY_SCHEMAS: Record<string, EntitySchema> = {
+"Platform": {
+    table: "platform_data",
+    auditMaskFields: [],
+    columns: {"id": { columnName: "id", modelName: "id", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "name": { columnName: "name", modelName: "name", logPolicy: "plain", logicalType: "text", decode: "native", nullable: false }, "version": { columnName: "version", modelName: "version", logPolicy: "plain", logicalType: "integer", decode: "number", nullable: false }},
+    relations: {"orderStatusList": { targetEntity: "OrderStatus", localKey: "id", foreignKey: "platform", many: true }, "customerList": { targetEntity: "Customer", localKey: "id", foreignKey: "platform", many: true }}
+},
+"OrderStatus": {
+    table: "order_status_data",
+    auditMaskFields: [],
+    columns: {"platform": { columnName: "platform", modelName: "platform", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "id": { columnName: "id", modelName: "id", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "name": { columnName: "name", modelName: "name", logPolicy: "plain", logicalType: "text", decode: "native", nullable: false }, "code": { columnName: "code", modelName: "code", logPolicy: "plain", logicalType: "text", decode: "native", nullable: false }, "color": { columnName: "color", modelName: "color", logPolicy: "plain", logicalType: "text", decode: "native", nullable: false }, "displayOrder": { columnName: "display_order", modelName: "display_order", logPolicy: "plain", logicalType: "integer", decode: "number", nullable: false }, "version": { columnName: "version", modelName: "version", logPolicy: "plain", logicalType: "integer", decode: "number", nullable: false }},
+    relations: {"platform": { targetEntity: "Platform", localKey: "platform", foreignKey: "id", many: false }, "customerOrderList": { targetEntity: "CustomerOrder", localKey: "id", foreignKey: "status", many: true }}
+},
+"Customer": {
+    table: "customer_data",
+    auditMaskFields: [],
+    columns: {"id": { columnName: "id", modelName: "id", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "platform": { columnName: "platform", modelName: "platform", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "name": { columnName: "name", modelName: "name", logPolicy: "plain", logicalType: "text", decode: "native", nullable: false }, "version": { columnName: "version", modelName: "version", logPolicy: "plain", logicalType: "integer", decode: "number", nullable: false }},
+    relations: {"platform": { targetEntity: "Platform", localKey: "platform", foreignKey: "id", many: false }, "customerOrderList": { targetEntity: "CustomerOrder", localKey: "id", foreignKey: "customer", many: true }}
+},
+"CustomerOrder": {
+    table: "customer_order_data",
+    auditMaskFields: [],
+    columns: {"id": { columnName: "id", modelName: "id", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "customer": { columnName: "customer", modelName: "customer", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "status": { columnName: "status", modelName: "status", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "orderNumber": { columnName: "order_number", modelName: "order_number", logPolicy: "plain", logicalType: "text", decode: "native", nullable: false }, "orderDate": { columnName: "order_date", modelName: "order_date", logPolicy: "plain", logicalType: "date", decode: "date", nullable: false }, "totalAmount": { columnName: "total_amount", modelName: "total_amount", logPolicy: "plain", logicalType: "decimal", decode: "number", nullable: false }, "version": { columnName: "version", modelName: "version", logPolicy: "plain", logicalType: "integer", decode: "number", nullable: false }},
+    relations: {"customer": { targetEntity: "Customer", localKey: "customer", foreignKey: "id", many: false }, "status": { targetEntity: "OrderStatus", localKey: "status", foreignKey: "id", many: false }, "orderItemList": { targetEntity: "OrderItem", localKey: "id", foreignKey: "customerOrder", many: true }}
+},
+"OrderItem": {
+    table: "order_item_data",
+    auditMaskFields: [],
+    columns: {"id": { columnName: "id", modelName: "id", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "customerOrder": { columnName: "customer_order", modelName: "customer_order", logPolicy: "plain", logicalType: "integer", decode: "string", nullable: false }, "productName": { columnName: "product_name", modelName: "product_name", logPolicy: "plain", logicalType: "text", decode: "native", nullable: false }, "quantity": { columnName: "quantity", modelName: "quantity", logPolicy: "plain", logicalType: "integer", decode: "number", nullable: false }, "unitPrice": { columnName: "unit_price", modelName: "unit_price", logPolicy: "plain", logicalType: "decimal", decode: "number", nullable: false }, "version": { columnName: "version", modelName: "version", logPolicy: "plain", logicalType: "integer", decode: "number", nullable: false }},
+    relations: {"customerOrder": { targetEntity: "CustomerOrder", localKey: "customerOrder", foreignKey: "id", many: false }}
+}
+};

source/browser-sqlite/orders-lib/src/teaql-ts.ts

@@ -0,0 +1,308 @@
+import {
+    CheckException, EntityChecker, RuntimeModule,
+    SelectQuery as RuntimeSelectQuery, UserContext,
+    executeRelationFacets, QueryRequest, MutationIntent, MutationRequest, GraphMutationSession,
+} from "teaql-ts";
+
+export { CheckException, EntityRoot, ObjectLocation, SmartList, UserContext, executeRelationFacets, MutationIntent } from "teaql-ts";
+export { GraphMutationSession, LoadedScalarSnapshot, MutationTraceScope } from "teaql-ts";
+export type { EntityKey } from "teaql-ts";
+export type { TeaQLPage } from "teaql-ts";
+import type { QueryOperation } from "teaql-ts";
+
+function soundex(input: unknown): string {
+    const text = String(input ?? "").toUpperCase().replace(/[^A-Z]/g, "");
+    if (!text) return "";
+    const code = (char: string): string => "BFPV".includes(char) ? "1"
+        : "CGJKQSXZ".includes(char) ? "2" : "DT".includes(char) ? "3"
+        : char === "L" ? "4" : "MN".includes(char) ? "5" : char === "R" ? "6" : "";
+    let result = text[0], previous = code(text[0]);
+    for (const char of text.slice(1)) {
+        const current = code(char);
+        if (current && current !== previous) result += current;
+        previous = current;
+        if (result.length === 4) break;
+    }
+    return (result + "000").slice(0, 4);
+}
+
+/** Generated naming adapter; query policy and execution remain in the formal runtime. */
+export class SelectQuery extends RuntimeSelectQuery {
+    orderBy(field: string, direction: string): this {
+        return this.order({ field, expr: null, direction: direction === "desc" ? "Desc" : "Asc" } as any);
+    }
+
+    relationQuery(
+        name: string, query: RuntimeSelectQuery, localKey = "id", foreignKey = "id", many = true,
+        operation?: QueryOperation,
+    ): this {
+        return super.relationQuery(name, query, localKey, foreignKey, many, operation);
+    }
+}
+
+export interface TeaQLDataService {
+    executeGraphSave<T>(intent: MutationIntent, work: (graph: GraphMutationSession) => Promise<T>): Promise<T>;
+    preflightMutation(mutation: any): any;
+    afterGraphCommit(work: () => void): void;
+    afterGraphRollback(work: () => void): void;
+    executeMutation(mutation: any): Promise<any>;
+    executeQuery(query: any): Promise<any[]>;
+    executeCount(query: any, alias?: string, operation?: QueryOperation): Promise<number>;
+    executeForStream(query: any, chunkSize?: number): AsyncIterable<any[]>;
+    close?(): Promise<void>;
+}
+
+export class TeaQLClient implements TeaQLDataService {
+    private data: Record<string, Record<string, any>> = {};
+    private nextIds: Record<string, number> = {};
+    private readonly checkers: Record<string, EntityChecker> = {};
+    private userContext = new UserContext();
+    private graphSaveActive = false;
+    private graphCommitActions: Array<() => void> = [];
+    private graphRollbackActions: Array<() => void> = [];
+    private graphSaveTail: Promise<void> = Promise.resolve();
+    private readonly mutationGovernanceEvents: any[] = [];
+
+    constructor(private storagePath?: string) {
+        if (storagePath) {
+            const fs = require("fs");
+            if (fs.existsSync(storagePath)) {
+                const state = JSON.parse(fs.readFileSync(storagePath, "utf8"));
+                this.data = state.data || {};
+                this.nextIds = state.nextIds || {};
+            }
+        }
+    }
+
+    /** Installs passive generated metadata. It never mutates storage. */
+    install(module: RuntimeModule): this {
+        Object.assign(this.checkers, module.checkers);
+        return this;
+    }
+
+    setUserContext(context: UserContext): this {
+        this.userContext = context;
+        return this;
+    }
+
+    get mutationGovernanceTrace(): readonly any[] {
+        return [...this.mutationGovernanceEvents];
+    }
+
+    private persist() {
+        if (!this.storagePath) return;
+        const fs = require("fs");
+        const path = require("path");
+        fs.mkdirSync(path.dirname(path.resolve(this.storagePath)), { recursive: true });
+        const temporaryPath = `${this.storagePath}.tmp`;
+        fs.writeFileSync(temporaryPath, JSON.stringify({ data: this.data, nextIds: this.nextIds }));
+        fs.renameSync(temporaryPath, this.storagePath);
+    }
+
+    async executeGraphSave<T>(intent: MutationIntent, work: (graph: GraphMutationSession) => Promise<T>): Promise<T> {
+        const graph = new GraphMutationSession(intent);
+        const predecessor = this.graphSaveTail;
+        let release!: () => void;
+        this.graphSaveTail = new Promise<void>(resolve => { release = resolve; });
+        await predecessor;
+        const dataSnapshot = JSON.parse(JSON.stringify(this.data));
+        const nextIdsSnapshot = { ...this.nextIds };
+        let fixEvidenceStarted = false;
+        let mutationPolicyGraphStarted = false;
+        try {
+            this.graphSaveActive = true;
+            this.graphCommitActions = [];
+            this.graphRollbackActions = [];
+            this.userContext.insertResource("fixTime", new Date());
+            this.userContext.beginFixEvidence();
+            fixEvidenceStarted = true;
+            this.userContext.beginMutationPolicyGraph();
+            mutationPolicyGraphStarted = true;
+            const result = await work(graph);
+            this.userContext.ensureMutationPolicyGraphComplete();
+            this.persist();
+            for (const action of this.graphCommitActions) action();
+            return result;
+        } catch (error) {
+            this.data = dataSnapshot;
+            this.nextIds = nextIdsSnapshot;
+            for (const action of [...this.graphRollbackActions].reverse()) action();
+            throw error;
+        } finally {
+            this.graphSaveActive = false;
+            this.graphCommitActions = [];
+            this.graphRollbackActions = [];
+            if (mutationPolicyGraphStarted) this.userContext.endMutationPolicyGraph();
+            this.userContext.removeResource("fixTime");
+            if (fixEvidenceStarted) this.userContext.finishFixEvidence();
+            release();
+        }
+    }
+
+    afterGraphCommit(work: () => void): void {
+        if (!this.graphSaveActive) throw new Error("No graph save is active");
+        this.graphCommitActions.push(work);
+    }
+
+    afterGraphRollback(work: () => void): void {
+        if (!this.graphSaveActive) throw new Error("No graph save is active");
+        this.graphRollbackActions.push(work);
+    }
+
+    preflightMutation(mutation: any): any {
+        mutation = this.checkAndFixMutation(mutation);
+        this.userContext.recordMutationPolicyPreflight(mutation);
+        return mutation;
+    }
+
+    private checkAndFixMutation(mutation: any): any {
+        if (mutation instanceof MutationRequest) mutation = mutation.mutation;
+        if (!String(mutation?.comment || "").trim()) throw new Error("Security audit failure: audit reason is required before mutation");
+        mutation = { ...mutation, payload: { ...(mutation?.payload || {}) } };
+        const checker = this.checkers[String(mutation.entity)];
+        if (!checker) return mutation;
+        const results: any[] = [];
+        const ownsFixTime = this.userContext.getResource("fixTime") === undefined;
+        if (ownsFixTime) this.userContext.insertResource("fixTime", new Date()).beginFixEvidence();
+        try {
+            checker.checkAndFix(this.userContext, mutation, results);
+            if (mutation.ledgerKey && mutation.ledgerRoot) for (const [field, value] of Object.entries(mutation.payload)) mutation.ledgerRoot.set(mutation.ledgerKey, field, value);
+            this.userContext.translateCheckResults(results);
+            if (results.length) throw new CheckException(results);
+            return mutation;
+        } finally { if (ownsFixTime) this.userContext.removeResource("fixTime").finishFixEvidence(); }
+    }
+
+    async executeMutation(mutation: any): Promise<any> {
+        mutation = this.checkAndFixMutation(mutation);
+        const mutationGovernance = this.userContext.enterMutationPolicy(mutation);
+        this.mutationGovernanceEvents.push(mutationGovernance);
+        const table = this.data[mutation.entity] ||= {};
+        if (mutation.action === "Create") {
+            const id = mutation.id ?? String(this.nextIds[mutation.entity] || 1);
+            this.nextIds[mutation.entity] = Number(id) + 1;
+            const record = { ...mutation.payload, id: String(id), version: Number(mutation.version || 0) + 1 };
+            table[String(id)] = record;
+            if (!this.graphSaveActive) this.persist();
+            return { success: true, id: String(id), version: record.version, persistedRecord: { ...record } };
+        }
+        if (mutation.action === "Update") {
+            const id = String(mutation.id);
+            if (!table[id]) throw new Error(`${mutation.entity}(${id}) does not exist`);
+            const expectedVersion = Number(mutation.version);
+            const currentVersion = Number(table[id].version || 0);
+            if (!Number.isFinite(expectedVersion) || expectedVersion !== currentVersion) {
+                throw new Error(
+                    `Optimistic lock conflict for ${mutation.entity}(${id}): expected ${expectedVersion}, current ${currentVersion}`);
+            }
+            table[id] = { ...table[id], ...mutation.payload, id, version: Number(table[id].version || 0) + 1 };
+            if (!this.graphSaveActive) this.persist();
+            return { success: true, id, version: table[id].version, persistedRecord: { ...table[id] } };
+        }
+        if (mutation.action === "Delete") {
+            const id = String(mutation.id);
+            if (!table[id]) throw new Error(`${mutation.entity}(${id}) does not exist`);
+            const expectedVersion = Number(mutation.version);
+            const currentVersion = Number(table[id].version || 0);
+            if (!Number.isFinite(expectedVersion) || expectedVersion !== currentVersion) {
+                throw new Error(
+                    `Optimistic lock conflict for ${mutation.entity}(${id}): expected ${expectedVersion}, current ${currentVersion}`);
+            }
+            table[id] = { ...table[id], id, version: -(currentVersion + 1) };
+            if (!this.graphSaveActive) this.persist();
+            return { success: true, id, version: table[id].version, deleted: true, persistedRecord: { ...table[id] } };
+        }
+        throw new Error(`Unsupported mutation action: ${mutation.action}`);
+    }
+    async query(context: any, req: any): Promise<any> {
+        return { rows: [] };
+    }
+    async executeQuery(query: any): Promise<any> {
+        if (!(query instanceof RuntimeSelectQuery)) {
+            throw new Error("TeaQL list execution requires the formal runtime SelectQuery");
+        }
+        query.prepareForList();
+        let rows = Object.values(this.data[query.entity] || {}).map((row: any) => ({ ...row }));
+        const matches = (row: any, expression: any): boolean => {
+            if (expression?.$and) return expression.$and.every((item: any) => matches(row, item));
+            return Object.entries(expression || {}).every(([field, predicate]: [string, any]) => {
+                if (predicate?.$eq !== undefined) return row[field] === (predicate.$eq?.id ?? predicate.$eq);
+                if (predicate?.$ne !== undefined) return row[field] !== (predicate.$ne?.id ?? predicate.$ne);
+                if (predicate?.$contains !== undefined) return String(row[field] ?? "").includes(String(predicate.$contains));
+                if (predicate?.$notContains !== undefined) return !String(row[field] ?? "").includes(String(predicate.$notContains));
+                if (predicate?.$startsWith !== undefined) return String(row[field] ?? "").startsWith(String(predicate.$startsWith));
+                if (predicate?.$notStartsWith !== undefined) return !String(row[field] ?? "").startsWith(String(predicate.$notStartsWith));
+                if (predicate?.$endsWith !== undefined) return String(row[field] ?? "").endsWith(String(predicate.$endsWith));
+                if (predicate?.$notEndsWith !== undefined) return !String(row[field] ?? "").endsWith(String(predicate.$notEndsWith));
+                if (predicate?.$soundLike !== undefined) return soundex(row[field]) === soundex(predicate.$soundLike);
+                if (predicate?.$in !== undefined) return predicate.$in.some((value: any) => row[field] === (value?.id ?? value));
+                if (predicate?.$notIn !== undefined) return !predicate.$notIn.some((value: any) => row[field] === (value?.id ?? value));
+                if (predicate?.$between !== undefined) return row[field] >= predicate.$between[0] && row[field] <= predicate.$between[1];
+                if (predicate?.$isNull === true) return row[field] === null || row[field] === undefined;
+                if (predicate?.$isNull === false) return row[field] !== null && row[field] !== undefined;
+                if (predicate?.$gt !== undefined) return row[field] > predicate.$gt;
+                if (predicate?.$gte !== undefined) return row[field] >= predicate.$gte;
+                if (predicate?.$lt !== undefined) return row[field] < predicate.$lt;
+                if (predicate?.$lte !== undefined) return row[field] <= predicate.$lte;
+                return true;
+            });
+        };
+        if (query.filterCondition) rows = rows.filter(row => matches(row, query.filterCondition));
+        if (query.aggregateItems?.length) {
+            return [Object.fromEntries(query.aggregateItems.map((aggregate: any) => {
+                if (String(aggregate.function).toLowerCase() !== "count") {
+                    throw new Error(`Unsupported local aggregate: ${aggregate.function}`);
+                }
+                return [aggregate.alias, rows.length];
+            }))];
+        }
+        for (const order of [...query.orderItems].reverse()) {
+            rows.sort((a, b) => (a[order.field] === b[order.field] ? 0 : a[order.field] > b[order.field] ? 1 : -1) * (String(order.direction).toLowerCase() === "desc" ? -1 : 1));
+        }
+        const start = query.offsetValue || 0;
+        rows = rows.slice(start, start + query.limitValue);
+        for (const relation of (query.relations || []) as any[]) {
+            const localValues = new Set(rows.map((row: any) => row[relation.localKey || "id"]));
+            const relatedRows = (await this.executeQuery(relation.query)).filter(
+                (row: any) => localValues.has(row[relation.foreignKey || "id"]));
+            for (const row of rows) {
+                const matches = relatedRows.filter(
+                    (related: any) => related[relation.foreignKey || "id"] === row[relation.localKey || "id"]);
+                row[relation.name] = relation.many === false ? matches[0] : matches;
+            }
+        }
+        if (query.selectItems.length > 0) {
+            const selections = new Set(query.selectItems);
+            for (const relation of (query.relations || []) as any[]) selections.add(relation.name);
+            rows = rows.map((row: any) => Object.fromEntries(
+                Object.entries(row).filter(([field]) => selections.has(field))));
+        }
+        return rows;
+    }
+    async executeCount(query: any, countAlias?: string, operation?: QueryOperation): Promise<number> {
+        if (typeof query?.forExactCount !== "function") {
+            throw new Error("TeaQL exact count requires the formal runtime SelectQuery");
+        }
+        const alias = countAlias ?? "__teaql_total";
+        const request = new QueryRequest(query).deriveOperation(query.forExactCount(alias), operation ?? {
+            kind: "named-count", ...(countAlias === undefined ? {} : { alias: countAlias }) });
+        const rows = await this.executeQuery(request.query);
+        const value = rows[0]?.[alias];
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+            throw new Error(`TeaQL provider did not return exact count alias ${alias}`);
+        }
+        return value;
+    }
+    async *executeForStream(query: any, chunkSize = 1000): AsyncIterable<any[]> {
+        if (!Number.isInteger(chunkSize) || chunkSize <= 0) throw new Error("stream chunk size must be a positive integer");
+        const rows = await this.executeQuery(query);
+        for (let offset = 0; offset < rows.length; offset += chunkSize) {
+            yield rows.slice(offset, offset + chunkSize);
+        }
+    }
+}
+
+declare const require: any;
+
+export function eq(a: any, b: any) { return {type: 'eq', field: a, value: b}; }
+export function contain(a: any, b: any) { return {type: 'contain', field: a, value: b}; }

source/browser-sqlite/orders-lib/teaql-i18n.json

@@ -0,0 +1,128 @@
+{
+    "schema": "teaql.i18n/v1",
+    "defaultLocale": "en",
+    "locales": {
+        "de": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "ko": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "pt": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "zh-TW": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "fil": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "en": {
+            "vocabulary": {
+                "property.platform.name": "Name",
+                "property.customerOrder.orderNumber": "Order Number",
+                "property.orderItem.id": "Id",
+                "entity.orderItem": "Order Item",
+                "property.orderItem.customerOrder": "Customer Order",
+                "property.orderStatus.version": "Version",
+                "property.orderItem.unitPrice": "Unit Price",
+                "property.orderItem.productName": "Product Name",
+                "property.orderStatus.code": "Code",
+                "property.customerOrder.orderDate": "Order Date",
+                "entity.customerOrder": "Customer Order",
+                "property.orderStatus.displayOrder": "Display Order",
+                "entity.customer": "Customer",
+                "property.customerOrder.id": "Id",
+                "property.orderStatus.color": "Color",
+                "property.customerOrder.totalAmount": "Total Amount",
+                "property.customerOrder.version": "Version",
+                "entity.platform": "Platform",
+                "property.platform.id": "Id",
+                "property.customer.version": "Version",
+                "property.orderStatus.id": "Id",
+                "property.customer.id": "Id",
+                "property.customer.platform": "Platform",
+                "entity.orderStatus": "Order Status",
+                "property.customerOrder.customer": "Customer",
+                "property.customer.name": "Name",
+                "property.orderItem.version": "Version",
+                "property.orderStatus.platform": "Platform",
+                "property.orderStatus.name": "Name",
+                "property.platform.version": "Version",
+                "property.customerOrder.status": "Status",
+                "property.orderItem.quantity": "Quantity"
+            },
+            "messages": {
+            }
+        },
+        "fr": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "zh-CN": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "es": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "ar": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "vi": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "th": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "uk": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "ja": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        },
+        "id": {
+            "vocabulary": {
+            },
+            "messages": {
+            }
+        }
+    }
+}

source/browser-sqlite/orders-lib/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true
+  },
+  "include": ["src/**/*", "*.d.ts"]
+}

source/browser-sqlite/package-lock.json

@@ -0,0 +1,1624 @@
+{
+  "name": "teaql-browser-sqlite-example",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "teaql-browser-sqlite-example",
+      "version": "1.0.0",
+      "dependencies": {
+        "@sqlite.org/sqlite-wasm": "3.53.0-build1",
+        "teaql-ts": "file:vendor/teaql-teaql-0.3.0.tgz"
+      },
+      "devDependencies": {
+        "puppeteer-core": "25.10.0",
+        "typescript": "5.9.2",
+        "vite": "^7.3.6"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz",
+      "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz",
+      "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz",
+      "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz",
+      "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz",
+      "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz",
+      "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz",
+      "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz",
+      "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz",
+      "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz",
+      "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz",
+      "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz",
+      "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz",
+      "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz",
+      "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz",
+      "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz",
+      "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz",
+      "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz",
+      "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz",
+      "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz",
+      "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz",
+      "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz",
+      "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz",
+      "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@napi-rs/lzma-linux-x64-gnu": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",
+      "integrity": "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^22.20 || ^24.12 || >=25"
+      }
+    },
+    "node_modules/@puppeteer/browsers": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-3.2.2.tgz",
+      "integrity": "sha512-q2BU4YfO9h/Wt7IcWPcggpOOqLk2Tbs1hDwolvKZrweRjy751OJBKMN9zO5bfD0pzU7X/tvKw/exQds4pM/LOg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "modern-tar": "^0.8.4",
+        "yargs": "^18.0.0"
+      },
+      "bin": {
+        "browsers": "lib/main-cli.js"
+      },
+      "engines": {
+        "node": ">=22.12.0"
+      },
+      "peerDependencies": {
+        "proxy-agent": ">=8.0.1",
+        "yauzl": "^2.10.0 || ^3.4.0"
+      },
+      "peerDependenciesMeta": {
+        "proxy-agent": {
+          "optional": true
+        },
+        "yauzl": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.1.tgz",
+      "integrity": "sha512-UZ8sUxPTiHWYX9QNdJedb1kDZSpS1t/VPWBWGSgqHNi9w3Cu6IXvu2mzbhiTiPvtrqgTQJ+zqiAq2iPIPilpaQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.63.1.tgz",
+      "integrity": "sha512-cQ4nFQABN5cDvDpbvJ7bMStCpnaVxynZrRMfUJYgxcIk9Sh54FIO1vtfkg0B69REjER77ioZ/ov+eAApx/KmLQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.63.1.tgz",
+      "integrity": "sha512-FQNqd1lRy/0QhDk3xeRIkSBiCpXCiDnZO3YLVdcDKN1UBiKToNftCzcXYNLshmPDUMlu2TdeS8tGcsU6f3YF1Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.63.1.tgz",
+      "integrity": "sha512-pvD16V939D3CloK0+qikpGaxiPrDUXTe7Y5cWOMkMSy7m1cawa8EGy/kXYi/G/cKAC4HDAbSnzCIk1WmsoOKXg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.63.1.tgz",
+      "integrity": "sha512-pcFGeL2345VwdTnJhA6zLbew+YgWB0qBG2+dMtXjCicf6+rm6kO6cOoh5VnTe0ZMrMRgRyuHmCJxZWrIdzYuOw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.63.1.tgz",
+      "integrity": "sha512-mRJlqSRulVzcKq/LKA6ICSIc3K/l4fzlVn/gePn2nXIHy8seRi5z/eeRE0d/XMBxcMldiXtQTSpRj0tkkC3g8Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.63.1.tgz",
+      "integrity": "sha512-YDUNvVM85TI3g/1OpnqKP1h4NeW/j64DfWMf+G3M809xNk1bJSnpFp4sh83NpmVE5DXnkh8ULor4LTVZKoYLHw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.63.1.tgz",
+      "integrity": "sha512-7Mcn71p9ZuQFAj+h+dhQXy/yeLePRS2yKRnmW1DijA9thKO5qap0GNOIQK4yQ6iP3SU0Mrb/yWo8h8vgRba8lw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.63.1.tgz",
+      "integrity": "sha512-4YiLQTX6U4CSl0L9cluep9A9W6UmTfqBDc2/CH6wlu54pl4E7Jn3cOD8oxzvBDEGk/JMKgJ47C8g+radF7mwvg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.63.1.tgz",
+      "integrity": "sha512-2ra8F7w8OquwZN9z2/fKFnli69wa8PLwaVzRMIPGb13ByMJwC28Fbp8YcVGoUhlYMTt7j5j9bNgpysrN2UM+vw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.63.1.tgz",
+      "integrity": "sha512-Sy20ncyhjmBP0Ml+UvQbimjlk6VFgjW5uNP+qqwHB00mTE8Bl2C1TuHTlRwK2YoXeZbee5lP2XevBWVkAQAtSQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.63.1.tgz",
+      "integrity": "sha512-noITLp8oNjYliPnGWmLyelIHwULGqbHloQHGw1rtxbWhTuWooRpnZarZQJ1y9EUC4szuCusCc+HEpUtxpIwYvA==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.63.1.tgz",
+      "integrity": "sha512-hlxxXd+F1mWiAcaFR7Sv9ZQT6m6UfI8+Vy/kFJzztq2pDMU/0wZ9sish0iszNZvsQDo8Gc0i5yuFEOz5dDf6fA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.63.1.tgz",
+      "integrity": "sha512-EF7OpqQTQ/BvGqLzUi4rEHuagCV9MugAUXSHemwPW5vxZ75RR+jxO/2j95Ph2dalMpFHSVECjRoioHZgA9zOYA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.63.1.tgz",
+      "integrity": "sha512-wQO3JesW9PRkwlabQ27y7sPfVOOTLRG73I4F2UYHG5PXun3J9U3y+b7ezVKSYbsvSKGQ1k1cq8Qlun4C9kLt3w==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.63.1.tgz",
+      "integrity": "sha512-ouAGwhO6wHRXdnOVCOsB0tRFkA7nhNB2Nwax6oECXN0YiN8EYUTBAOudADOB1PI+yDL61TeNx/u7MVCzksNbkQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.63.1.tgz",
+      "integrity": "sha512-q2R38Sn+1J8RxhfJ+T54wSWmyKXWec+9jgDfqO2AtArEqHO5R2aeayp5H5OYLr5UYDVGsVaZPEFUooMhYCdz5A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.63.1.tgz",
+      "integrity": "sha512-gfI5T24WLLuFfSKw7Go/zDXjAAV0fny0swTaDv+WjK7vqcw4cRhFfdsyKL1n+ukI+ooBxn3bVQnyrn06WpI50w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "glibc"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.63.1.tgz",
+      "integrity": "sha512-4h6XqthmB4Hspji84wvgk+ElodTsGj+dbZqHJHHtKxj4mYq0ANSEEPX9ys3moJueqsRjwpaJYH7874Itwnj2ow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "libc": [
+        "musl"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.63.1.tgz",
+      "integrity": "sha512-dlfCOa87o1VAYegLQ9EKilx2JCeRofiyPGhTCmqnuXZ6bMPiycO1rq1+sKoulAp7pGLIsTIw+1x5R+zgh5LhhA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.63.1.tgz",
+      "integrity": "sha512-cjkLbOlfcm3QGhMM1J5zaZjsw1GggbN6rw9UTSSRrPrR1KkcXnN7Uq9rPw34xImQ9VOY9GN+6u2Zj80B9ptkcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.63.1.tgz",
+      "integrity": "sha512-Li1KdUnWGE4N3e1F/B4RTB1ms+nG4WBgjByO46pkeBVX/2UBsY53xf5vK9WygVmnH3RwncIST7lkSdLSY6P9lg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.63.1.tgz",
+      "integrity": "sha512-t4ZYOSoLTgwhuFMrmTMLx/+i1DQVK7HYqMc6kY46EApwi8X0nIVphzdNoThU3xt6n+N5urG1/gxBdCaKDLavfg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.63.1.tgz",
+      "integrity": "sha512-RgroPfMmKlD1RzSDxvwgcPiy2HNQKoYV7OmwIXDsk73uKW5t6B/V8KIy27SMv/FNXFo/oSBtWc9J0X7t91ezZg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.63.1.tgz",
+      "integrity": "sha512-at8QVep6S3h5Y6gSbdGU06bRY5WJkf6WUduM9YtvYMbYhB1MOFfUgc6kehitQXzOtMSaT70q7f9ydPhpqu821w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@sqlite.org/sqlite-wasm": {
+      "version": "3.53.0-build1",
+      "resolved": "https://registry.npmjs.org/@sqlite.org/sqlite-wasm/-/sqlite-wasm-3.53.0-build1.tgz",
+      "integrity": "sha512-PfWPWN2n+/37doa8oh2/oUXk4OOsRYZsxc1W1sDXIGb/Pu5Yrb+f2eyYpgQMGITVX7HVgxhs9P18Rc6I97ym/g==",
+      "license": "Apache-2.0",
+      "workspaces": [
+        "demos/*"
+      ],
+      "engines": {
+        "node": ">=22"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/ansi-regex": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.3.0.tgz",
+      "integrity": "sha512-WpDfL7NO6j7tH88IDBNVdUJxDh9nmCteAVW9dsep846XdwF4naCBK+/tGLX3KJgcpgMRXCFlTM2hKGoK9FsdrQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+      "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/chromium-bidi": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-17.0.2.tgz",
+      "integrity": "sha512-5v9GQFhTktFvotn/OFNJBmKLKRAb6n9r0bVCwf7sHgWc3/JryK0bj1nn93L3pHFrfgcsu6Be6EWsDi+1XHTGDg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "mitt": "^3.0.1",
+        "zod": "^3.24.1"
+      },
+      "engines": {
+        "node": ">=20.19.0 <22.0.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "devtools-protocol": "*"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-9.0.1.tgz",
+      "integrity": "sha512-k7ndgKhwoQveBL+/1tqGJYNz097I7WOvwbmmU2AR5+magtbjPWQTS1C5vzGkBC8Ym8UWRzfKUzUUqFLypY4Q+w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^7.2.0",
+        "strip-ansi": "^7.1.0",
+        "wrap-ansi": "^9.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/cliui/node_modules/string-width": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
+      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^10.3.0",
+        "get-east-asian-width": "^1.0.0",
+        "strip-ansi": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/devtools-protocol": {
+      "version": "0.0.1666840",
+      "resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1666840.tgz",
+      "integrity": "sha512-gCcO42XCHKEs7Ag0S7aGYsnJ7hlgrO3qderYqeiY0Eqk+0GFfuvT13IA0hHreJTa2KCdDVyGMeOhdMNmrrTjVg==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/emoji-regex": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz",
+      "integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.28.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz",
+      "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.28.2",
+        "@esbuild/android-arm": "0.28.2",
+        "@esbuild/android-arm64": "0.28.2",
+        "@esbuild/android-x64": "0.28.2",
+        "@esbuild/darwin-arm64": "0.28.2",
+        "@esbuild/darwin-x64": "0.28.2",
+        "@esbuild/freebsd-arm64": "0.28.2",
+        "@esbuild/freebsd-x64": "0.28.2",
+        "@esbuild/linux-arm": "0.28.2",
+        "@esbuild/linux-arm64": "0.28.2",
+        "@esbuild/linux-ia32": "0.28.2",
+        "@esbuild/linux-loong64": "0.28.2",
+        "@esbuild/linux-mips64el": "0.28.2",
+        "@esbuild/linux-ppc64": "0.28.2",
+        "@esbuild/linux-riscv64": "0.28.2",
+        "@esbuild/linux-s390x": "0.28.2",
+        "@esbuild/linux-x64": "0.28.2",
+        "@esbuild/netbsd-arm64": "0.28.2",
+        "@esbuild/netbsd-x64": "0.28.2",
+        "@esbuild/openbsd-arm64": "0.28.2",
+        "@esbuild/openbsd-x64": "0.28.2",
+        "@esbuild/openharmony-arm64": "0.28.2",
+        "@esbuild/sunos-x64": "0.28.2",
+        "@esbuild/win32-arm64": "0.28.2",
+        "@esbuild/win32-ia32": "0.28.2",
+        "@esbuild/win32-x64": "0.28.2"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/get-east-asian-width": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.6.0.tgz",
+      "integrity": "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/mitt": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/modern-tar": {
+      "version": "0.8.4",
+      "resolved": "https://registry.npmjs.org/modern-tar/-/modern-tar-0.8.4.tgz",
+      "integrity": "sha512-gN54ddmyzEg10orwZ2u4OOv+bjpMWdIl5jIkodK97bMq8QBSL5c0D7YX0lT1Ooz+99S7+PvFbnxzdjgHo1r41g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.18",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.18.tgz",
+      "integrity": "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz",
+      "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.28",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.28.tgz",
+      "integrity": "sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.18",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/puppeteer-core": {
+      "version": "25.10.0",
+      "resolved": "https://registry.npmjs.org/puppeteer-core/-/puppeteer-core-25.10.0.tgz",
+      "integrity": "sha512-Hy5eMQshOEMil4JUUx03h5pw1HYkYCso1RG/gcpPlFSd4cYPOcopxcXEAxpLPOkOPJb9LIJtwxuj66bSdvknFg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@puppeteer/browsers": "3.2.2",
+        "chromium-bidi": "17.0.2",
+        "devtools-protocol": "0.0.1666840",
+        "typed-query-selector": "^2.12.2",
+        "webdriver-bidi-protocol": "0.4.3",
+        "ws": "^8.21.3"
+      },
+      "engines": {
+        "node": ">=22.12.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.63.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.63.1.tgz",
+      "integrity": "sha512-3Df9jsstwhccuEfmAMi9l8XUh/GOkVObmFTU7CCVBysEbcOZLl84jCtaAZMcPiMz2EGKsATzQcU+Xr3n/wU6cg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@napi-rs/lzma-linux-x64-gnu": "1.5.1",
+        "@rollup/rollup-android-arm-eabi": "4.63.1",
+        "@rollup/rollup-android-arm64": "4.63.1",
+        "@rollup/rollup-darwin-arm64": "4.63.1",
+        "@rollup/rollup-darwin-x64": "4.63.1",
+        "@rollup/rollup-freebsd-arm64": "4.63.1",
+        "@rollup/rollup-freebsd-x64": "4.63.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.63.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.63.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.63.1",
+        "@rollup/rollup-linux-arm64-musl": "4.63.1",
+        "@rollup/rollup-linux-loong64-gnu": "4.63.1",
+        "@rollup/rollup-linux-loong64-musl": "4.63.1",
+        "@rollup/rollup-linux-ppc64-gnu": "4.63.1",
+        "@rollup/rollup-linux-ppc64-musl": "4.63.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.63.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.63.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.63.1",
+        "@rollup/rollup-linux-x64-gnu": "4.63.1",
+        "@rollup/rollup-linux-x64-musl": "4.63.1",
+        "@rollup/rollup-openbsd-x64": "4.63.1",
+        "@rollup/rollup-openharmony-arm64": "4.63.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.63.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.63.1",
+        "@rollup/rollup-win32-x64-gnu": "4.63.1",
+        "@rollup/rollup-win32-x64-msvc": "4.63.1",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "8.2.2",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-8.2.2.tgz",
+      "integrity": "sha512-GaPUh5gfdrYzqeVNZvUfT23vYYxXzKYidUcnMtJg/3rxRV63EFZy3k6xfKlmfeJD0176lnUV/Usr3XcwSvFzpg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "get-east-asian-width": "^1.5.0",
+        "strip-ansi": "^7.1.2"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz",
+      "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.2.2"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/teaql-ts": {
+      "name": "@teaql/teaql",
+      "version": "0.3.0",
+      "resolved": "file:vendor/teaql-teaql-0.3.0.tgz",
+      "integrity": "sha512-au422aLCU34kwRxBu4rjqbiMCxpStQzTBek73/dUKw+SbJVMDNoo/VqkcgI8C4leKEF5p4ozH+QosGuSp+PIWw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "node-fetch": "^2.7.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.9.1",
+        "@opentelemetry/api-logs": "^0.221.0",
+        "@sqlite.org/sqlite-wasm": "3.53.0-build1",
+        "better-sqlite3": "^12.10.0",
+        "expo-sqlite": "*",
+        "mysql2": "^3.11.0",
+        "pg": "^8.12.0",
+        "pg-query-stream": "^4.7.0"
+      },
+      "peerDependenciesMeta": {
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@opentelemetry/api-logs": {
+          "optional": true
+        },
+        "@sqlite.org/sqlite-wasm": {
+          "optional": true
+        },
+        "better-sqlite3": {
+          "optional": true
+        },
+        "expo-sqlite": {
+          "optional": true
+        },
+        "mysql2": {
+          "optional": true
+        },
+        "pg": {
+          "optional": true
+        },
+        "pg-query-stream": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
+    "node_modules/typed-query-selector": {
+      "version": "2.12.2",
+      "resolved": "https://registry.npmjs.org/typed-query-selector/-/typed-query-selector-2.12.2.tgz",
+      "integrity": "sha512-EOPFbyIub4ngnEdqi2yOcNeDLaX/0jcE1JoAXQDDMIthap7FoN795lc/SHfIq2d416VufXpM8z/lD+WRm2gfOQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/typescript": {
+      "version": "5.9.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz",
+      "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/vite": {
+      "version": "7.3.6",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.6.tgz",
+      "integrity": "sha512-4XP60spRGjSZFf1qYH+dJIkK2znL3zQfl9KkOV9MkkRR/3Dls0dxaBsQPTloEc5BLXWPL9vsOxopxyKoMmDueg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.27.0 || ^0.28.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/webdriver-bidi-protocol": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/webdriver-bidi-protocol/-/webdriver-bidi-protocol-0.4.3.tgz",
+      "integrity": "sha512-uuN0goWfxP22B7J/uAgBpOYNPttC+XVseYE+rSY5+rQ+YBeVz/VORw8WbmLVcqW78zNg5A4qnjNXYUWR3il2ig==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz",
+      "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.2.1",
+        "string-width": "^7.0.0",
+        "strip-ansi": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/string-width": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
+      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^10.3.0",
+        "get-east-asian-width": "^1.0.0",
+        "strip-ansi": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.21.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.3.tgz",
+      "integrity": "sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "18.1.0",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-18.1.0.tgz",
+      "integrity": "sha512-2rAgRKu54VsHkqI0/tYkmluGXHD4KW7yZoycuqDQ15QOTnc2VVfy0nN/1eMhnQLO00A+dwtK20xuCnc1YGeUyg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^9.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "string-width": "^8.2.1",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^22.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=23"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "22.0.0",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-22.0.0.tgz",
+      "integrity": "sha512-rwu/ClNdSMpkSrUb+d6BRsSkLUq1fmfsY6TOpYzTwvwkg1/NRG85KBy3kq++A8LKQwX6lsu+aWad+2khvuXrqw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=23"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

source/browser-sqlite/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "teaql-browser-sqlite-example",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit && vite build",
+    "smoke": "node scripts/smoke.mjs"
+  },
+  "dependencies": {
+    "@sqlite.org/sqlite-wasm": "3.53.0-build1",
+    "teaql-ts": "file:vendor/teaql-teaql-0.3.0.tgz"
+  },
+  "devDependencies": {
+    "puppeteer-core": "25.10.0",
+    "typescript": "5.9.2",
+    "vite": "^7.3.6"
+  }
+}

source/browser-sqlite/scripts/smoke.mjs

@@ -0,0 +1,130 @@
+import {spawn} from 'node:child_process';
+import {readFileSync, writeFileSync} from 'node:fs';
+import {createHash} from 'node:crypto';
+import {join} from 'node:path';
+import assert from 'node:assert/strict';
+import puppeteer from 'puppeteer-core';
+
+const generated = JSON.parse(readFileSync('generated-order-hashes.json', 'utf8'));
+function checkLibrary() {
+  for (const [file, expected] of Object.entries(generated))
+    assert.equal(createHash('sha256').update(readFileSync(join('orders-lib', file))).digest('hex'), expected, `generated file changed: ${file}`);
+}
+checkLibrary();
+const server = spawn(process.execPath, ['node_modules/vite/bin/vite.js', 'preview', '--host', '127.0.0.1', '--port', '4175', '--strictPort'],
+  {stdio: ['ignore', 'pipe', 'pipe']});
+let serverOutput = '';
+server.stdout.on('data', value => { serverOutput += value; }); server.stderr.on('data', value => { serverOutput += value; });
+let browser;
+const receipts = [];
+try {
+  let ready = false;
+  for (let attempt = 0; attempt < 100; attempt++) {
+    try { ready = (await fetch('http://127.0.0.1:4175/')).ok; } catch { /* starting */ }
+    if (ready) break;
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  assert.ok(ready, serverOutput);
+  browser = await puppeteer.launch({executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome',
+    args: ['--no-sandbox', '--disable-dev-shm-usage'], headless: true});
+  const page = await browser.newPage(), errors = [];
+  page.on('pageerror', error => errors.push(error.message));
+  page.on('console', event => { if (event.type() === 'error') errors.push(event.text()); });
+  page.on('response', response => { if (response.status() >= 400) errors.push(`${response.status()} ${response.url()}`); });
+  page.on('requestfailed', request => errors.push(`${request.failure()?.errorText} ${request.url()}`));
+  async function waitReady(storage) {
+    try {
+      await page.waitForFunction(value => {
+        const text = document.querySelector('#status')?.textContent || '';
+        return text.startsWith(value) && text.includes('ready');
+      }, {timeout: 20_000}, storage);
+    } catch (error) {
+      throw new Error(`${error.message}; status=${await page.$eval('#status', element => element.textContent)}; browserErrors=${errors.join('\n')}`);
+    }
+  }
+  async function inspect(label, diagnostics) {
+    const response = JSON.parse(await page.$eval('#result', element => element.textContent));
+    assert.equal(response.metadata.totalCount, 3); assert.equal(response.metadata.aggregations.totalOrders, 3);
+    assert.equal(response.metadata.pageOffset, 1); assert.equal(response.metadata.pageSize, 1);
+    assert.equal(response.resultCode, 0); assert.equal(response.status, 'YES');
+    assert.equal(response.version, '1.001'); assert.equal(response.recordCount, 3);
+    assert.deepEqual(response.metadata.searchWarnings, []);
+    assert.equal(response.data.length, 1); const order = response.data[0];
+    assert.equal(order.orderNumber, 'KEEP-002'); assert.equal(order.orderDate.slice(0, 10), '2026-10-02');
+    assert.equal(order.version, 1); assert.equal(order.status.name, 'Paid'); assert.equal(order.status.color, '#22C55E');
+    assert.deepEqual(order.items.map(item => [item.productName, item.quantity]), [['Box 1', 1], ['Box 2', 2], ['Box 3', 3]]);
+    assert.equal(order.itemCount, 5);
+    assert.deepEqual(response.facets.statusCounts.map(row => [String(row.id), row.orderCount, row.orderTotalAmount]),
+      [['1001', 1, 100], ['1002', 2, 500], ['1003', 0, null]]);
+    const evidence = JSON.parse(await page.$eval('#sql', element => element.textContent));
+    assert.equal(evidence.length, 8);
+    const comments = evidence.map(entry => entry.traceChain.filter(node => node.kind === 'comment').map(node => node.detail));
+    const expected = [
+      ['load order list', "countAs('totalOrders')"], ['load order list'],
+      ['load order list', 'selectStatusWith(...)', 'load status'],
+      ['load order list', 'selectOrderItemListWith(...)', 'load item previews'],
+      ['load order list', "countOrderItemsAs('itemCount')"],
+      ['load order list', "facetByStatusAs('statusCounts')", 'aggregate status'],
+      ['load order list', "facetByStatusAs('statusCounts')", 'load status facets'],
+      ['load order list', "facetByStatusAs('statusCounts')", 'aggregate status'],
+    ];
+    assert.deepEqual(comments.map(JSON.stringify).sort(), expected.map(JSON.stringify).sort());
+    for (const entry of evidence) {
+      assert.equal(entry.purpose, 'render order list page');
+      assert.ok(entry.tracePath.some(node => node.kind === 'provider'));
+      assert.equal(entry.traceChain.filter(node => node.kind === 'purpose').length, 1);
+    }
+    const text = await page.$eval('#status', element => element.textContent);
+    assert.ok(text.includes(`${diagnostics} diagnostics`), text);
+    assert.equal(await page.$eval('#trace', element => element.textContent), evidence.map(entry => `${entry.purpose}: ${entry.traceChain
+      .filter(node => node.kind === 'comment').map(node => node.detail).join(' → ')}`).join('\n'));
+    assert.deepEqual(await page.$$eval('.evidence-table th', cells => cells.map(cell => cell.textContent)),
+      ['Time', 'Identity', 'Trace chain', 'SQL']);
+    const renderedEvidence = await page.$$eval('#evidence-rows tr', rows => rows.map(row =>
+      [...row.querySelectorAll('td')].map(cell => cell.textContent)));
+    assert.deepEqual(renderedEvidence, evidence.map(entry => [
+      `${entry.elapsedMicros} µs`, entry.tracePath.find(node => node.kind === 'request')?.name ?? '—',
+      `${entry.traceChain.find(node => node.kind === 'purpose').detail}: ${entry.traceChain
+        .filter(node => node.kind === 'comment').map(node => node.detail).join(' → ')}`, entry.debugSQL,
+    ]));
+    receipts.push({label, response, evidence, diagnostics, renderedEvidence});
+    return response;
+  }
+  await page.goto('http://127.0.0.1:4175/', {waitUntil: 'networkidle0'});
+  await waitReady('MEMORY'); const baseline = await inspect('memory-first', 8);
+  await page.select('#example', 'all');
+  await page.waitForFunction(() => {
+    const text = document.querySelector('#result')?.textContent;
+    return text && JSON.parse(text).metadata.totalCount === 4;
+  });
+  const all = JSON.parse(await page.$eval('#result', element => element.textContent));
+  assert.equal(all.data[0].orderNumber, 'KEEP-003');
+  assert.deepEqual(all.facets.statusCounts.map(row => [row.orderCount, row.orderTotalAmount]), [[1, 100], [3, 1400], [0, null]]);
+  await page.$eval('#search', element => { element.value = 'Q.constructor("return globalThis")'; });
+  await page.click('#query');
+  await page.waitForFunction(() => document.querySelector('#status')?.textContent?.includes('not allowed'));
+  assert.equal(await page.$$eval('#evidence-rows tr', rows => rows.length), 0);
+  assert.equal(await page.$eval('#sql', element => element.textContent), '[]');
+  await page.click('#preset'); await waitReady('MEMORY');
+  assert.deepEqual(await inspect('restored-preset', 8), baseline);
+  await page.reload({waitUntil: 'networkidle0'}); await waitReady('MEMORY');
+  assert.deepEqual(await inspect('memory-refresh', 8), baseline);
+  await page.click('#logging');
+  await page.waitForFunction(() => document.querySelector('#status')?.textContent?.includes('0 diagnostics'));
+  assert.deepEqual(await inspect('memory-logging-off', 0), baseline);
+  await page.click('#reset');
+  await page.waitForFunction(() => !document.querySelector('#reset')?.hasAttribute('disabled'));
+  assert.deepEqual(await inspect('memory-reset', 0), baseline);
+  await page.click('#persist'); await waitReady('OPFS');
+  assert.deepEqual(await inspect('opfs-first', 0), baseline);
+  await page.reload({waitUntil: 'networkidle0'}); await waitReady('OPFS');
+  assert.deepEqual(await inspect('opfs-refresh', 8), baseline);
+  await page.click('#reset');
+  await page.waitForFunction(() => !document.querySelector('#reset')?.hasAttribute('disabled'));
+  assert.deepEqual(await inspect('opfs-reset', 8), baseline);
+  assert.deepEqual(errors, []); checkLibrary();
+  if (process.env.TEAQL_BROWSER_ORDER_EVIDENCE) writeFileSync(process.env.TEAQL_BROWSER_ORDER_EVIDENCE,
+    JSON.stringify({receipts, queryPresetSwitch: true, forbiddenConstructorRejected: true,
+      generatedLibraryUnchanged: true, browserErrors: errors}, null, 2) + '\n', {flag: 'wx'});
+  console.log('PASS browser generated order TraceChain: memory/OPFS, refresh/reset, logging on/off, exact facets/counts/previews, actual SQL=8, unchanged generated library');
+} finally { await browser?.close(); server.kill('SIGTERM'); }

source/browser-sqlite/src/main.ts

@@ -0,0 +1,185 @@
+import { BrowserSQLiteTeaQLClient, type BrowserSQLiteStorage } from 'teaql-ts/sql/browser-sqlite';
+import { DelegatingMutationPolicyApprovalProvider, DelegatingMutationPolicyRegistry, QueryParser, UserContext } from 'teaql-ts';
+import type { TeaQLPage } from 'teaql-ts';
+import { SQLExecutionEvidenceStore, type SQLExecutionMetadata } from 'teaql-ts/sql/core';
+import { Q } from '../orders-lib/src/generated/Q';
+import { E } from '../orders-lib/src/generated/E';
+import { OrderStatus } from '../orders-lib/src/generated/models/OrderStatus';
+import { GENERATED_RUNTIME_MODULE } from '../orders-lib/src/runtime-module';
+import { ENTITY_SCHEMAS } from '../orders-lib/src/teaql-schemas';
+import { webResponse } from './web-response';
+import './style.css';
+
+const status = document.querySelector<HTMLParagraphElement>('#status')!;
+const output = document.querySelector<HTMLPreElement>('#result')!;
+const trace = document.querySelector<HTMLPreElement>('#trace')!;
+const sql = document.querySelector<HTMLPreElement>('#sql')!;
+const evidenceRows = document.querySelector<HTMLTableSectionElement>('#evidence-rows')!;
+const persist = document.querySelector<HTMLInputElement>('#persist')!;
+const logging = document.querySelector<HTMLInputElement>('#logging')!;
+const reset = document.querySelector<HTMLButtonElement>('#reset')!;
+const run = document.querySelector<HTMLButtonElement>('#query')!;
+const search = document.querySelector<HTMLTextAreaElement>('#search')!;
+const example = document.querySelector<HTMLSelectElement>('#example')!;
+const filteredSearch = JSON.stringify(JSON.stringify({filter: {orderNumber: {$contains: 'KEEP'}}}));
+const preset = `Q.customerOrdersWithMinimalFields()
+  .filterByJson(${filteredSearch})
+  .countAs("totalOrders")
+  .facetByStatusAs("statusCounts", Q.orderStatusesWithMinimalFields()
+    .selectName().selectColor().countAs("orderCount")
+    .sumTotalAmountOfCustomerOrdersAs("orderTotalAmount", Q.customerOrdersWithMinimalFields())
+    .orderByDisplayOrderAscending().comment("load status facets"))
+  .selectOrderNumber().selectOrderDate()
+  .selectStatusWith(Q.orderStatusesWithMinimalFields()
+    .selectName().selectColor().comment("load status"))
+  .selectOrderItemListWith(Q.orderItemsWithMinimalFields()
+    .selectProductName().selectQuantity().orderByIdAscending().limit(3).comment("load item previews"))
+  .countOrderItemsAs("itemCount")
+  .orderByOrderDateDescending().orderByIdDescending()
+  .comment("load order list").purpose("render order list page")`;
+search.value = preset;
+type Runtime = {client: BrowserSQLiteTeaQLClient; context: UserContext; evidence: SQLExecutionEvidenceStore; diagnostics: SQLExecutionMetadata[]};
+let active: Runtime | undefined;
+const opfsAvailable = globalThis.crossOriginIsolated && typeof navigator.storage?.getDirectory === 'function';
+persist.checked = opfsAvailable && localStorage.getItem('teaql-browser-order-storage') === 'opfs';
+persist.disabled = !opfsAvailable;
+if (!opfsAvailable) document.querySelector('#opfs-note')!.textContent = '(not available on this host; memory remains fully browser-local)';
+
+async function open(storage: BrowserSQLiteStorage): Promise<Runtime> {
+  const worker = new Worker(new URL('./sqlite.worker.ts', import.meta.url), {type: 'module'});
+  const client = await BrowserSQLiteTeaQLClient.open(worker, {...ENTITY_SCHEMAS}, {
+    storage, databaseName: 'teaql-browser-orders.sqlite3',
+  });
+  client.install(GENERATED_RUNTIME_MODULE);
+  client.setDiagnosticSQLLogSink(undefined).setMutationLoggingEnabled(false);
+  const identity = Object.freeze({policyId: 'browser-order-seed', version: '1', fingerprint: 'sha256:browser-order-seed-v1'});
+  const context = new UserContext().insertResource('dataService', client)
+    .withMutationPolicyRegistry(new DelegatingMutationPolicyRegistry(() => ({identity,
+      review: (_context, plan) => plan.operations.length > 0 ? {verdict: 'allow'}
+        : {verdict: 'deny', code: 'EMPTY_GRAPH', message: 'empty mutation graph'},
+    })))
+    .withMutationPolicyApprovalProvider(new DelegatingMutationPolicyApprovalProvider(
+      policy => ({policy, approvedBy: 'browser-demo-owner', approvedAt: new Date()}),
+    ));
+  client.setUserContext(context);
+  await context.ensureSchema();
+  await context.ensureSchema();
+  return {client, context, evidence: new SQLExecutionEvidenceStore(), diagnostics: []};
+}
+
+async function seed({context}: Runtime): Promise<void> {
+  const existing = await Q.customerOrdersWithMinimalFields().limit(1)
+    .comment('detect existing order demo').purpose('keep mutation seeding idempotent').executeForList(context);
+  if (existing.length) return;
+  const platform = (await Q.platforms().limit(2).comment('load bootstrap platform').purpose('prepare order demo').executeForList(context))[0];
+  const customer = Q.customers().comment('initialize demo customer').purpose('prepare order demo').newEntity(context);
+  customer.updateName('North Star Retail').updatePlatform(platform.id);
+  await customer.auditAs('seed browser order customer').save(context);
+  for (let index = 1; index <= 4; index++) {
+    const order = Q.customerOrders().comment('initialize demo order').purpose('prepare order demo').newEntity(context);
+    order.updateCustomer(customer.id).updateOrderNumber(index < 4 ? `KEEP-00${index}` : 'DROP-004')
+      .updateOrderDate(`2026-10-0${index}`).updateTotalAmount(index < 4 ? index * 100 : 900);
+    if (index === 1) order.updateStatusToNew(); else order.updateStatusToPaid();
+    await order.auditAs('seed browser order').save(context);
+    for (let item = 1; item <= 5; item++) {
+      const line = Q.orderItems().comment('initialize demo item').purpose('prepare item previews').newEntity(context);
+      line.updateCustomerOrder(order.id).updateProductName(`Box ${item}`).updateQuantity(item).updateUnitPrice(20);
+      await line.auditAs('seed browser order item').save(context);
+    }
+  }
+}
+
+async function show(runtime: Runtime): Promise<void> {
+  output.textContent = '';
+  trace.textContent = '';
+  sql.textContent = '[]';
+  evidenceRows.replaceChildren();
+  runtime.evidence.enableAll(); runtime.diagnostics.length = 0;
+  type Order = NonNullable<Parameters<typeof E.customerOrder>[0]>;
+  type Executable = {executeForPage(context: UserContext, offset: number, size: number): Promise<TeaQLPage<Order>>};
+  const request = QueryParser.parse(search.value, Q) as Executable & {dynamicSearchWarnings?: readonly unknown[]};
+  if (typeof request?.executeForPage !== 'function') throw new Error('The query must contain a generated executable Q request');
+  runtime.client.setRuntimeTelemetrySink(runtime.evidence).setQueryLoggingEnabled(logging.checked)
+    .setDiagnosticSQLLogSink({write: entry => runtime.diagnostics.push(entry)});
+  const page = await request.executeForPage(runtime.context, 1, 1);
+  const responseBase = webResponse(page.data);
+  const response = {
+    resultCode: responseBase.resultCode, status: responseBase.status, version: responseBase.version,
+    recordCount: page.totalCount,
+    data: page.data.map(row => {
+      const expression = E.customerOrder(row);
+      const previewSize = expression.orderItemList().size().eval();
+      if (previewSize == null) throw new Error('Selected item list unexpectedly has a null size');
+      return {id: row.id, version: row.version, orderNumber: expression.orderNumber().eval(), orderDate: expression.orderDate().eval(),
+        status: {name: expression.status().name().eval(), color: expression.status().color().eval()},
+        items: Array.from({length: previewSize}, (_, index) => ({
+          productName: expression.orderItemList().get(index).productName().eval(), quantity: expression.orderItemList().get(index).quantity().eval(),
+        })), itemCount: (row as unknown as Record<string, unknown>).itemCount};
+    }),
+    metadata: {totalCount: page.totalCount, pageOffset: 1, pageSize: 1, aggregations: page.data.aggregations, searchWarnings: request.dynamicSearchWarnings ?? []},
+    facets: {statusCounts: page.data.facets.statusCounts.map(value => ({
+      id: value.id, name: E.orderStatus(OrderStatus.fromRecord(value)).name().eval(),
+      color: E.orderStatus(OrderStatus.fromRecord(value)).color().eval(), orderCount: value.orderCount, orderTotalAmount: value.orderTotalAmount,
+    }))},
+  };
+  output.textContent = JSON.stringify(response, null, 2);
+  const statements = runtime.evidence.snapshot();
+  // Rendering only: ownership and comments come from the actual runtime metadata.
+  const rows = statements.map(entry => {
+    const chain = entry.traceChain ?? [];
+    const purposes = chain.filter(node => node.kind === 'purpose');
+    const businessTrace = purposes.length === 1
+      ? `${purposes[0].detail}: ${chain.filter(node => node.kind === 'comment').map(node => node.detail).join(' → ')}`
+      : 'TraceChain unavailable';
+    const row = document.createElement('tr');
+    for (const value of [`${entry.elapsedMicros} µs`,
+      entry.tracePath.find(node => node.kind === 'request')?.name ?? '—', businessTrace, entry.debugSQL]) {
+      const cell = document.createElement('td');
+      cell.textContent = value;
+      row.append(cell);
+    }
+    return {row, businessTrace};
+  });
+  evidenceRows.replaceChildren(...rows.map(value => value.row));
+  trace.textContent = rows.map(value => value.businessTrace).join('\n');
+  sql.textContent = JSON.stringify(statements, null, 2);
+  status.textContent = `${runtime.client.storage!.toUpperCase()} · ${page.totalCount} matches · ${statements.length} SQL statements · ${runtime.diagnostics.length} diagnostics · policy installed · ready`;
+}
+
+async function replace(storage: BrowserSQLiteStorage): Promise<void> {
+  status.textContent = `Opening ${storage.toUpperCase()} SQLite/WASM…`;
+  const previous = active; active = undefined;
+  await previous?.client.close();
+  const next = await open(storage); active = next;
+  await seed(next); await show(next);
+}
+function fail(value: unknown): void {
+  status.textContent = value instanceof Error ? `${value.name}: ${value.message}` : String(value);
+}
+run.addEventListener('click', async () => {
+  if (!active) return;
+  run.disabled = true;
+  try { await show(active); } catch (error) { fail(error); } finally { run.disabled = false; }
+});
+document.querySelector('#preset')!.addEventListener('click', () => {
+  search.value = preset; example.value = 'filtered'; run.click();
+});
+example.addEventListener('change', () => {
+  search.value = example.value === 'all' ? preset.replace(filteredSearch, JSON.stringify('{}')) : preset;
+  run.click();
+});
+search.addEventListener('keydown', event => {
+  if ((event.ctrlKey || event.metaKey) && event.key === 'Enter') run.click();
+});
+logging.addEventListener('change', () => { if (active) show(active).catch(fail); });
+persist.addEventListener('change', () => {
+  const storage = persist.checked ? 'opfs' : 'memory';
+  localStorage.setItem('teaql-browser-order-storage', storage); replace(storage).catch(fail);
+});
+reset.addEventListener('click', async () => {
+  if (!active) return;
+  reset.disabled = true;
+  try { await active.client.reset(active.context); await seed(active); await show(active); }
+  catch (error) { fail(error); } finally { reset.disabled = false; }
+});
+replace(persist.checked ? 'opfs' : 'memory').catch(fail);

source/browser-sqlite/src/sqlite.worker.ts

@@ -0,0 +1,4 @@
+import { startBrowserSQLiteWorker } from 'teaql-ts/sql/browser-sqlite-worker';
+import sqliteWasmUrl from '@sqlite.org/sqlite-wasm/sqlite3.wasm?url';
+
+startBrowserSQLiteWorker({ wasmUrl: sqliteWasmUrl });

source/browser-sqlite/src/style.css

@@ -0,0 +1,14 @@
+:root { font: 16px/1.5 Inter, system-ui, sans-serif; color: #e8edf5; background: #090b10; }
+body { margin: 0; }
+main { width: min(760px, calc(100% - 40px)); margin: 10vh auto; }
+.eyebrow { color: #d9ff52; font-size: 12px; font-weight: 800; letter-spacing: .16em; }
+h1 { margin: 8px 0; font-size: clamp(36px, 7vw, 68px); letter-spacing: -.05em; }
+.controls { display: flex; gap: 18px; align-items: center; margin: 32px 0; }
+button { border: 0; border-radius: 5px; padding: 10px 14px; background: #d9ff52; font-weight: 800; }
+#status { color: #aab4c4; }
+pre { min-height: 260px; padding: 22px; overflow: auto; border: 1px solid #2b323e; border-radius: 8px; background: #11151c; color: #c6d1df; }
+.evidence-scroll { overflow-x: auto; margin: 24px 0; }
+.evidence-table { border-collapse: collapse; width: 100%; text-align: left; }
+.evidence-table th, .evidence-table td { padding: 12px; border: 1px solid #2b323e; vertical-align: top; }
+.evidence-table td { white-space: pre-wrap; overflow-wrap: anywhere; min-width: 110px; }
+.evidence-table td:last-child { min-width: 320px; font-family: monospace; }

source/browser-sqlite/src/web-response.ts

@@ -0,0 +1,16 @@
+import type { SmartList } from 'teaql-ts';
+
+/** Application response projection; querying and facet computation stay in the runtime. */
+export function webResponse<T>(rows: SmartList<T>) {
+  const facets = Object.fromEntries(Object.entries(rows.facets)
+    .map(([name, values]) => [name, Array.from(values)]));
+  return {
+    data: Array.from(rows),
+    resultCode: 0,
+    status: 'YES' as const,
+    recordCount: rows.totalCountOrLength(),
+    version: '1.001',
+    ...(Object.keys(facets).length ? {facets} : {}),
+    ...(Object.keys(rows.aggregations).length ? {aggregations: rows.aggregations} : {}),
+  };
+}

source/browser-sqlite/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["vite/client"],
+    "lib": ["ES2022", "DOM", "WebWorker"]
+  },
+  "include": ["src"]
+}

source/browser-sqlite/vendor/teaql-teaql-0.3.0.tgz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d4e5cbaecc4fcc06fe3b357a4575d6e5ca4a92673b625ef2c7d5ec7d02b287d
+size 349294