@quereus/quereus 0.2.1 → 0.4.5

package/src/runtime/emit/window.ts

@@ -1,5 +1,5 @@
 import type { WindowNode } from '../../planner/nodes/window-node.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
 import type { OutputValue, Row, SqlValue } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
 import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
@@ -100,14 +100,14 @@ export function emitWindow(plan: WindowNode, ctx: EmissionContext): Instruction
 
 	return {
 		params: [sourceInstruction, ...allCallbacks],
-		run: run as any,
+		run: run as InstructionRun,
 		note: `window(${plan.functions.map(f => f.functionName).join(', ')})`
 	};
 }
 
 async function groupByPartitions(
 	rows: Row[],
-	partitionCallbacks: Array<(ctx: RuntimeContext) => any>,
+	partitionCallbacks: Array<(ctx: RuntimeContext) => OutputValue>,
 	rctx: RuntimeContext,
 	sourceRowDescriptor: RowDescriptor
 ): Promise<Map<string, Row[]>> {

package/src/runtime/emitters.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { QuereusError } from "../common/errors.js";
 import type { PlanNode } from "../planner/nodes/plan-node.js";
 import type { PlanNodeType } from "../planner/nodes/plan-node-type.js";

package/src/runtime/register.ts

@@ -1,135 +1,150 @@
-import { PlanNodeType } from "../planner/nodes/plan-node-type.js";
-import { registerEmitter, type EmitterFunc } from "./emitters.js";
-import { emitBinaryOp } from "./emit/binary.js";
-import { emitUnaryOp } from "./emit/unary.js";
-import { emitLiteral } from "./emit/literal.js";
-import { emitSeqScan } from "./emit/scan.js";
-import { emitIn, emitScalarSubquery, emitExists } from "./emit/subquery.js";
-import { emitBlock } from "./emit/block.js";
-import { emitParameterReference } from './emit/parameter.js';
-import { emitCreateTable } from './emit/create-table.js';
-import { emitCreateIndex } from './emit/create-index.js';
-import { emitDropTable } from './emit/drop-table.js';
-import { emitCreateView } from './emit/create-view.js';
-import { emitDropView } from './emit/drop-view.js';
-import { emitCTE } from './emit/cte.js';
-import { emitCTEReference } from './emit/cte-reference.js';
-import { emitInternalRecursiveCTERef } from './emit/internal-recursive-cte-ref.js';
-import { emitInsert } from './emit/insert.js';
-import { emitUpdate } from './emit/update.js';
-import { emitDmlExecutor } from './emit/dml-executor.js';
-import { emitDelete } from './emit/delete.js';
-import { emitProject } from './emit/project.js';
-import { emitColumnReference } from './emit/column-reference.js';
-import { emitArrayIndex } from './emit/array-index.js';
-import { emitValues, emitSingleRow, emitTableLiteral } from './emit/values.js';
-import { emitFilter } from './emit/filter.js';
-import { emitDistinct } from './emit/distinct.js';
-import { emitScalarFunctionCall } from './emit/scalar-function.js';
-import { emitLimitOffset } from './emit/limit-offset.js';
-import { emitStreamAggregate } from './emit/aggregate.js';
-import { emitCaseExpr } from './emit/case.js';
-import { emitCast } from './emit/cast.js';
-import { emitCollate } from "./emit/collate.js";
-import { emitTableValuedFunctionCall } from './emit/table-valued-function.js';
-import { emitTransaction } from './emit/transaction.js';
-import { emitPragma } from './emit/pragma.js';
-import { emitSort } from './emit/sort.js';
-import { emitWindow } from './emit/window.js';
-import { emitWindowFunctionCall } from './emit/window-function.js';
-import { emitSequencing } from './emit/sequencing.js';
-import { emitRecursiveCTE } from './emit/recursive-cte.js';
-import { emitSetOperation } from './emit/set-operation.js';
-import { emitConstraintCheck } from './emit/constraint-check.js';
-import { emitAddConstraint } from './emit/add-constraint.js';
-import { emitLoopJoin } from './emit/join.js';
-import { emitCache } from './emit/cache.js';
-import { emitReturning } from './emit/returning.js';
-import { emitSink } from './emit/sink.js';
-import { emitBetween } from './emit/between.js';
-
-let registered = false;
-
-export function registerEmitters() {
-	if (registered) {
-		return;
-	}
-	registered = true;
-
-	// Scalar expression emitters
-	registerEmitter(PlanNodeType.BinaryOp, emitBinaryOp as EmitterFunc);
-	registerEmitter(PlanNodeType.UnaryOp, emitUnaryOp as EmitterFunc);
-	registerEmitter(PlanNodeType.Literal, emitLiteral as EmitterFunc);
-	registerEmitter(PlanNodeType.ColumnReference, emitColumnReference as EmitterFunc);
-	registerEmitter(PlanNodeType.ArrayIndex, emitArrayIndex as EmitterFunc);
-	registerEmitter(PlanNodeType.ParameterReference, emitParameterReference as EmitterFunc);
-	registerEmitter(PlanNodeType.ScalarFunctionCall, emitScalarFunctionCall as EmitterFunc);
-	registerEmitter(PlanNodeType.WindowFunctionCall, emitWindowFunctionCall as EmitterFunc);
-	registerEmitter(PlanNodeType.CaseExpr, emitCaseExpr as EmitterFunc);
-	registerEmitter(PlanNodeType.Cast, emitCast as EmitterFunc);
-	registerEmitter(PlanNodeType.Collate, emitCollate as EmitterFunc);
-	registerEmitter(PlanNodeType.Between, emitBetween as EmitterFunc);
-	registerEmitter(PlanNodeType.ScalarSubquery, emitScalarSubquery as EmitterFunc);
-	registerEmitter(PlanNodeType.Exists, emitExists as EmitterFunc);
-
-	// Relational emitters (mix of logical and physical for now)
-	registerEmitter(PlanNodeType.Block, emitBlock as EmitterFunc);
-	registerEmitter(PlanNodeType.CTEReference, emitCTEReference as EmitterFunc);
-	registerEmitter(PlanNodeType.InternalRecursiveCTERef, emitInternalRecursiveCTERef as EmitterFunc);
-
-	// Physical access node emitters (Phase 1)
-	registerEmitter(PlanNodeType.SeqScan, emitSeqScan as EmitterFunc);
-	registerEmitter(PlanNodeType.IndexScan, emitSeqScan as EmitterFunc); // Reuse for now
-	registerEmitter(PlanNodeType.IndexSeek, emitSeqScan as EmitterFunc); // Reuse for now
-
-	registerEmitter(PlanNodeType.Values, emitValues as EmitterFunc);
-	registerEmitter(PlanNodeType.TableLiteral, emitTableLiteral as EmitterFunc);
-	registerEmitter(PlanNodeType.SingleRow, emitSingleRow as EmitterFunc);
-	registerEmitter(PlanNodeType.Filter, emitFilter as EmitterFunc);
-	registerEmitter(PlanNodeType.Project, emitProject as EmitterFunc);
-	registerEmitter(PlanNodeType.Distinct, emitDistinct as EmitterFunc);
-	registerEmitter(PlanNodeType.Sort, emitSort as EmitterFunc);
-	registerEmitter(PlanNodeType.LimitOffset, emitLimitOffset as EmitterFunc);
-	registerEmitter(PlanNodeType.TableFunctionCall, emitTableValuedFunctionCall as EmitterFunc);
-	registerEmitter(PlanNodeType.In, emitIn as EmitterFunc);
-	registerEmitter(PlanNodeType.Window, emitWindow as EmitterFunc);
-	registerEmitter(PlanNodeType.Sequencing, emitSequencing as EmitterFunc);
-	registerEmitter(PlanNodeType.CTE, emitCTE as EmitterFunc);
-	registerEmitter(PlanNodeType.RecursiveCTE, emitRecursiveCTE as EmitterFunc);
-
-	// Physical aggregate emitters
-	registerEmitter(PlanNodeType.StreamAggregate, emitStreamAggregate as EmitterFunc);
-	// For now, logical aggregates also use the stream aggregate emitter
-	registerEmitter(PlanNodeType.Aggregate, emitStreamAggregate as EmitterFunc);
-	// TODO: registerEmitter(PlanNodeType.HashAggregate, emitHashAggregate as EmitterFunc);
-
-	// DML/DDL emitters
-	registerEmitter(PlanNodeType.CreateTable, emitCreateTable as EmitterFunc);
-	registerEmitter(PlanNodeType.CreateIndex, emitCreateIndex as EmitterFunc);
-	registerEmitter(PlanNodeType.DropTable, emitDropTable as EmitterFunc);
-	registerEmitter(PlanNodeType.CreateView, emitCreateView as EmitterFunc);
-	registerEmitter(PlanNodeType.DropView, emitDropView as EmitterFunc);
-	registerEmitter(PlanNodeType.Insert, emitInsert as EmitterFunc);
-	registerEmitter(PlanNodeType.Update, emitUpdate as EmitterFunc);
-	registerEmitter(PlanNodeType.UpdateExecutor, emitDmlExecutor as EmitterFunc);
-	registerEmitter(PlanNodeType.Delete, emitDelete as EmitterFunc);
-	registerEmitter(PlanNodeType.ConstraintCheck, emitConstraintCheck as EmitterFunc);
-	registerEmitter(PlanNodeType.AddConstraint, emitAddConstraint as EmitterFunc);
-	registerEmitter(PlanNodeType.Returning, emitReturning as EmitterFunc);
-
-	// Transaction control emitters
-	registerEmitter(PlanNodeType.Transaction, emitTransaction as EmitterFunc);
-	registerEmitter(PlanNodeType.Pragma, emitPragma as EmitterFunc);
-
-	// Set operation emitter
-	registerEmitter(PlanNodeType.SetOperation, emitSetOperation as EmitterFunc);
-
-	// Join emitters
-	registerEmitter(PlanNodeType.Join, emitLoopJoin as EmitterFunc);
-
-	// Cache emitter
-	registerEmitter(PlanNodeType.Cache, emitCache as EmitterFunc);
-
-	// Sink emitter
-	registerEmitter(PlanNodeType.Sink, emitSink as EmitterFunc);
-}
+import { PlanNodeType } from "../planner/nodes/plan-node-type.js";
+import { registerEmitter, type EmitterFunc } from "./emitters.js";
+import { emitBinaryOp } from "./emit/binary.js";
+import { emitUnaryOp } from "./emit/unary.js";
+import { emitLiteral } from "./emit/literal.js";
+import { emitSeqScan } from "./emit/scan.js";
+import { emitIn, emitScalarSubquery, emitExists } from "./emit/subquery.js";
+import { emitBlock } from "./emit/block.js";
+import { emitParameterReference } from './emit/parameter.js';
+import { emitCreateTable } from './emit/create-table.js';
+import { emitCreateIndex } from './emit/create-index.js';
+import { emitDropTable } from './emit/drop-table.js';
+import { emitCreateView } from './emit/create-view.js';
+import { emitDropView } from './emit/drop-view.js';
+import { emitCreateAssertion } from './emit/create-assertion.js';
+import { emitDropAssertion } from './emit/drop-assertion.js';
+import { emitCTE } from './emit/cte.js';
+import { emitCTEReference } from './emit/cte-reference.js';
+import { emitInternalRecursiveCTERef } from './emit/internal-recursive-cte-ref.js';
+import { emitInsert } from './emit/insert.js';
+import { emitUpdate } from './emit/update.js';
+import { emitDmlExecutor } from './emit/dml-executor.js';
+import { emitDelete } from './emit/delete.js';
+import { emitProject } from './emit/project.js';
+import { emitColumnReference } from './emit/column-reference.js';
+import { emitArrayIndex } from './emit/array-index.js';
+import { emitValues, emitSingleRow, emitTableLiteral } from './emit/values.js';
+import { emitFilter } from './emit/filter.js';
+import { emitDistinct } from './emit/distinct.js';
+import { emitScalarFunctionCall } from './emit/scalar-function.js';
+import { emitLimitOffset } from './emit/limit-offset.js';
+import { emitStreamAggregate } from './emit/aggregate.js';
+import { emitCaseExpr } from './emit/case.js';
+import { emitCast } from './emit/cast.js';
+import { emitCollate } from "./emit/collate.js";
+import { emitTableValuedFunctionCall } from './emit/table-valued-function.js';
+import { emitTransaction } from './emit/transaction.js';
+import { emitPragma } from './emit/pragma.js';
+import { emitSort } from './emit/sort.js';
+import { emitWindow } from './emit/window.js';
+import { emitWindowFunctionCall } from './emit/window-function.js';
+import { emitSequencing } from './emit/sequencing.js';
+import { emitRecursiveCTE } from './emit/recursive-cte.js';
+import { emitSetOperation } from './emit/set-operation.js';
+import { emitConstraintCheck } from './emit/constraint-check.js';
+import { emitAddConstraint } from './emit/add-constraint.js';
+import { emitLoopJoin } from './emit/join.js';
+import { emitCache } from './emit/cache.js';
+import { emitReturning } from './emit/returning.js';
+import { emitSink } from './emit/sink.js';
+import { emitBetween } from './emit/between.js';
+import { emitRetrieve } from './emit/retrieve.js';
+import { emitRemoteQuery } from './emit/remote-query.js';
+import { emitDeclareSchema, emitDiffSchema, emitApplySchema, emitExplainSchema } from './emit/schema-declarative.js';
+
+let registered = false;
+
+export function registerEmitters() {
+	if (registered) {
+		return;
+	}
+	registered = true;
+
+	// Scalar expression emitters
+	registerEmitter(PlanNodeType.BinaryOp, emitBinaryOp as EmitterFunc);
+	registerEmitter(PlanNodeType.UnaryOp, emitUnaryOp as EmitterFunc);
+	registerEmitter(PlanNodeType.Literal, emitLiteral as EmitterFunc);
+	registerEmitter(PlanNodeType.ColumnReference, emitColumnReference as EmitterFunc);
+	registerEmitter(PlanNodeType.ArrayIndex, emitArrayIndex as EmitterFunc);
+	registerEmitter(PlanNodeType.ParameterReference, emitParameterReference as EmitterFunc);
+	registerEmitter(PlanNodeType.ScalarFunctionCall, emitScalarFunctionCall as EmitterFunc);
+	registerEmitter(PlanNodeType.WindowFunctionCall, emitWindowFunctionCall as EmitterFunc);
+	registerEmitter(PlanNodeType.CaseExpr, emitCaseExpr as EmitterFunc);
+	registerEmitter(PlanNodeType.Cast, emitCast as EmitterFunc);
+	registerEmitter(PlanNodeType.Collate, emitCollate as EmitterFunc);
+	registerEmitter(PlanNodeType.Between, emitBetween as EmitterFunc);
+	registerEmitter(PlanNodeType.ScalarSubquery, emitScalarSubquery as EmitterFunc);
+	registerEmitter(PlanNodeType.Exists, emitExists as EmitterFunc);
+
+	// Relational emitters (mix of logical and physical for now)
+	registerEmitter(PlanNodeType.Block, emitBlock as EmitterFunc);
+	registerEmitter(PlanNodeType.CTEReference, emitCTEReference as EmitterFunc);
+	registerEmitter(PlanNodeType.InternalRecursiveCTERef, emitInternalRecursiveCTERef as EmitterFunc);
+	registerEmitter(PlanNodeType.Retrieve, emitRetrieve as EmitterFunc);
+
+	// Physical access node emitters (Phase 1)
+	registerEmitter(PlanNodeType.SeqScan, emitSeqScan as EmitterFunc);
+	registerEmitter(PlanNodeType.IndexScan, emitSeqScan as EmitterFunc); // Reuse for now
+	registerEmitter(PlanNodeType.IndexSeek, emitSeqScan as EmitterFunc); // Reuse for now
+	registerEmitter(PlanNodeType.RemoteQuery, emitRemoteQuery as EmitterFunc);
+
+	registerEmitter(PlanNodeType.Values, emitValues as EmitterFunc);
+	registerEmitter(PlanNodeType.TableLiteral, emitTableLiteral as EmitterFunc);
+	registerEmitter(PlanNodeType.SingleRow, emitSingleRow as EmitterFunc);
+	registerEmitter(PlanNodeType.Filter, emitFilter as EmitterFunc);
+	registerEmitter(PlanNodeType.Project, emitProject as EmitterFunc);
+	registerEmitter(PlanNodeType.Distinct, emitDistinct as EmitterFunc);
+	registerEmitter(PlanNodeType.Sort, emitSort as EmitterFunc);
+	registerEmitter(PlanNodeType.LimitOffset, emitLimitOffset as EmitterFunc);
+	registerEmitter(PlanNodeType.TableFunctionCall, emitTableValuedFunctionCall as EmitterFunc);
+	registerEmitter(PlanNodeType.In, emitIn as EmitterFunc);
+	registerEmitter(PlanNodeType.Window, emitWindow as EmitterFunc);
+	registerEmitter(PlanNodeType.Sequencing, emitSequencing as EmitterFunc);
+	registerEmitter(PlanNodeType.CTE, emitCTE as EmitterFunc);
+	registerEmitter(PlanNodeType.RecursiveCTE, emitRecursiveCTE as EmitterFunc);
+
+	// Physical aggregate emitters
+	registerEmitter(PlanNodeType.StreamAggregate, emitStreamAggregate as EmitterFunc);
+	// Do not map the aggregate node to an emitter.  It is logical only.
+	// NO: registerEmitter(PlanNodeType.Aggregate, emitStreamAggregate as EmitterFunc);
+	// TODO: registerEmitter(PlanNodeType.HashAggregate, emitHashAggregate as EmitterFunc);
+
+	// DML/DDL emitters
+	registerEmitter(PlanNodeType.CreateTable, emitCreateTable as EmitterFunc);
+	registerEmitter(PlanNodeType.CreateIndex, emitCreateIndex as EmitterFunc);
+	registerEmitter(PlanNodeType.DropTable, emitDropTable as EmitterFunc);
+	registerEmitter(PlanNodeType.CreateView, emitCreateView as EmitterFunc);
+	registerEmitter(PlanNodeType.DropView, emitDropView as EmitterFunc);
+	registerEmitter(PlanNodeType.CreateAssertion, emitCreateAssertion as EmitterFunc);
+	registerEmitter(PlanNodeType.DropAssertion, emitDropAssertion as EmitterFunc);
+	registerEmitter(PlanNodeType.Insert, emitInsert as EmitterFunc);
+	registerEmitter(PlanNodeType.Update, emitUpdate as EmitterFunc);
+	registerEmitter(PlanNodeType.UpdateExecutor, emitDmlExecutor as EmitterFunc);
+	registerEmitter(PlanNodeType.Delete, emitDelete as EmitterFunc);
+	registerEmitter(PlanNodeType.ConstraintCheck, emitConstraintCheck as EmitterFunc);
+	registerEmitter(PlanNodeType.AddConstraint, emitAddConstraint as EmitterFunc);
+	registerEmitter(PlanNodeType.Returning, emitReturning as EmitterFunc);
+
+	// Transaction control emitters
+	registerEmitter(PlanNodeType.Transaction, emitTransaction as EmitterFunc);
+	registerEmitter(PlanNodeType.Pragma, emitPragma as EmitterFunc);
+
+	// Declarative schema
+	registerEmitter(PlanNodeType.DeclareSchema, emitDeclareSchema as EmitterFunc);
+	registerEmitter(PlanNodeType.DiffSchema, emitDiffSchema as EmitterFunc);
+	registerEmitter(PlanNodeType.ApplySchema, emitApplySchema as EmitterFunc);
+	registerEmitter(PlanNodeType.ExplainSchema, emitExplainSchema as EmitterFunc);
+
+	// Set operation emitter
+	registerEmitter(PlanNodeType.SetOperation, emitSetOperation as EmitterFunc);
+
+	// Join emitters
+	registerEmitter(PlanNodeType.Join, emitLoopJoin as EmitterFunc);
+
+	// Cache emitter
+	registerEmitter(PlanNodeType.Cache, emitCache as EmitterFunc);
+
+	// Sink emitter
+	registerEmitter(PlanNodeType.Sink, emitSink as EmitterFunc);
+}

package/src/runtime/scheduler.ts

@@ -22,7 +22,7 @@ function wrapIterableForTracing<T>(
 	instruction: Instruction
 ): AsyncIterable<T> {
 	// Prevent double-wrapping
-	if ((src as any)[TRACED_ITERABLE_SYMBOL]) {
+	if ((src as unknown as Record<symbol, boolean>)[TRACED_ITERABLE_SYMBOL]) {
 		return src;
 	}
 
@@ -39,7 +39,7 @@ function wrapIterableForTracing<T>(
 	})();
 
 	// Mark as already wrapped
-	(wrapped as any)[TRACED_ITERABLE_SYMBOL] = true;
+	(wrapped as unknown as Record<symbol, boolean>)[TRACED_ITERABLE_SYMBOL] = true;
 	return wrapped;
 }
 

package/src/runtime/types.ts

@@ -9,7 +9,7 @@ import type { PlanNode } from '../planner/nodes/plan-node.js';
 
 export type RuntimeContext = {
 	db: Database;
-	stmt: Statement | null; // Can be null for transient exec statements
+	stmt: Statement | undefined; // Undefined for transient exec statements
 	params: SqlParameters; // User-provided values for the current execution
 	/** Row contexts by row descriptor */
 	context: Map<RowDescriptor, RowGetter>;
@@ -27,7 +27,7 @@ export type RuntimeContext = {
 	planStack?: PlanNode[];
 };
 
-export type InstructionRun = (ctx: RuntimeContext, ...args: any[]) => OutputValue;
+export type InstructionRun = (ctx: RuntimeContext, ...args: RuntimeValue[]) => OutputValue;
 
 export type Instruction = {
 	params: Instruction[];
@@ -182,16 +182,19 @@ export class CollectingInstructionTracer implements InstructionTracer {
 	}
 
 	private cloneResult(result: OutputValue): OutputValue {
-		return this.cloneValue(result);
+		if (result instanceof Promise) {
+			return result.then(resolved => this.cloneValue(resolved as RuntimeValue));
+		}
+		return this.cloneValue(result as RuntimeValue);
 	}
 
-	private cloneValue(value: any): any {
+	private cloneValue(value: RuntimeValue): RuntimeValue {
 		if (value === null || value === undefined) return value;
 		if (typeof value === 'function') return '[Function]';
-		if (typeof value === 'object' && Symbol.asyncIterator in value) return '[AsyncIterable]';
-		if (Array.isArray(value)) return value.map(v => this.cloneValue(v));
+		if (typeof value === 'object' && value && Symbol.asyncIterator in value) return '[AsyncIterable]';
+		if (Array.isArray(value)) return value.map(v => this.cloneValue(v as RuntimeValue)) as RuntimeValue;
 		if (typeof value === 'object') return '[Object]';
-		return value;
+		return value as RuntimeValue;
 	}
 }
 

package/src/runtime/utils.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { QuereusError } from '../common/errors.js';
 import { StatusCode } from '../common/types.js';
 import type { TableSchema } from '../schema/table.js';
@@ -7,7 +8,7 @@ import type { VirtualTableConnection } from '../vtab/connection.js';
 import { createLogger } from '../common/logger.js';
 import type { MemoryVirtualTableConnection } from '../vtab/memory/connection.js';
 import type { MemoryTable } from '../vtab/memory/table.js';
-import type { RowDescriptor } from '../planner/nodes/plan-node.js';
+import type { RowDescriptor, Attribute } from '../planner/nodes/plan-node.js';
 
 const log = createLogger('runtime:utils');
 const errorLog = log.extend('error');
@@ -121,7 +122,7 @@ export async function disconnectVTable(ctx: RuntimeContext, vtab: VirtualTable):
 /**
  * Helper function to log context push operations
  */
-export function logContextPush(descriptor: RowDescriptor, note: string, attributes?: any[]) {
+export function logContextPush(descriptor: RowDescriptor, note: string, attributes?: readonly Attribute[]) {
 	const attrs = Object.keys(descriptor).filter(k => descriptor[parseInt(k)] !== undefined);
 	const attrNames = attributes ? attributes.map(attr => `${attr.name}(#${attr.id})`).join(',') : 'unknown';
 	ctxLog('PUSH context %s: attrs=[%s] names=[%s]', note, attrs.join(','), attrNames);

package/src/schema/assertion.ts

@@ -0,0 +1,21 @@
+export interface AssertionDependentTable {
+  /** Instance-unique table reference key, e.g. schema.table#nodeId */
+  relationKey: string;
+  /** Base table identifier, e.g. schema.table */
+  base: string;
+}
+
+export interface IntegrityAssertionSchema {
+  /** Unique assertion name */
+  name: string;
+  /** SQL text of the violation-producing query. Any returned row indicates a violation. */
+  violationSql: string;
+  /** Whether the assertion is deferrable. Currently always enforced at COMMIT. */
+  deferrable: boolean;
+  /** If true, initially deferred. Currently informational. */
+  initiallyDeferred: boolean;
+  /** Base tables referenced; filled during assertion preparation/creation. */
+  dependentTables?: AssertionDependentTable[];
+}
+
+

package/src/schema/catalog.ts

@@ -0,0 +1,208 @@
+import type { Database } from '../core/database.js';
+import type { TableSchema } from './table.js';
+import type { ViewSchema } from './view.js';
+import type { IntegrityAssertionSchema } from './assertion.js';
+import { createTableToString } from '../util/ast-stringify.js';
+import type * as AST from '../parser/ast.js';
+
+/**
+ * Represents a catalog snapshot of the current database schema state
+ */
+export interface SchemaCatalog {
+	schemaName: string;
+	tables: CatalogTable[];
+	views: CatalogView[];
+	indexes: CatalogIndex[];
+	assertions: CatalogAssertion[];
+}
+
+export interface CatalogTable {
+	name: string;
+	ddl: string;
+	columns: Array<{ name: string; type: string; notNull: boolean; primaryKey: boolean }>;
+}
+
+export interface CatalogView {
+	name: string;
+	ddl: string;
+}
+
+export interface CatalogIndex {
+	name: string;
+	tableName: string;
+	ddl: string;
+}
+
+export interface CatalogAssertion {
+	name: string;
+	ddl: string;
+}
+
+/**
+ * Collects current schema state from the database into a catalog representation
+ */
+export function collectSchemaCatalog(db: Database, schemaName: string = 'main'): SchemaCatalog {
+	const schema = db.schemaManager.getSchema(schemaName);
+	if (!schema) {
+		return {
+			schemaName,
+			tables: [],
+			views: [],
+			indexes: [],
+			assertions: []
+		};
+	}
+
+	const tables: CatalogTable[] = [];
+	const views: CatalogView[] = [];
+	const indexes: CatalogIndex[] = [];
+	const assertions: CatalogAssertion[] = [];
+
+	// Collect tables
+	for (const tableSchema of schema.getAllTables()) {
+		if (!tableSchema.isView) {
+			tables.push(tableSchemaToCatalog(tableSchema));
+		}
+	}
+
+	// Collect views
+	for (const viewSchema of schema.getAllViews()) {
+		views.push(viewSchemaToCatalog(viewSchema));
+	}
+
+	// Collect assertions
+	for (const assertionSchema of schema.getAllAssertions()) {
+		assertions.push(assertionSchemaToCatalog(assertionSchema));
+	}
+
+	return {
+		schemaName,
+		tables,
+		views,
+		indexes,
+		assertions
+	};
+}
+
+function tableSchemaToCatalog(tableSchema: TableSchema): CatalogTable {
+	// Generate canonical DDL from TableSchema
+	const ddl = generateTableDDL(tableSchema);
+
+	const columns = tableSchema.columns.map(col => ({
+		name: col.name,
+		type: col.affinity?.toString() || 'TEXT',
+		notNull: col.notNull,
+		primaryKey: col.primaryKey
+	}));
+
+	return {
+		name: tableSchema.name,
+		ddl,
+		columns
+	};
+}
+
+function viewSchemaToCatalog(viewSchema: ViewSchema): CatalogView {
+	return {
+		name: viewSchema.name,
+		ddl: viewSchema.sql
+	};
+}
+
+function assertionSchemaToCatalog(assertionSchema: IntegrityAssertionSchema): CatalogAssertion {
+	return {
+		name: assertionSchema.name,
+		ddl: `CREATE ASSERTION ${assertionSchema.name} CHECK (${assertionSchema.violationSql})`
+	};
+}
+
+/**
+ * Generates canonical DDL for a table from its schema
+ */
+function generateTableDDL(tableSchema: TableSchema): string {
+	const parts: string[] = ['CREATE TABLE'];
+
+	if (tableSchema.isTemporary) {
+		parts.push('TEMP');
+	}
+
+	parts.push(`"${tableSchema.name}"`);
+
+	// Generate column definitions
+	const columnDefs: string[] = [];
+	for (const col of tableSchema.columns) {
+		let colDef = `"${col.name}"`;
+		if (col.affinity) {
+			colDef += ` ${col.affinity}`;
+		}
+		if (col.notNull) {
+			colDef += ' NOT NULL';
+		}
+		if (col.primaryKey && tableSchema.primaryKeyDefinition.length === 1) {
+			colDef += ' PRIMARY KEY';
+		}
+		columnDefs.push(colDef);
+	}
+
+	// Add table-level PRIMARY KEY if composite
+	if (tableSchema.primaryKeyDefinition.length > 1) {
+		const pkCols = tableSchema.primaryKeyDefinition
+			.map(pk => `"${tableSchema.columns[pk.index].name}"`)
+			.join(', ');
+		columnDefs.push(`PRIMARY KEY (${pkCols})`);
+	}
+
+	parts.push(`(${columnDefs.join(', ')})`);
+
+	// Add USING clause
+	if (tableSchema.vtabModuleName) {
+		parts.push(`USING ${tableSchema.vtabModuleName}`);
+		if (tableSchema.vtabArgs && Object.keys(tableSchema.vtabArgs).length > 0) {
+			const args = Object.entries(tableSchema.vtabArgs)
+				.map(([key, value]) => `${key} = ${JSON.stringify(value)}`)
+				.join(', ');
+			parts.push(`(${args})`);
+		}
+	}
+
+	return parts.join(' ');
+}
+
+/**
+ * Generates canonical DDL from a declared schema AST
+ */
+export function generateDeclaredDDL(declaredSchema: AST.DeclareSchemaStmt, targetSchema?: string): string[] {
+	const ddlStatements: string[] = [];
+
+	for (const item of declaredSchema.items) {
+		switch (item.type) {
+			case 'declaredTable': {
+				// Qualify table name with schema if specified
+				const tableStmt = item.tableStmt;
+				if (targetSchema && targetSchema !== 'main' && !tableStmt.table.schema) {
+					const qualifiedStmt: AST.CreateTableStmt = {
+						...tableStmt,
+						table: {
+							...tableStmt.table,
+							schema: targetSchema
+						}
+					};
+					ddlStatements.push(createTableToString(qualifiedStmt));
+				} else {
+					ddlStatements.push(createTableToString(tableStmt));
+				}
+				break;
+			}
+			case 'declaredIndex':
+				// TODO: Implement index DDL generation
+				break;
+			case 'declaredView':
+				// TODO: Implement view DDL generation
+				break;
+		}
+	}
+
+	return ddlStatements;
+}
+
+

package/src/schema/change-events.ts

@@ -11,8 +11,8 @@ export interface SchemaChangeEvent {
 	      'module_added' | 'module_removed' | 'collation_added' | 'collation_removed';
 	schemaName?: string;
 	objectName: string;
-	oldObject?: any;
-	newObject?: any;
+	oldObject?: unknown;
+	newObject?: unknown;
 }
 
 /**