@minnowdb/core 0.4.1 → 0.6.0

package/dist/storage/types.d.ts

@@ -111,7 +111,7 @@ export type SqlDomain = {
     precision?: number;
     scale?: number;
 } | {
-    kind: "json" | "jsonb" | "uuid" | "time" | "interval";
+    kind: "json" | "jsonb" | "uuid" | "date" | "time" | "interval";
 } | {
     kind: "array";
     element: string;
@@ -136,6 +136,11 @@ export type ColumnDefault = {
 } | {
     kind: "autoincrement";
 };
+/** A stored generated-column expression, evaluated from the row on every insert and update. */
+export interface ColumnGenerated {
+    readonly kind: "stored";
+    readonly sql: string;
+}
 export interface TableColumnRecord {
     id: string;
     name: string;
@@ -152,6 +157,8 @@ export interface TableColumnRecord {
     nullable: boolean;
     /** Fills omitted or SQL `DEFAULT` slots at insert time; explicit NULL is never replaced. */
     defaultValue?: ColumnDefault;
+    /** Recomputed from sibling columns on every insert and update; callers cannot assign it. */
+    generatedValue?: ColumnGenerated;
     /**
      * What rows written before this column existed read as, instead of NULL.
      *
@@ -264,6 +271,15 @@ export interface SecondaryIndexRecord {
  * accelerator. Index identity, key shape, and UNIQUE enforcement are structural.
  */
 export declare function secondaryIndexWriteContractChanged(previous: Readonly<Record<string, SecondaryIndexRecord>> | null | undefined, next: Readonly<Record<string, SecondaryIndexRecord>> | null | undefined): boolean;
+export interface TableForeignKeyRecord {
+    name: string;
+    columns: string[];
+    parentTable: string;
+    parentColumns: string[];
+    onDelete: "restrict" | "cascade" | "set null";
+    /** False records relationship metadata without write/delete enforcement. Absent means true. */
+    enforced?: boolean;
+}
 export interface TableRecord {
     id: string;
     name: string;
@@ -279,13 +295,7 @@ export interface TableRecord {
     /** BEFORE/AFTER triggers on this table, fired by the committing writer in its transaction. */
     triggers?: TriggerRecord[];
     /** FOREIGN KEY constraints. Column tuples are always explicit, including scalar keys. */
-    foreignKeys?: Array<{
-        name: string;
-        columns: string[];
-        parentTable: string;
-        parentColumns: string[];
-        onDelete: "restrict" | "cascade" | "set null";
-    }>;
+    foreignKeys?: TableForeignKeyRecord[];
     /**
      * Row-level CHECK constraints (E141-06), each the text of a boolean expression over this
      * table's own columns. Text rather than a compiled form because the record crosses the worker
@@ -329,6 +339,12 @@ export interface TableRecord {
     /** Compare-and-swap revision for catalog evolution. */
     revision: number;
 }
+/**
+ * Validates one relationship against its child and parent records. This is shared by every
+ * storage adapter and snapshot restore path so informational relationships cannot bypass the
+ * same structural and domain checks as enforced foreign keys.
+ */
+export declare function validateTableForeignKey(childTable: TableRecord, key: TableForeignKeyRecord, parentTable: TableRecord): void;
 /** Exact UTF-8 bytes used when the canonical record-wire JSON codec persists a table record. */
 export declare function catalogRecordRetainedBytes(record: TableRecord): number;
 export declare function manifestRecordRetainedBytes(record: Manifest): number;
@@ -1815,6 +1831,8 @@ export interface CatalogMutationOptions {
 /** Atomic replacement fields for one catalog record. */
 export interface TableRecordUpdate extends CatalogMutationOptions {
     columns?: TableColumnRecord[];
+    /** Replaces the complete relationship catalog. */
+    foreignKeys?: TableRecord["foreignKeys"];
     /** Replaces the full-text index state map; null clears it. */
     ftsColumns?: Record<string, FtsColumnIndexRecord> | null;
     /** Replaces the secondary-index state map; null clears it. */

package/dist/storage/types.js

@@ -141,6 +141,22 @@ export function validateTableColumns(columns) {
                 ...(column.enumValues === undefined ? {} : { enumValues: column.enumValues }),
             }, column.defaultValue);
         }
+        if (column.generatedValue !== undefined) {
+            const generated = column.generatedValue;
+            if (typeof generated !== "object" ||
+                generated === null ||
+                !("kind" in generated) ||
+                generated.kind !== "stored" ||
+                !("sql" in generated) ||
+                typeof generated.sql !== "string" ||
+                generated.sql.length === 0 ||
+                generated.sql.trim() !== generated.sql) {
+                throw new TypeError(`Generated SQL must be a trimmed non-empty expression: ${column.name}`);
+            }
+            if (column.defaultValue !== undefined || column.backfill !== undefined || column.hidden) {
+                throw new TypeError(`Generated columns cannot have defaults, backfills, or hidden metadata: ${column.name}`);
+            }
+        }
         if (column.backfill !== undefined) {
             const value = column.backfill;
             const validType = column.type === "datetime"
@@ -258,6 +274,70 @@ export function secondaryIndexWriteContractChanged(previous, next) {
             left.locator !== right.locator);
     });
 }
+/**
+ * Validates one relationship against its child and parent records. This is shared by every
+ * storage adapter and snapshot restore path so informational relationships cannot bypass the
+ * same structural and domain checks as enforced foreign keys.
+ */
+export function validateTableForeignKey(childTable, key, parentTable) {
+    if (typeof key.name !== "string" ||
+        key.name.length === 0 ||
+        typeof key.parentTable !== "string" ||
+        key.parentTable.length === 0 ||
+        !Array.isArray(key.columns) ||
+        !Array.isArray(key.parentColumns) ||
+        key.columns.length === 0 ||
+        key.columns.some((column) => typeof column !== "string" || column.length === 0) ||
+        key.parentColumns.some((column) => typeof column !== "string" || column.length === 0) ||
+        new Set(key.columns).size !== key.columns.length ||
+        new Set(key.parentColumns).size !== key.parentColumns.length ||
+        !["restrict", "cascade", "set null"].includes(key.onDelete) ||
+        (key.enforced !== undefined && typeof key.enforced !== "boolean")) {
+        throw new TypeError("FOREIGN KEY metadata is invalid");
+    }
+    if (key.parentTable !== parentTable.name) {
+        throw new TypeError(`FOREIGN KEY ${key.name} resolved to the wrong parent table`);
+    }
+    if (key.enforced === false && key.onDelete !== "restrict") {
+        throw new TypeError(`Informational FOREIGN KEY ${key.name} cannot declare ON DELETE actions`);
+    }
+    const children = key.columns.map((name) => childTable.columns.find((column) => column.name === name && column.hidden !== true));
+    if (children.some((column) => column === undefined)) {
+        throw new TypeError(`FOREIGN KEY ${key.name} names a column this table does not have`);
+    }
+    const addressIds = parentTable.primaryKeyColumnIds?.length
+        ? parentTable.primaryKeyColumnIds
+        : parentTable.uniqueKeyColumnId === undefined
+            ? []
+            : [parentTable.uniqueKeyColumnId];
+    const parents = addressIds.map((id) => parentTable.columns.find((column) => column.id === id && column.hidden !== true));
+    const addressNames = parents.map((column) => column?.name ?? "");
+    if (addressNames.length !== key.parentColumns.length ||
+        addressNames.some((name, index) => name !== key.parentColumns[index])) {
+        throw new TypeError(`FOREIGN KEY ${key.name} must reference the parent primary or unique key`);
+    }
+    if (children.length !== parents.length) {
+        throw new TypeError(`FOREIGN KEY ${key.name} has ${String(children.length)} child columns for ${String(parents.length)} parent columns`);
+    }
+    children.forEach((child, index) => {
+        const parent = parents[index];
+        if (child === undefined || parent === undefined) {
+            throw new TypeError(`FOREIGN KEY ${key.name} is missing a key column`);
+        }
+        if (child.type !== parent.type) {
+            throw new TypeError(`FOREIGN KEY ${key.name} compares ${child.type} with ${parent.type}`);
+        }
+        if ((child.integer === true) !== (parent.integer === true)) {
+            throw new TypeError(`FOREIGN KEY ${key.name} compares an integer domain with an approximate number domain`);
+        }
+        if (JSON.stringify(child.sqlDomain ?? null) !== JSON.stringify(parent.sqlDomain ?? null)) {
+            throw new TypeError(`FOREIGN KEY ${key.name} compares different SQL value domains`);
+        }
+        if (key.onDelete === "set null" && !child.nullable) {
+            throw new TypeError(`FOREIGN KEY ${key.name} cannot SET NULL a NOT NULL column`);
+        }
+    });
+}
 const catalogRecordTextEncoder = new TextEncoder();
 function durableRecordRetainedBytes(record, label) {
     // Keep this byte accounting identical to the canonical record-wire JSON codec without
@@ -389,6 +469,11 @@ export function validateTableRecordBounds(record) {
         throw new RangeError(`A table cannot exceed ${String(MAX_TABLE_CONSTRAINTS)} named constraints`);
     }
     const constraintNames = new Set();
+    for (const key of record.foreignKeys ?? []) {
+        if (key.enforced !== undefined && typeof key.enforced !== "boolean") {
+            throw new TypeError(`FOREIGN KEY enforcement is invalid: ${key.name}`);
+        }
+    }
     for (const constraintName of namedConstraints) {
         validateCatalogName(constraintName, "Constraint name");
         if (constraintNames.has(constraintName)) {

package/dist/transactions/index.d.ts

@@ -195,9 +195,11 @@ export declare class DatabaseTransaction {
     setUniqueKeyChanges(changes: UniqueKeyChanges): void;
     /**
      * Attaches one batch's full-text deltas; applied atomically with the publish. A second
-     * batch for the same table merges per column — postings re-sorted by term (each batch's
-     * reserved row ids are strictly above the last, so rowIds stay ascending within a term)
-     * and token totals summed — so a scope can insert into one FTS table any number of times.
+     * batch for the same table merges per column — postings stay sorted by term and row ID,
+     * duplicate row locators collapse to their greatest term frequency, and token totals are
+     * summed — so a scope can mutate one indexed table any number of times. Secondary indexes
+     * use stable hashed key locators rather than reserved row IDs, so operation order does not
+     * imply locator order.
      */
     setFtsChanges(changes: FtsChanges): void;
     /**

package/dist/transactions/index.js

@@ -712,9 +712,11 @@ export class DatabaseTransaction {
     }
     /**
      * Attaches one batch's full-text deltas; applied atomically with the publish. A second
-     * batch for the same table merges per column — postings re-sorted by term (each batch's
-     * reserved row ids are strictly above the last, so rowIds stay ascending within a term)
-     * and token totals summed — so a scope can insert into one FTS table any number of times.
+     * batch for the same table merges per column — postings stay sorted by term and row ID,
+     * duplicate row locators collapse to their greatest term frequency, and token totals are
+     * summed — so a scope can mutate one indexed table any number of times. Secondary indexes
+     * use stable hashed key locators rather than reserved row IDs, so operation order does not
+     * imply locator order.
      */
     setFtsChanges(changes) {
         this.#assertActive();
@@ -746,6 +748,7 @@ export class DatabaseTransaction {
                 });
                 continue;
             }
+            let duplicateTokens = 0;
             for (const posting of column.postings) {
                 const held = present.postings.get(posting.term);
                 if (held === undefined) {
@@ -756,13 +759,18 @@ export class DatabaseTransaction {
                     });
                 }
                 else {
-                    for (const rowId of posting.rowIds)
-                        held.rowIds.push(rowId);
-                    for (const tf of posting.tf)
-                        held.tf.push(tf);
+                    const merged = mergeFtsPostingRows(held, posting);
+                    duplicateTokens = safeWholeNumberSum([
+                        duplicateTokens,
+                        postingTokenCount(held) + postingTokenCount(posting) - postingTokenCount(merged),
+                    ], "Duplicate posting token count");
+                    present.postings.set(posting.term, merged);
                 }
             }
-            present.totalTokens = tokenTotals.get(column.columnId) ?? present.totalTokens;
+            const totalTokens = tokenTotals.get(column.columnId) ?? present.totalTokens;
+            if (duplicateTokens > totalTokens)
+                throw new Error("Posting token merge is inconsistent");
+            present.totalTokens = totalTokens - duplicateTokens;
         }
     }
     #materializedFtsChanges() {
@@ -1615,6 +1623,48 @@ function safeWholeNumberSum(values, label) {
     }
     return total;
 }
+/** Linear merge of two canonical postings for one term. */
+function mergeFtsPostingRows(left, right) {
+    if (left.term !== right.term)
+        throw new TypeError("Posting terms differ during transaction merge");
+    const rowIds = [];
+    const tf = [];
+    let leftIndex = 0;
+    let rightIndex = 0;
+    const push = (rowId, frequency) => {
+        const previous = rowIds[rowIds.length - 1];
+        if (previous === rowId) {
+            tf[tf.length - 1] = Math.max(tf[tf.length - 1] ?? 1, frequency);
+            return;
+        }
+        rowIds.push(rowId);
+        tf.push(frequency);
+    };
+    while (leftIndex < left.rowIds.length && rightIndex < right.rowIds.length) {
+        const leftRowId = left.rowIds[leftIndex] ?? 0n;
+        const rightRowId = right.rowIds[rightIndex] ?? 0n;
+        if (leftRowId <= rightRowId) {
+            push(leftRowId, left.tf[leftIndex] ?? 1);
+            leftIndex += 1;
+        }
+        if (rightRowId <= leftRowId) {
+            push(rightRowId, right.tf[rightIndex] ?? 1);
+            rightIndex += 1;
+        }
+    }
+    while (leftIndex < left.rowIds.length) {
+        push(left.rowIds[leftIndex] ?? 0n, left.tf[leftIndex] ?? 1);
+        leftIndex += 1;
+    }
+    while (rightIndex < right.rowIds.length) {
+        push(right.rowIds[rightIndex] ?? 0n, right.tf[rightIndex] ?? 1);
+        rightIndex += 1;
+    }
+    return { term: left.term, rowIds, tf };
+}
+function postingTokenCount(posting) {
+    return safeWholeNumberSum(posting.tf, "Posting token count");
+}
 function requiredCompactionJobId(id) {
     if (id === null)
         throw new Error("Compaction source blocks require a compaction job");

package/dist/worker-protocol/index.d.ts

@@ -1,4 +1,4 @@
-export declare const protocolVersion: 2;
+export declare const protocolVersion: 3;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export declare const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export type WorkerOperation = "benchmark" | "cancelBenchmark" | "memorySample" | "datasetList" | "datasetCreate" | "datasetDelete" | "runQuery" | "suiteReference" | "suiteWrite" | "suiteFeatureMatrix" | "suiteLive";
@@ -46,6 +46,11 @@ export type RpcRequest = {
     handleId: string | null;
     method: string;
     args: unknown[];
+} | {
+    version: typeof protocolVersion;
+    /** The request whose work should stop. Cancellation has no response frame of its own. */
+    requestId: string;
+    kind: "rpc-cancel";
 };
 export type RpcResponse = {
     version: typeof protocolVersion;

package/dist/worker-protocol/index.js

@@ -1,4 +1,4 @@
-export const protocolVersion = 2;
+export const protocolVersion = 3;
 /** Outstanding request/response pairs retained by either side of one database RPC connection. */
 export const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export function parseRequest(value) {
@@ -64,8 +64,11 @@ export function parseRpcRequest(value) {
     if (typeof value !== "object" || value === null)
         return null;
     const candidate = value;
-    if (candidate.kind !== "rpc-init" && candidate.kind !== "rpc-call")
+    if (candidate.kind !== "rpc-init" &&
+        candidate.kind !== "rpc-call" &&
+        candidate.kind !== "rpc-cancel") {
         return null;
+    }
     if (candidate.version !== protocolVersion)
         throw new Error("Unsupported protocol version");
     if (typeof candidate.requestId !== "string" || candidate.requestId.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",

package/postgres-feature-profile.json

@@ -149,6 +149,11 @@
       "classification": "different",
       "reason": "Minnow returns arrays as canonical JSON text at the JavaScript boundary while PostgreSQL clients commonly return native arrays."
     },
+    {
+      "id": "type.date",
+      "classification": "different",
+      "reason": "Minnow returns zoneless DATE values as canonical YYYY-MM-DD text while PostgreSQL clients commonly materialize them as midnight Date objects."
+    },
     {
       "id": "json.query",
       "classification": "different",

package/sql-feature-matrix.json

@@ -1,5 +1,5 @@
 {
-  "version": 4,
+  "version": 5,
   "description": "Executable PostgreSQL compatibility examples for MinnowDatabase. postgres-feature-profile.json records differences, extensions, and embedded exclusions.",
   "features": [
     {
@@ -20,7 +20,8 @@
     {
       "id": "select.distinct",
       "status": "supported",
-      "example": "SELECT DISTINCT region FROM rows"
+      "example": "SELECT DISTINCT region FROM rows",
+      "notes": "Plain projections and SELECT DISTINCT * are supported. DISTINCT combined with grouping, HAVING, or aggregate/window expressions is rejected."
     },
     {
       "id": "select.scalar-subquery",
@@ -127,7 +128,7 @@
       "id": "group-by.rollup",
       "status": "supported",
       "example": "SELECT region, SUM(amount) AS total FROM rows GROUP BY ROLLUP(region)",
-      "notes": "ROLLUP/CUBE/GROUPING SETS desugar into a UNION ALL of grouped blocks. The GROUPING() marker is deliberately unsupported, so rollup NULLs and data NULLs are indistinguishable. SQLite itself has none of these."
+      "notes": "ROLLUP/CUBE/GROUPING SETS desugar into a UNION ALL of grouped blocks. GROUPING() distinguishes rolled-up columns from data NULLs. SQLite itself has none of these."
     },
     {
       "id": "group-by.grouping-sets",
@@ -245,7 +246,7 @@
       "id": "mutation.update-keyed",
       "status": "supported",
       "example": "UPDATE keyed SET score = score + 1 WHERE score > 0",
-      "notes": "Requires a unique-key table; read-then-mutate, not serializable."
+      "notes": "Requires a unique-key table. A standalone statement reads and publishes inside one retryable write scope; an explicit transaction stages it with the transaction's other statements."
     },
     {
       "id": "mutation.delete-keyed",
@@ -316,7 +317,7 @@
       "id": "predicate.quantified",
       "status": "supported",
       "example": "SELECT region FROM rows WHERE amount > ALL (SELECT amount FROM dims)",
-      "notes": "ANY/SOME/ALL with full three-valued logic; correlated forms are rejected. SQLite itself has no quantified comparisons."
+      "notes": "ANY/SOME/ALL use full three-valued logic. Correlated forms are supported as top-level WHERE predicates. SQLite itself has no quantified comparisons."
     },
     {
       "id": "predicate.ilike",
@@ -387,30 +388,67 @@
       "id": "subquery.correlated",
       "status": "supported",
       "example": "SELECT region FROM rows r WHERE amount > (SELECT AVG(amount) FROM rows q WHERE q.region = r.region)",
-      "notes": "Equality-correlated subqueries decorrelate into derived-table joins at compile time; both executors run plain joins."
+      "notes": "Correlated subqueries decorrelate into derived-table joins at compile time; both executors run plain joins."
     },
     {
       "id": "subquery.correlated-exists",
       "status": "supported",
       "example": "SELECT amount FROM rows r WHERE EXISTS (SELECT region FROM dims d WHERE d.region = r.region)",
-      "notes": "EXISTS joins the subquery's distinct correlation keys; NOT EXISTS becomes a left join checked with IS NULL."
+      "notes": "Top-level EXISTS and NOT EXISTS lower to semi-joins and anti-joins. Nested boolean forms use hidden per-probe match flags."
     },
     {
       "id": "subquery.correlated-select",
       "status": "supported",
       "example": "SELECT r.region, (SELECT AVG(q.amount) FROM rows q WHERE q.region = r.region) AS regional FROM rows r",
-      "notes": "Correlated scalar aggregates decorrelate in the select list too, outside grouped queries."
+      "notes": "Correlated scalar aggregates decorrelate in the select list. In a grouped query, their outer references must be GROUP BY columns and the scalar cannot sit inside an outer aggregate."
+    },
+    {
+      "id": "subquery.correlated-select-grouped",
+      "status": "supported",
+      "example": "SELECT r.region, COUNT(*) AS c, (SELECT AVG(q.amount) FROM rows q WHERE q.region = r.region) AS regional FROM rows r GROUP BY r.region",
+      "notes": "The decorrelated value is functionally determined by the outer grouping keys and is carried as an internal group key."
+    },
+    {
+      "id": "subquery.correlated-scalar-non-equi",
+      "status": "supported",
+      "example": "SELECT r.amount, (SELECT COUNT(*) FROM rows q WHERE q.amount < r.amount) AS lower_count FROM rows r",
+      "notes": "Non-equality scalar aggregates group inner rows once per distinct outer probe tuple, then join the result back by equality."
+    },
+    {
+      "id": "subquery.correlated-exists-expression",
+      "status": "supported",
+      "example": "SELECT r.amount FROM rows r WHERE r.amount > 100 OR EXISTS (SELECT d.region FROM dims d WHERE d.region = r.region)",
+      "notes": "Correlated EXISTS and NOT EXISTS remain set-at-a-time when nested below OR, NOT, or CASE."
     },
     {
       "id": "subquery.correlated-non-equi",
       "status": "supported",
       "example": "SELECT r.amount FROM rows r WHERE EXISTS (SELECT q.amount FROM rows q WHERE q.amount < r.amount)",
-      "notes": "Non-equality EXISTS and NOT EXISTS correlations lower to semi-joins and anti-joins; correlated scalar aggregates and IN remain equality-only."
+      "notes": "Non-equality EXISTS and NOT EXISTS correlations lower to semi-joins and anti-joins. Scalar aggregates use distinct outer probes."
+    },
+    {
+      "id": "subquery.correlated-in-non-equi",
+      "status": "supported",
+      "example": "SELECT r.amount FROM rows r WHERE r.region IN (SELECT q.region FROM rows q WHERE q.amount < r.amount)",
+      "notes": "A range-correlated IN predicate lowers to a semi-join carrying both its correlation and membership comparisons."
     },
     {
       "id": "subquery.correlated-not-in",
       "status": "supported",
-      "example": "SELECT region FROM rows r WHERE region NOT IN (SELECT d.region FROM dims d WHERE d.region = r.region)"
+      "example": "SELECT region FROM rows r WHERE region NOT IN (SELECT d.region FROM dims d WHERE d.region = r.region)",
+      "notes": "Correlated NOT IN preserves empty-set and NULL semantics rather than treating it as a simple anti-join."
+    },
+    {
+      "id": "subquery.correlated-not-in-non-equi",
+      "status": "supported",
+      "example": "SELECT r.amount FROM rows r WHERE 'north' NOT IN (SELECT q.region FROM rows q WHERE q.amount < r.amount)",
+      "notes": "Range correlation uses an anti-join for exact matches plus per-probe total and non-NULL counts."
+    },
+    {
+      "id": "subquery.correlated-quantified",
+      "status": "supported",
+      "example": "SELECT r.amount FROM rows r WHERE r.amount > ALL (SELECT q.amount FROM rows q WHERE q.region = r.region)",
+      "notes": "At top-level WHERE, correlated ANY lowers to a semi-join on true comparisons and ALL to an anti-join on false or unknown comparisons."
     },
     {
       "id": "cte.recursive",
@@ -456,13 +494,13 @@
       "id": "aggregate.filter",
       "status": "supported",
       "example": "SELECT region, COUNT(*) FILTER (WHERE amount > 5) AS big FROM rows GROUP BY region",
-      "notes": "Desugars into a CASE inside the aggregate, so it works with every aggregate and DISTINCT."
+      "notes": "Desugars into a CASE inside COUNT/SUM/AVG/MIN/MAX and preserves DISTINCT. JSON_ARRAYAGG does not support FILTER."
     },
     {
       "id": "window.aggregate-over",
       "status": "supported",
       "example": "SELECT SUM(amount) OVER (PARTITION BY region) AS total FROM rows",
-      "notes": "Default frame only: whole partition without OVER ordering, running with peers when ordered."
+      "notes": "Without explicit framing, the default is the whole partition when unordered and a peer-aware running frame when ordered. ROWS, RANGE, GROUPS, and exclusions are tracked separately below."
     },
     {
       "id": "window.in-expression",
@@ -569,7 +607,7 @@
       "id": "trigger.create-after",
       "status": "supported",
       "example": "CREATE TRIGGER keyed_audit AFTER INSERT ON keyed BEGIN INSERT INTO rows (region, amount) VALUES (NEW.name, NEW.score); END",
-      "notes": "AFTER and BEFORE row triggers on INSERT/UPDATE/DELETE, executed atomically inside the triggering commit with NEW/OLD references. Bodies: INSERT ... VALUES into keyless tables; UPDATE/DELETE against keyed tables. One cascade level is allowed; deeper chains error at write time."
+      "notes": "AFTER and BEFORE row triggers on INSERT/UPDATE/DELETE execute atomically with NEW/OLD references. Bodies support parameter-free INSERT ... VALUES into keyless tables and UPDATE/DELETE against keyed tables; ON CONFLICT and RETURNING are rejected. One cascade level is allowed."
     },
     {
       "id": "trigger.create-before",
@@ -970,8 +1008,8 @@
     {
       "id": "json.object",
       "status": "supported",
-      "example": "SELECT JSON_OBJECT('a' VALUE 1, 'missing' VALUE NULL) AS document",
-      "notes": "Defaults to NULL ON NULL and WITHOUT UNIQUE KEYS. NULL keys are rejected. The constructor returns JSON text; cast or store it as JSON/JSONB for domain validation and JSONB canonicalization."
+      "example": "SELECT JSON_OBJECT('a' VALUE 1, 'detail' VALUE JSON_OBJECT('name' VALUE 'Acme')) AS document",
+      "notes": "Defaults to NULL ON NULL and WITHOUT UNIQUE KEYS. NULL keys are rejected. JSON-producing arguments embed as documents rather than escaped strings; ordinary text remains a string. The constructor returns JSON text; cast or store it as JSON/JSONB for domain validation and JSONB canonicalization."
     },
     {
       "id": "json.array",
@@ -990,6 +1028,12 @@
       "example": "CREATE TABLE defaulted (id INTEGER PRIMARY KEY, tier TEXT DEFAULT 'basic')",
       "notes": "DEFAULT accepts a variable-free scalar expression. Omission or SQL DEFAULT invokes it; explicit NULL follows the column's independent nullability."
     },
+    {
+      "id": "ddl.generated-column",
+      "status": "supported",
+      "example": "CREATE TABLE generated_value (base INTEGER, doubled INTEGER GENERATED ALWAYS AS (base * 2) STORED)",
+      "notes": "Stored generated columns recompute on every write and may be indexed, but cannot be caller-assigned or used as Minnow's row-addressing primary/unique key. Expressions are immutable and row-local."
+    },
     {
       "id": "ddl.create-table-key-clause",
       "status": "supported",
@@ -1117,7 +1161,13 @@
       "id": "from.lateral",
       "status": "supported",
       "example": "SELECT x.amount FROM rows r, LATERAL (SELECT amount FROM dims WHERE dims.region = r.region) x",
-      "notes": "Equality-correlated derived sources become set-at-a-time joins. Correlated grouping, ordering, and LIMIT remain unsupported."
+      "notes": "Equality and range-correlated derived sources become set-at-a-time joins. Correlated grouping, ordering, and LIMIT remain unsupported."
+    },
+    {
+      "id": "from.lateral-non-equi",
+      "status": "supported",
+      "example": "SELECT x.amount FROM rows r, LATERAL (SELECT q.amount FROM rows q WHERE q.amount < r.amount) x",
+      "notes": "Non-equality correlation lowers to an ordinary general join rather than executing the derived source once per outer row."
     },
     {
       "id": "aggregate.string-agg",
@@ -1146,8 +1196,8 @@
     {
       "id": "aggregate.json",
       "status": "supported",
-      "example": "SELECT JSON_ARRAYAGG(region) AS regions FROM rows",
-      "notes": "Supports DISTINCT, includes SQL NULL as JSON null, and returns NULL for empty input. FILTER, window use, aggregate-local ORDER BY, and explicit NULL/ABSENT clauses are not supported; input order is otherwise unspecified."
+      "example": "SELECT JSON_ARRAYAGG(JSON_OBJECT('region' VALUE region)) AS regions FROM rows",
+      "notes": "Supports DISTINCT, embeds JSON-producing inputs as documents, includes SQL NULL as JSON null, and returns NULL for empty input. FILTER, window use, aggregate-local ORDER BY, and explicit NULL/ABSENT clauses are not supported; input order is otherwise unspecified."
     },
     {
       "id": "type.array",
@@ -1161,6 +1211,12 @@
       "example": "SELECT TIME '12:00:00' AS at",
       "notes": "A time of day without a time zone, returned as canonical text."
     },
+    {
+      "id": "type.date",
+      "status": "supported",
+      "example": "SELECT CAST('2026-08-26' AS DATE) AS day",
+      "notes": "A calendar date without a time zone, returned as canonical YYYY-MM-DD text."
+    },
     {
       "id": "ddl.sequence",
       "status": "supported",
@@ -1178,7 +1234,7 @@
       "id": "ddl.create-view",
       "status": "supported",
       "example": "CREATE VIEW west AS SELECT region, amount FROM rows WHERE region = 'west'",
-      "notes": "The catalog stores the query text and the schema inferred from it, so a view answers the same questions a table does and reads expand it into the query it stands for — anywhere a read runs, including inside a write scope. A view is never a write target. CREATE OR REPLACE redefines one; a view stacked on it follows the new definition, and a cycle two redefinitions close is caught on the next read rather than recursed."
+      "notes": "The catalog stores the query text and inferred schema, so reads expand a view anywhere a table can be read, including inside a write scope. A view is never a write target. CREATE OR REPLACE redefines one; dependent views follow it and cycles are rejected on read. CREATE VIEW column-name lists are not supported."
     },
     {
       "id": "ddl.drop-view",