@jarenjs/db 0.84.3 → 0.85.0

package/ARCHITECTURE.md

@@ -1167,8 +1167,10 @@ calls with different bound values.
 `physical.js` compiles column codecs and verifies declarations against that
 inventory. The existing entity core, tracker and graph row merger execute both
 hybrid and column layouts; there is no separate relational store. The query
-planner reports decoded evaluation for physical codecs, and refuses physical
-keyset continuation until its identity semantics are qualified.
+planner preserves codec semantics through qualified native plans and explicit
+residuals, and refuses physical keyset continuation until its identity semantics
+are qualified. Present-null scalar predicates and safe fluent projection
+flattening join this native subset; strict binding failures stop before a scan.
 
 `sql.js` binds trusted statements to `store.js` transaction views. It reuses the
 read classifier's tokenizer and the driver's scope owner. Writes invalidate all
@@ -1176,6 +1178,21 @@ clean tracked entities; pending edits and incomplete capture populations refuse.
 `invariants.js` uses the shared Query compiler for store rules; the dialect lowers
 a bounded database subset into ordered trigger bodies. `migrate.js` reuses its
 existing rebuild/receipt transaction and verifies preservation before publication.
-The backup publisher remains shared by Node online and Bun serialized snapshots.
+The backup publisher uses Node online backup and Bun disk-backed VACUUM INTO.
+The standalone snapshot helper shares destination reservation and cleanup across
+both hosts, including transaction failures.
 
 `src/search.js` composes core lexical mechanics and the JSON predicate compiler over complete bounded entity snapshots. Committed capture and data-version checks invalidate derived state; SHA-256 source content validates persisted caches across reopen. Snapshot storage uses existing collection transactions. See [search execution](docs/SEARCH.md); native full-text dialects remain unqualified.
+
+`dialects/sqlite-relational.js` owns the explicit SQLite expression and statement
+compiler; `dialects/sqlite-schema.js` reuses it for ordered tables, indexes and
+triggers. `table-migration.js` owns reviewed source/target guards, native copying
+and preservation checks, with catalog/pragma spellings in the SQLite dialect.
+The supplied driver owns transactions and cursors. These programs are explicitly
+SQLite-semantic and never enter the JSON residual evaluator. See
+[the native SQLite contract](docs/SQLITE-RELATIONAL.md).
+
+`engine-metadata.js` holds inert version/table constants so schema inspection
+does not import runtime owners. `/query`, `/model` and `/entity` expose those
+mechanisms without the root store import. `compileEntityModel` performs one model
+normalization for both entities and mapping; openStore reuses that result.

package/README.md

@@ -1379,6 +1379,10 @@ Every subpath a consumer can import, derived from the manifest by
 | `@jarenjs/db/package.json` | metadata | — |
 | `@jarenjs/db/node-worker` | JavaScript | declared |
 | `@jarenjs/db/node-pool` | JavaScript | declared |
+| `@jarenjs/db/relational` | JavaScript | declared |
+| `@jarenjs/db/query` | JavaScript | declared |
+| `@jarenjs/db/model` | JavaScript | declared |
+| `@jarenjs/db/entity` | JavaScript | declared |
 <!--/fact-->
 
 
@@ -1431,3 +1435,10 @@ SQLite constraint/audit triggers for installation through that migration boundar
 Native column reads and bounded mutation documents are specified in [NATIVE-PLANS](docs/NATIVE-PLANS.md), including SQL census coverage, resource accounting and refusals.
 
 `@jarenjs/db/search` composes the resident ranker with bounded authoritative entity reads and optional atomic snapshot storage. See [persisted search](docs/SEARCH.md).
+
+Column-first table definitions, guarded same-connection rebuilds, exact matched writes,
+partial conflicts, raw-text JSON queries and byte-valued operations use
+[`@jarenjs/db/relational`](docs/SQLITE-RELATIONAL.md). Both host entries export
+`snapshotDatabase(connection, newPath)` for a disk-backed committed-WAL copy.
+Existing-connection consumers can import `/query`, `/model` and `/entity`;
+`compileEntityModel` shares one normalization between queries and mapping.

package/docs/MODEL-FORMAT.md

@@ -2352,7 +2352,9 @@ relation navigation across physical layouts is not qualified.
 | `decimal` | exact decimal string, including trailing zeros | TEXT |
 | `blob-hex` | lowercase hexadecimal string | BLOB |
 
-Unsafe narrowing refuses `JD2003`. A byte handle never enters the public entity.
+Unsafe narrowing refuses `JD2003`. A byte handle never enters the JSON-facing entity;
+[the native SQLite channel](SQLITE-RELATIONAL.md#exact-writes-and-bytes) preserves
+Uint8Array/Buffer values on the same synchronous connection.
 `null: "null"` maps SQL NULL to present JSON null; `"absent"` omits the property;
 `"reject"` refuses it. With the JSON codec, JSON null is stored as the text `null`,
 so SQL NULL can independently mean absence. `default: "database"` omits an absent
@@ -2361,9 +2363,10 @@ writes to the database. A generated integer identity uses the existing
 `x-entity.default: "auto"` declaration. Direct updates with identical values and
 identical tracked saves produce no effective writes.
 
-Mapped query documents execute through the existing decoded-row evaluator;
-explanations report this residual and strict pushdown refuses it. Scalar graph
-loads use mapped names; complex codec predicates require query documents.
+Mapped query documents use the qualified native subset in [NATIVE-PLANS](NATIVE-PLANS.md).
+Present-null scalar equality/ranges preserve Jaren semantics. Unsupported codecs
+and shapes retain explicit residuals; strict mode also rejects unsupported bound
+externals before fetching rows. Scalar graph loads use mapped names.
 Physical `page` and `after` continuation refuse until codec-aware keysets are
 qualified; an explicit `take`/`skip` load remains available.
 Capture/live/replication for adopted application triggers is not qualified and
@@ -2414,3 +2417,10 @@ must stay in the safe-number range.
 ## Native column mutation documents
 
 Asynchronous entity sets expose `mutate(document)` for conditional updates, conflict-aware upserts and bounded same-entity insert-select. The closed grammar, no-op/revision behavior, output bounds and transactional qualifications are specified in [NATIVE-PLANS](NATIVE-PLANS.md).
+
+Explicit physical DDL metadata and live-schema migration planning are specified
+in [SQLITE-RELATIONAL](SQLITE-RELATIONAL.md#physical-schema-ownership). Opening a
+physical entity retains adoption-only behavior. Public plans create complete
+ordered declarations; an incomplete generated/default definition or view remains
+adoption metadata. SQLite expressions preserve a separate, explicit semantic
+contract for raw text, bytes, nulls, collations and floating totals.

package/docs/NATIVE-PLANS.md

@@ -49,6 +49,13 @@ Floating sums/averages and date/datetime grouping remain residual. Physical text
 comparisons explicitly use codepoint collation, independent of a column's declared
 collation; an incompatible index may therefore stop helping that query.
 
+Safe identity/object projection chains, including a projected join followed by
+filtering and ordering, flatten without crossing windows, grouping or inner
+ordering. Standalone min/max over supported scalar columns and sum/avg over safe
+integer columns now lower natively, preserving empty-sequence and present-null
+errors. Missing or unbindable external values refuse strict execution and both
+cursor APIs before any decoded fetch; a nullable slot accepts explicit null.
+
 `explain` reports the emitted SQL, scan narrative, profile bounds and last
 execution's admitted statement/returned-row/serialized-wire-byte counts. These
 are application admission costs. SQLite does not expose visited-row counts or
@@ -73,12 +80,13 @@ const result = await store.entity('Inventory').mutate({
 });
 ```
 
-The three operations are:
+The operations are:
 
 | Operation | Required document members | Meaning |
 |---|---|---|
-| `update` | `key`, `set`; `expectedRevision` for a versioned entity | Complete primary key and revision predicate; writes only changed columns and increments the revision once. Missing/stale/identical rows yield zero affected rows. |
-| `upsert` | `values`, `conflict`, `update` | Insert or update the named supplied members only if their stored values differ. `conflict` is the complete ordered primary key. |
+| `update` | `key` and/or `where`, `set` and/or `expressions`; `expectedRevision` for a versioned entity | Exact assignments with an atomic predicate. Default changed reporting suppresses identical writes; `reporting: 'matched'` executes them. A declared version increments once on a write. |
+| `upsert` | `values`, `conflict`; `update` or `onConflict: 'nothing'` | Ordered logical conflict columns may name a non-primary UNIQUE identity; `conflictWhere` matches a partial index. Default changed reporting suppresses identical updates. |
+| `delete` | `key` and/or `where`; `expectedRevision` for a versioned entity | One conditional or bulk delete, with the same transactional output bounds. |
 | `insert-select` | `source`, `where`, `select`, `conflict`, `onConflict: 'nothing'` | Same-entity scalar/literal projection, bounded source rows, conflict-ignore insertion. Source and target path codecs and NULL policies must match. |
 
 `returning` is a nonempty list of logical stored members (default: all). `maxRows`
@@ -92,14 +100,23 @@ before insertion, even if all rows would conflict. Output bounds and codec/schem
 validation run inside the transaction; failure rolls back rows and trigger effects.
 The byte bound checks decoded output, not a database allocation interrupt.
 The statement's `RETURNING` view follows SQLite timing; later AFTER-trigger
-modifications are not an extra readback. Same-input replay yields no effective
-write, no revision increment and no additional trigger effects.
+modifications are not an extra readback. Changed-reporting same-input literal replay yields no effective write, revision
+increment or additional trigger effects. Matched reporting and arithmetic
+expressions intentionally may write on repeat.
 
 Mutations are untracked. Re-read affected rows before subsequent tracked editing;
 a previously tracked revision remains stale and retains normal conflict checks.
 Use `tx.entity(name).mutate(document)` to compose writes, receipts and jobs in one
-transaction. An outer failure rolls everything back. No synchronous `mutate`
-facade or generic bulk mutation expression language is declared.
+transaction. An outer failure rolls everything back. `entityCore` on a synchronous
+connection also settles these mutations synchronously. `where` accepts a native
+Jaren predicate or structural `sql` expression; `expressions` maps exact logical
+assignment names to `sql` expressions, with logical columns resolved to physical
+names. A member cannot appear in both `set` and `expressions`.
+
+For cross-table insert-select, expression conflict updates, raw JSON text, bytes
+and complete SQLite null/collation semantics use the explicit
+[native SQLite surface](SQLITE-RELATIONAL.md). It shares expression emission with
+entity mutations while retaining its own native SQL result contract.
 
 ## Bounded ranges and live qualification
 

package/docs/SQLITE-RELATIONAL.md

@@ -0,0 +1,190 @@
+# Native SQLite programs on an existing connection
+
+`@jarenjs/db/relational` provides structural SQL authoring, physical table DDL,
+and guarded migrations. `relational(connection)` requires an available
+synchronous SQLite connection from `@jarenjs/db/node` or `@jarenjs/db/bun`.
+It opens no store and uses the supplied connection and transaction. Expressions
+are closed `$sql` nodes built by `sql`; strings are bound values, never SQL
+fragments. Identifiers are quoted as single names. `planRelational` returns
+`{ sql, params, access }` for review without reading the database.
+
+## Choose the expression semantics
+
+| Surface | Null, text and numeric semantics | Execution |
+|---|---|---|
+| LINQ / JSON query over mapped entities | Jaren equality, codepoint text comparison, declared codecs; present null remains null | Qualified native plan; `strict: true` refuses any required residual, including unsupported external bindings |
+| `sql` expressions and `relational` | SQLite three-valued logic, native affinities, explicit BINARY/NOCASE/RTRIM, native aggregates | One native statement; no decoded-row fallback |
+
+For example, Jaren equality regards two present nulls as equal, while SQLite
+`=` yields SQL NULL and `IS` supplies a null-safe comparison. Jaren sum over an
+empty sequence is zero and a present null is a type error. SQLite `sum` skips
+null and returns null without inputs; `total` returns floating zero. SQLite
+floating accumulation and ASCII NOCASE are deliberate choices on this surface.
+No mapping must omit a null member to use native SQL.
+
+```js
+import { relational, sql } from '@jarenjs/db/relational';
+const r = relational(connection);
+const c = sql.column;
+const query = {
+  from: { table: 'staging', as: 's' },
+  columns: {
+    id: c('id', 's'), raw: c('body', 's'),
+    price: sql.cast(sql.call('json_extract', [c('body', 's'), '$.price']), 'REAL'),
+  },
+  where: sql.binary('IS', c('supplier', 's'), sql.param('supplier')),
+  orderBy: [{ by: sql.collate(c('sku', 's'), 'NOCASE'), nulls: 'first' }],
+};
+for (const row of r.iterate(query, { externals: { supplier: null } })) {
+  consume(row); // original raw text and native byte values are preserved
+}
+```
+
+`all`, `get`, `iterate` and `execute` settle synchronously. `iterate` uses the
+shared cursor lifecycle, releases its statement on early return or failure,
+and reports `streaming`/`barrier` from the driver. `all` intentionally collects
+the result. SQLite may itself sort or build temporary query structures.
+
+Selections support table and subquery sources, inner/left/cross joins, correlated
+`sql.scalar`/`sql.exists`, CASE, IN/NOT IN, DISTINCT, grouped and distinct
+aggregates, HAVING, UNION/UNION ALL and ordered windows. The declaration file
+lists the closed operators and functions, including trim/coalesce, LIKE, JSON
+extraction, casts and SQLite date functions. Neither arbitrary function names
+nor a raw-expression escape hatch is accepted.
+
+## Exact writes and bytes
+
+```js
+const result = r.execute({
+  op: 'update', table: 'claims',
+  set: { revision: sql.binary('+', c('revision'), 1), status: 'done' },
+  where: sql.binary('AND',
+    sql.binary('=', c('revision'), sql.param('expected')),
+    sql.binary('=', c('owner'), sql.param('owner'))),
+}, { externals: { expected: 3, owner: 'worker-1' } });
+// result.affected is SQLite's direct statement count, excluding trigger writes.
+```
+
+UPDATE emits exactly the supplied assignments. `reporting: 'matched'` is the
+native surface's default and executes identical assignments, so UPDATE OF and
+immutability triggers run. `reporting: 'changed'` adds a BINARY, null-safe
+comparison to suppress unchanged rows. UPDATE and DELETE require an explicit
+`where`; literal `1` authorizes every row. Predicates and arithmetic belong to
+one statement. The existing entity updater retains changed-row behavior;
+`entity.mutate` adds explicit matched reporting and expression assignments.
+
+INSERT accepts `values` or a `source` selection with ordered target `columns`.
+A source may read another table or an intermediate legacy shape. `ignore: true`
+uses INSERT OR IGNORE. `conflict` accepts ordered column/expression targets, an
+optional partial-index `where`, and `action: 'nothing'` or `'update'` with an
+exact `set` and optional `updateWhere`. Use `sql.column(name, 'excluded')` for
+incoming values. Conflict-target expressions contain literal schema values so
+SQLite can match its index. No read-then-write emulation occurs.
+
+`Uint8Array` and Node `Buffer` values bind as bytes; returned binary values stay
+bytes. Subarray offsets and zero bytes survive without hex strings or JSON
+arrays. Combine metadata, image, conflict and history writes inside the existing
+synchronous transaction; failure rolls back all of them. Optional `returning`
+collects rows using SQLite RETURNING timing, before subsequent AFTER-trigger
+changes. Unlike bounded entity mutation documents, this explicit native surface
+has no automatic result row/byte limit; use a bounded selection or streaming read
+when handling large results.
+
+## Physical schema ownership
+
+```js
+import { defineTable, planTable, planTableMigration, applyTableMigration } from '@jarenjs/db/relational';
+const history = defineTable({
+  name: 'history', primaryKey: ['id'],
+  columns: [
+    { name: 'id', type: 'INTEGER', identity: 'autoincrement', nullable: false },
+    { name: 'body', type: 'TEXT', nullable: false },
+    { name: 'revision', type: 'INTEGER', default: 1, nullable: false },
+  ],
+  indexes: [{ name: 'history_revision', terms: [{ by: c('revision'), direction: 'desc' }] }],
+  triggers: [{ name: 'history_immutable', timing: 'before', event: 'update',
+    steps: [{ raise: { action: 'abort', message: 'immutable history' } }] }],
+});
+const ddl = planTable(history).createSql;
+const migration = planTableMigration(connection, history, { id: 'history-v2', allowRebuild: true });
+// Inspect migration.statements and migration.finish before applying the plan.
+applyTableMigration(connection, migration);
+```
+
+Columns retain declaration order and exact INTEGER/REAL/TEXT/BLOB/NUMERIC/ANY
+types. Definitions support ordered primary keys, rowid or AUTOINCREMENT identity,
+nullability, database defaults, generated columns, STRICT/WITHOUT ROWID, named
+UNIQUE/CHECK/foreign-key constraints and delete/update actions. Index terms
+support expressions, direction and collation, with an optional partial predicate.
+Triggers support BEFORE/AFTER, INSERT/UPDATE/DELETE, UPDATE OF, OLD/NEW conditions,
+mutation steps and RAISE. Schema expressions use the same structural emitter,
+with quoted inline literals because SQLite disallows schema parameters.
+
+Entity `.physical(...)` metadata can also supply column `type`, `defaultValue`,
+`collation`, `identity`, `check`, `generatedExpression` and `stored`, plus table
+`constraints`, `indexes`, `triggers`, `strict` and `withoutRowid`.
+`planEntity(...).createSql` now emits explicit table DDL for complete writable
+declarations; views and incomplete generated/default definitions remain adoption
+metadata. `openStore` still verifies physical tables without creating them.
+Identical physical models produce an empty `planModelMigration`; changed
+physical tables use the live-schema `planTableMigration` API.
+
+## Guarded upgrades
+
+Planning inspects the existing schema without modifying it. A differing existing
+table requires `allowRebuild: true`; additions currently use the same guarded
+rebuild. Every removed column needs `dropColumns`; removing an existing explicit
+index/trigger requires `dropObjects`. Unmentioned indexes and triggers survive.
+An optional `copy` maps writable non-key target columns to structural expressions;
+new columns otherwise use their defaults. The plan retains the source schema and
+an exact canonical checksum. Applying an edited plan or a stale source refuses.
+A target already matching the reviewed plan is a no-op on repeat.
+
+Execution creates a replacement, copies natively, verifies row counts and
+unchanged values/storage classes, drops/renames atomically, restores indexes and
+triggers, and checks foreign keys and the target schema. Primary-key columns,
+unshadowed hidden rowids, raw text, bytes and AUTOINCREMENT high-water marks are
+preserved. A key change, rowid-ownership change or ambiguous rowid alias refuses.
+No migration history table or model adoption is needed.
+
+Rebuilds require SQLite's foreign-key transition outside a transaction. For a
+nested upgrade use `withForeignKeysSuspended(connection, () => { ... })` as the
+outer scope, then nested `connection.transaction`/migration calls share savepoints.
+The helper owns an IMMEDIATE transaction, checks references, and restores
+`foreign_keys` and `legacy_alter_table` after success or failure. Its callback must
+settle synchronously. A rebuild inside an already open FK-enabled transaction
+refuses before DDL. Node/Bun regressions cover populated history and references,
+failed copies, repeat reopening, nested rollback, and process death after DROP
+with WAL recovery. These tests do not establish power-loss durability.
+
+## Read-only inspection and disk snapshots
+
+`readSchema` from `@jarenjs/db/model` inventories tables without adopting them,
+but excludes engine bookkeeping. For a scanner that must include framework tables,
+select table names directly from `sqlite_schema` with `relational`, or use the
+public `connection.dialect.introspect.tables()` statement. A native selection can use `sql.call('typeof', [sql.column(name)])` and
+`sql.column('rowid')` to inspect actual text storage in otherwise unknown shapes.
+Declared affinity does not determine a value's storage class. WITHOUT ROWID tables
+and shadowed rowid aliases require an explicit different identity selection.
+
+Both host driver entries export `snapshotDatabase(connection, newPath)`. It
+reserves a new destination, refuses any existing file (even empty), includes
+committed WAL data through VACUUM INTO, syncs the output and cleans up a failed
+copy. It allocates no database-sized JavaScript image. SQLite page caches and
+its temporary storage govern native working memory. The copy runs synchronously
+inside the asynchronous filesystem operation; it is not an incremental-progress
+or interruption API. A snapshot inside an active transaction fails and cleans up.
+Explicit keys, retained histories and bytes survive; [SQLite VACUUM](https://www.sqlite.org/lang_vacuum.html)
+may renumber unaliased rowids, so this is not a page-identical archival copy. Bun store backups
+use the same disk-backed path; Node store backup keeps its online-backup binding.
+
+## Lightweight engines
+
+Use `@jarenjs/db/query`, `/model` and `/entity` for existing-connection consumers;
+`/relational` needs neither entity normalization nor a query plan cache.
+`compileEntityModel(model)` returns `{ entities, mapping }` from one normalization,
+avoiding the duplicated work of separate `normalizeEntities` and `explainMapping`
+calls. No global strong model cache is introduced. Keep connection/query caches
+bounded and reuse compiled metadata. Smaller import graphs alone do not prove
+the complete application meets its RSS budget; measure application memory with
+representative workloads.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/db",
   "private": false,
-  "version": "0.84.3",
+  "version": "0.85.0",
   "type": "module",
   "main": "./src/index.js",
   "types": "./types/index.d.ts",
@@ -48,6 +48,22 @@
     "./node-pool": {
       "types": "./types/node-pool.d.ts",
       "default": "./src/drivers/node-pool.js"
+    },
+    "./relational": {
+      "types": "./types/relational.d.ts",
+      "default": "./src/relational-api.js"
+    },
+    "./query": {
+      "types": "./types/query.d.ts",
+      "default": "./src/query-api.js"
+    },
+    "./model": {
+      "types": "./types/model.d.ts",
+      "default": "./src/model-api.js"
+    },
+    "./entity": {
+      "types": "./types/entity.d.ts",
+      "default": "./src/entity.js"
     }
   },
   "files": [
@@ -88,9 +104,9 @@
     "prepack": "npm run build:types"
   },
   "dependencies": {
-    "@jarenjs/core": "^0.84.3",
-    "@jarenjs/json": "^0.84.3",
-    "@jarenjs/validate": "^0.84.3"
+    "@jarenjs/core": "^0.85.0",
+    "@jarenjs/json": "^0.85.0",
+    "@jarenjs/validate": "^0.85.0"
   },
   "bin": {
     "jaren-db": "./src/cli.js"

package/schemas/jaren-model.authoring.schema.json

@@ -233,10 +233,167 @@
                   },
                   "generated": {
                     "type": "boolean"
+                  },
+                  "type": {
+                    "enum": [
+                      "INTEGER",
+                      "REAL",
+                      "TEXT",
+                      "BLOB",
+                      "NUMERIC"
+                    ]
+                  },
+                  "defaultValue": {
+                    "description": "A literal SQLite value or closed structural $sql expression; planTable validates its operator and contextual semantics.",
+                    "anyOf": [
+                      {
+                        "type": [
+                          "string",
+                          "number",
+                          "null"
+                        ]
+                      },
+                      {
+                        "type": "object",
+                        "required": [
+                          "$sql"
+                        ],
+                        "properties": {
+                          "$sql": {
+                            "enum": [
+                              "column",
+                              "value",
+                              "binary",
+                              "not",
+                              "in",
+                              "call",
+                              "cast",
+                              "collate",
+                              "case",
+                              "scalar",
+                              "exists"
+                            ]
+                          }
+                        }
+                      }
+                    ]
+                  },
+                  "collation": {
+                    "enum": [
+                      "BINARY",
+                      "NOCASE",
+                      "RTRIM"
+                    ]
+                  },
+                  "identity": {
+                    "enum": [
+                      "rowid",
+                      "autoincrement"
+                    ]
+                  },
+                  "check": {
+                    "description": "A literal SQLite value or closed structural $sql expression; planTable validates its operator and contextual semantics.",
+                    "anyOf": [
+                      {
+                        "type": [
+                          "string",
+                          "number",
+                          "null"
+                        ]
+                      },
+                      {
+                        "type": "object",
+                        "required": [
+                          "$sql"
+                        ],
+                        "properties": {
+                          "$sql": {
+                            "enum": [
+                              "column",
+                              "value",
+                              "binary",
+                              "not",
+                              "in",
+                              "call",
+                              "cast",
+                              "collate",
+                              "case",
+                              "scalar",
+                              "exists"
+                            ]
+                          }
+                        }
+                      }
+                    ]
+                  },
+                  "generatedExpression": {
+                    "description": "A literal SQLite value or closed structural $sql expression; planTable validates its operator and contextual semantics.",
+                    "anyOf": [
+                      {
+                        "type": [
+                          "string",
+                          "number",
+                          "null"
+                        ]
+                      },
+                      {
+                        "type": "object",
+                        "required": [
+                          "$sql"
+                        ],
+                        "properties": {
+                          "$sql": {
+                            "enum": [
+                              "column",
+                              "value",
+                              "binary",
+                              "not",
+                              "in",
+                              "call",
+                              "cast",
+                              "collate",
+                              "case",
+                              "scalar",
+                              "exists"
+                            ]
+                          }
+                        }
+                      }
+                    ]
+                  },
+                  "stored": {
+                    "type": "boolean"
                   }
                 },
                 "additionalProperties": false
               }
+            },
+            "constraints": {
+              "type": "array",
+              "items": {
+                "type": "object"
+              },
+              "description": "Structural SQLite declarations validated by planTable."
+            },
+            "indexes": {
+              "type": "array",
+              "items": {
+                "type": "object"
+              },
+              "description": "Structural SQLite declarations validated by planTable."
+            },
+            "triggers": {
+              "type": "array",
+              "items": {
+                "type": "object"
+              },
+              "description": "Structural SQLite declarations validated by planTable."
+            },
+            "strict": {
+              "type": "boolean"
+            },
+            "withoutRowid": {
+              "type": "boolean"
             }
           },
           "additionalProperties": false