@quereus/quereus 0.2.0 → 0.4.0

package/src/runtime/emit/constraint-check.ts

@@ -1,13 +1,25 @@
 import type { ConstraintCheckNode } from '../../planner/nodes/constraint-check-node.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
 import type { Row } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
 import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
 import { QuereusError } from '../../common/errors.js';
 import { StatusCode, type SqlValue, type OutputValue } from '../../common/types.js';
 import type { RowConstraintSchema, TableSchema } from '../../schema/table.js';
-import { RowOp } from '../../schema/table.js';
-import { withAsyncRowContext } from '../context-helpers.js';
+import type { RowDescriptor } from '../../planner/nodes/plan-node.js';
+import { RowOpFlag } from '../../schema/table.js';
+import { withAsyncRowContext, createRowSlot } from '../context-helpers.js';
+
+interface ConstraintMetadataEntry {
+	schema: RowConstraintSchema;
+	flatRowDescriptor: RowDescriptor;
+	evaluator: (ctx: RuntimeContext) => OutputValue;
+	constraintName: string;
+	shouldDefer: boolean;
+	baseTable: string;
+	contextRow?: Row; // Mutation context row if present
+	contextDescriptor?: RowDescriptor; // Mutation context row descriptor
+}
 
 export function emitConstraintCheck(plan: ConstraintCheckNode, ctx: EmissionContext): Instruction {
 	// Get the table schema to access constraints
@@ -16,32 +28,102 @@ export function emitConstraintCheck(plan: ConstraintCheckNode, ctx: EmissionCont
 	// Use the pre-built flat row descriptor from the plan
 	const flatRowDescriptor = plan.flatRowDescriptor;
 
+	// Get mutation context from the plan (passed from DML builders)
+	const mutationContextValues = plan.mutationContextValues;
+	const contextAttributes = plan.contextAttributes;
+	const contextDescriptor = plan.contextDescriptor;
+
+	// Emit mutation context value evaluators if present
+	const contextEvaluatorInstructions: Instruction[] = [];
+	if (mutationContextValues && contextAttributes) {
+		for (const attr of contextAttributes) {
+			const valueExpr = mutationContextValues.get(attr.name);
+			if (valueExpr) {
+				contextEvaluatorInstructions.push(emitCallFromPlan(valueExpr, ctx));
+			}
+		}
+	}
+
 	// Emit evaluator instructions for each pre-built constraint expression
 	const checkEvaluators = plan.constraintChecks.map(check =>
 		emitCallFromPlan(check.expression, ctx)
 	);
 
-	// Extract just the constraint metadata for the runtime checker
-	const constraintMetadata = plan.constraintChecks.map(c => c.constraint);
+	const constraintMetadata: ConstraintMetadataEntry[] = plan.constraintChecks.map((check, idx) => {
+		const evaluatorInstruction = checkEvaluators[idx];
+		const constraintName = check.constraint.name ?? generateDefaultConstraintName(tableSchema, check.constraint);
+		return {
+			schema: check.constraint,
+			flatRowDescriptor: plan.flatRowDescriptor,
+			evaluator: evaluatorInstruction.run,
+			constraintName,
+			shouldDefer: Boolean(check.deferrable || check.initiallyDeferred || check.containsSubquery),
+			baseTable: `${tableSchema.schemaName}.${tableSchema.name}`,
+			contextRow: undefined,
+			contextDescriptor
+		};
+	});
 
 	async function* run(rctx: RuntimeContext, inputRows: AsyncIterable<Row>, ...evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>): AsyncIterable<Row> {
 		if (!inputRows) {
 			return;
 		}
 
-		for await (const inputRow of inputRows) {
-			const flatRow = inputRow;
+		// Evaluate mutation context values once per statement (not per row)
+		let contextRow: Row | undefined;
+		let contextSlot: ReturnType<typeof createRowSlot> | undefined;
+
+		if (contextEvaluatorInstructions.length > 0 && contextDescriptor) {
+			// Split evaluatorFunctions into context evaluators and constraint evaluators
+			const contextEvalFunctions = evaluatorFunctions.slice(0, contextEvaluatorInstructions.length);
+			const constraintEvalFunctions = evaluatorFunctions.slice(contextEvaluatorInstructions.length);
 
-			const result = await withAsyncRowContext(rctx, flatRowDescriptor, () => flatRow, async () => {
-				// Check all constraints that apply to this operation
-				await checkConstraints(rctx, plan, tableSchema, flatRow, constraintMetadata, evaluatorFunctions);
+			// Evaluate all context values
+			contextRow = [];
+			for (const contextEvaluator of contextEvalFunctions) {
+				const value = await contextEvaluator(rctx) as SqlValue;
+				contextRow.push(value);
+			}
 
-				// If all constraints pass, yield the flat row for downstream processing
-				// All downstream operations (INSERT executor, DELETE executor, RETURNING) expect flat rows
-				return flatRow;
+			// Store context row in metadata for deferred constraints
+			constraintMetadata.forEach(meta => {
+				meta.contextRow = contextRow;
 			});
 
-			yield result;
+			// Create a row slot for the mutation context that persists for the whole statement
+			contextSlot = createRowSlot(rctx, contextDescriptor);
+			contextSlot.set(contextRow);
+
+			// Use constraint evaluators for the rest of the function
+			evaluatorFunctions = constraintEvalFunctions;
+		}
+
+		try {
+			for await (const inputRow of inputRows) {
+				const flatRow = inputRow;
+
+				// If we have mutation context, compose it with the flat row for constraint evaluation
+				const combinedRow = contextRow ? [...contextRow, ...flatRow] : flatRow;
+				const combinedDescriptor = contextDescriptor && contextRow
+					? composeCombinedDescriptor(contextDescriptor, flatRowDescriptor)
+					: flatRowDescriptor;
+
+				const result = await withAsyncRowContext(rctx, combinedDescriptor, () => combinedRow, async () => {
+					// Check all constraints that apply to this operation
+					await checkConstraints(rctx, plan, tableSchema, flatRow, constraintMetadata, evaluatorFunctions);
+
+					// If all constraints pass, yield the flat row for downstream processing
+					// All downstream operations (INSERT executor, DELETE executor, RETURNING) expect flat rows
+					return flatRow;
+				});
+
+				yield result;
+			}
+		} finally {
+			// Clean up context slot if we created one
+			if (contextSlot) {
+				contextSlot.close();
+			}
 		}
 	}
 
@@ -49,18 +131,45 @@ export function emitConstraintCheck(plan: ConstraintCheckNode, ctx: EmissionCont
 	const sourceInstruction = emitPlanNode(plan.source, ctx);
 
 	return {
-		params: [sourceInstruction, ...checkEvaluators],
-		run: run as any,
-		note: `constraintCheck(${plan.operation}, ${plan.constraintChecks.length} checks)`
+		params: [sourceInstruction, ...contextEvaluatorInstructions, ...checkEvaluators],
+		run: run as InstructionRun,
+		note: `constraintCheck(${plan.operation}, ${contextEvaluatorInstructions.length} ctx, ${plan.constraintChecks.length} checks)`
 	};
 }
 
+/**
+ * Composes a combined row descriptor that includes both context and flat (OLD/NEW) descriptors.
+ * Context attributes come first, followed by OLD/NEW attributes with offset indices.
+ */
+function composeCombinedDescriptor(contextDescriptor: RowDescriptor, flatRowDescriptor: RowDescriptor): RowDescriptor {
+	const combined: RowDescriptor = [];
+	const contextLength = Object.keys(contextDescriptor).filter(k => contextDescriptor[parseInt(k)] !== undefined).length;
+
+	// Copy context descriptor as-is (indices 0..contextLength-1)
+	for (const attrIdStr in contextDescriptor) {
+		const attrId = parseInt(attrIdStr);
+		if (contextDescriptor[attrId] !== undefined) {
+			combined[attrId] = contextDescriptor[attrId];
+		}
+	}
+
+	// Copy flat descriptor with offset indices (indices contextLength..end)
+	for (const attrIdStr in flatRowDescriptor) {
+		const attrId = parseInt(attrIdStr);
+		if (flatRowDescriptor[attrId] !== undefined) {
+			combined[attrId] = flatRowDescriptor[attrId] + contextLength;
+		}
+	}
+
+	return combined;
+}
+
 async function checkConstraints(
 	rctx: RuntimeContext,
 	plan: ConstraintCheckNode,
 	tableSchema: TableSchema,
 	row: Row,
-	constraintMetadata: Array<RowConstraintSchema>,
+	constraintMetadata: ConstraintMetadataEntry[],
 	evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>
 ): Promise<void> {
 	// Check PRIMARY KEY constraints (UNIQUE constraints on PK columns)
@@ -70,7 +179,7 @@ async function checkConstraints(
 	await checkNotNullConstraints(rctx, plan, tableSchema, row);
 
 	// Check CHECK constraints (both column-level and table-level)
-	await checkCheckConstraints(rctx, plan, tableSchema, constraintMetadata, evaluatorFunctions);
+	await checkCheckConstraints(rctx, plan, tableSchema, row, constraintMetadata, evaluatorFunctions);
 }
 
 async function checkNotNullConstraints(
@@ -82,7 +191,7 @@ async function checkNotNullConstraints(
 	// For INSERT operations, check NOT NULL on NEW values
 	// For UPDATE operations, check NOT NULL on NEW values
 	// DELETE operations don't need NOT NULL checks
-	if (plan.operation === RowOp.DELETE) {
+	if (plan.operation === RowOpFlag.DELETE) {
 		return;
 	}
 
@@ -122,25 +231,38 @@ async function checkCheckConstraints(
 	rctx: RuntimeContext,
 	plan: ConstraintCheckNode,
 	tableSchema: TableSchema,
-	constraintMetadata: Array<RowConstraintSchema>,
+	row: Row,
+	constraintMetadata: ConstraintMetadataEntry[],
 	evaluatorFunctions: Array<(ctx: RuntimeContext) => OutputValue>
 ): Promise<void> {
 	// Evaluate each CHECK constraint using pre-built evaluators
 	for (let i = 0; i < constraintMetadata.length; i++) {
-		const constraint = constraintMetadata[i];
-		const evaluator = evaluatorFunctions[i];
+		const metadata = constraintMetadata[i];
+		const evaluator = evaluatorFunctions[i] ?? metadata.evaluator;
+
+		if (metadata.shouldDefer) {
+			const activeConnectionId = rctx.activeConnection?.connectionId;
+			rctx.db._queueDeferredConstraintRow(
+				metadata.baseTable,
+				metadata.constraintName,
+				row.slice() as Row,
+				metadata.flatRowDescriptor,
+				evaluator,
+				activeConnectionId,
+				metadata.contextRow,
+				metadata.contextDescriptor
+			);
+			continue;
+		}
 
 		try {
-			// Use the evaluator function to get the constraint result
-			const result = evaluator(rctx) as SqlValue;
+			const result = await evaluator(rctx) as SqlValue;
 
 			// CHECK constraint passes if result is truthy or NULL
 			// It fails only if result is false or 0 (SQLite-style numeric boolean)
 			if (result === false || result === 0) {
-				// Generate a proper constraint name if none was provided
-				const constraintName = constraint.name || generateDefaultConstraintName(tableSchema, constraint);
 				throw new QuereusError(
-					`CHECK constraint failed: ${constraintName}`,
+					`CHECK constraint failed: ${metadata.constraintName}`,
 					StatusCode.CONSTRAINT
 				);
 			}

package/src/runtime/emit/create-assertion.ts

@@ -0,0 +1,82 @@
+import type { CreateAssertionNode } from '../../planner/nodes/create-assertion-node.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
+import type { EmissionContext } from '../emission-context.js';
+import { QuereusError } from '../../common/errors.js';
+import { SqlValue, StatusCode } from '../../common/types.js';
+import { createLogger } from '../../common/logger.js';
+import type { IntegrityAssertionSchema, AssertionDependentTable } from '../../schema/assertion.js';
+import { expressionToString } from '../../util/ast-stringify.js';
+
+const log = createLogger('runtime:emit:create-assertion');
+
+export function emitCreateAssertion(plan: CreateAssertionNode, _ctx: EmissionContext): Instruction {
+
+	async function run(rctx: RuntimeContext): Promise<SqlValue> {
+		// Convert the CHECK expression to SQL text for storage
+		// The CHECK expression should be negated to become a violation query:
+		// CHECK (condition) becomes "SELECT 1 WHERE NOT (condition)"
+		let violationSql: string;
+		try {
+			const exprSql = expressionToString(plan.checkExpression);
+			violationSql = `SELECT 1 WHERE NOT (${exprSql})`;
+		} catch (e) {
+			log('Failed to stringify assertion expression: %O', e);
+			// Fallback for complex expressions
+			violationSql = 'SELECT 1 WHERE FALSE'; // Never violates
+		}
+
+		// Create the assertion schema object
+		const assertionSchema: IntegrityAssertionSchema = {
+			name: plan.name,
+			violationSql,
+			deferrable: true, // Auto-deferred for multi-table constraints
+			initiallyDeferred: true,
+			dependentTables: []
+		};
+
+		// Discover dependent base tables (best-effort; conservative if any failure)
+		try {
+			const planNode = rctx.db.getPlan(violationSql);
+			const deps = new Map<string, AssertionDependentTable>();
+			(function collect(node: unknown) {
+				const anyNode = node as any;
+				if (anyNode && typeof anyNode.getRelations === 'function') {
+					for (const child of anyNode.getRelations()) collect(child);
+				}
+				if (anyNode?.tableSchema?.name && anyNode?.id !== undefined) {
+					const base = `${anyNode.tableSchema.schemaName}.${anyNode.tableSchema.name}`.toLowerCase();
+					const relationKey = `${base}#${anyNode.id}`;
+					if (!deps.has(relationKey)) deps.set(relationKey, { relationKey, base });
+				}
+			})(planNode);
+			assertionSchema.dependentTables = Array.from(deps.values());
+			log('Assertion %s dependencies discovered: %o', plan.name, assertionSchema.dependentTables);
+		} catch (depErr) {
+			log('Dependency discovery failed for assertion %s: %O', plan.name, depErr);
+		}
+
+		// Add to schema
+		const schemaManager = rctx.db.schemaManager;
+		const schema = schemaManager.getMainSchema(); // Store in main schema for now
+
+		// Check for existing assertion
+		const existing = schema.getAssertion(plan.name);
+		if (existing) {
+			throw new QuereusError(
+				`Assertion ${plan.name} already exists`,
+				StatusCode.CONSTRAINT
+			);
+		}
+
+		schema.addAssertion(assertionSchema);
+
+		log('Created assertion %s with violationSql: %s', plan.name, violationSql);
+		return null;
+	}
+
+	return {
+		params: [],
+		run: run as InstructionRun,
+		note: `createAssertion(${plan.name})`
+	};
+}

package/src/runtime/emit/cte-reference.ts

@@ -2,7 +2,7 @@ import type { Row } from '../../common/types.js';
 import type { CTEReferenceNode } from '../../planner/nodes/cte-reference-node.js';
 import type { EmissionContext } from '../emission-context.js';
 import { emitPlanNode, createValidatedInstruction } from '../emitters.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
 import { buildRowDescriptor } from '../../util/row-descriptor.js';
 import { withRowContextGenerator } from '../context-helpers.js';
 import { createLogger } from '../../common/logger.js';
@@ -31,7 +31,7 @@ export function emitCTEReference(plan: CTEReferenceNode, ctx: EmissionContext):
 
 	return createValidatedInstruction(
 		[cteInstruction],
-		run as any,
+		run as InstructionRun,
 		ctx,
 		`cte_ref(${plan.source.cteName}${plan.alias ? ` AS ${plan.alias}` : ''})`
 	);

package/src/runtime/emit/cte.ts

@@ -1,5 +1,5 @@
 import type { CTENode } from '../../planner/nodes/cte-node.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
 import type { EmissionContext } from '../emission-context.js';
 import { emitPlanNode } from '../emitters.js';
 import type { Row } from '../../common/types.js';
@@ -33,7 +33,7 @@ export function emitCTE(plan: CTENode, ctx: EmissionContext): Instruction {
 
 	return {
 		params: [queryInstruction],
-		run: run as any,
+		run: run as InstructionRun,
 		note: `cte(${plan.cteName})`
 	};
 }

package/src/runtime/emit/distinct.ts

@@ -1,5 +1,5 @@
 import type { DistinctNode } from '../../planner/nodes/distinct-node.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
 import { emitPlanNode } from '../emitters.js';
 import { type Row } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
@@ -34,7 +34,7 @@ export function emitDistinct(plan: DistinctNode, ctx: EmissionContext): Instruct
 
 	return {
 		params: [sourceInstruction],
-		run: run as any,
+		run: run as InstructionRun,
 		note: 'distinct (btree-optimized)'
 	};
 }

package/src/runtime/emit/dml-executor.ts

@@ -2,8 +2,9 @@ import type { DmlExecutorNode } from '../../planner/nodes/dml-executor-node.js';
 import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
 import { emitPlanNode } from '../emitters.js';
 import { QuereusError } from '../../common/errors.js';
-import { StatusCode, type Row } from '../../common/types.js';
+import { StatusCode, type Row, type SqlValue } from '../../common/types.js';
 import { getVTable, disconnectVTable } from '../utils.js';
+import { ConflictResolution } from '../../common/constants.js';
 import type { EmissionContext } from '../emission-context.js';
 import { extractOldRowFromFlat, extractNewRowFromFlat } from '../../util/row-descriptor.js';
 
@@ -21,8 +22,10 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 		try {
 			for await (const flatRow of rows) {
 				const newRow = extractNewRowFromFlat(flatRow, tableSchema.columns.length);
-				(newRow as any)._onConflict = plan.onConflict || 'abort';
-				await vtab.xUpdate!('insert', newRow);
+				await vtab.xUpdate!('insert', newRow, undefined, plan.onConflict ?? ConflictResolution.ABORT);
+				// Track change (INSERT): record NEW primary key
+				const pkValues = tableSchema.primaryKeyDefinition.map(def => newRow[def.index]);
+				ctx.db._recordInsert(`${tableSchema.schemaName}.${tableSchema.name}`, pkValues);
 				yield flatRow; // make OLD/NEW available downstream (e.g. RETURNING)
 			}
 		} finally {
@@ -39,13 +42,16 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 				const newRow = extractNewRowFromFlat(flatRow, tableSchema.columns.length);
 
 				// Extract primary key values from the OLD row (these identify which row to update)
-				const keyValues = pkColumnIndicesInSchema.map(pkColIdx => {
+				const keyValues: SqlValue[] = pkColumnIndicesInSchema.map(pkColIdx => {
 					if (pkColIdx >= oldRow.length) {
 						throw new QuereusError(`PK column index ${pkColIdx} out of bounds for OLD row length ${oldRow.length} in UPDATE on '${tableSchema.name}'.`, StatusCode.INTERNAL);
 					}
 					return oldRow[pkColIdx];
 				});
-				await vtab.xUpdate!('update', newRow, keyValues);
+				await vtab.xUpdate!('update', newRow, keyValues, ConflictResolution.ABORT);
+				// Track change (UPDATE): record OLD and NEW primary keys
+				const newKeyValues: SqlValue[] = tableSchema.primaryKeyDefinition.map(pkColDef => newRow[pkColDef.index]);
+				ctx.db._recordUpdate(`${tableSchema.schemaName}.${tableSchema.name}`, keyValues, newKeyValues);
 				yield flatRow;
 			}
 		} finally {
@@ -60,13 +66,15 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 			for await (const flatRow of rows) {
 				const oldRow = extractOldRowFromFlat(flatRow, tableSchema.columns.length);
 
-				const keyValues = pkColumnIndicesInSchema.map(pkColIdx => {
+				const keyValues: SqlValue[] = pkColumnIndicesInSchema.map(pkColIdx => {
 					if (pkColIdx >= oldRow.length) {
 						throw new QuereusError(`PK column index ${pkColIdx} out of bounds for OLD row length ${oldRow.length} in DELETE on '${tableSchema.name}'.`, StatusCode.INTERNAL);
 					}
 					return oldRow[pkColIdx];
 				});
-				await vtab.xUpdate!('delete', undefined, keyValues);
+				await vtab.xUpdate!('delete', undefined, keyValues, ConflictResolution.ABORT);
+				// Track change (DELETE): record OLD primary key
+				ctx.db._recordDelete(`${tableSchema.schemaName}.${tableSchema.name}`, keyValues);
 				yield flatRow;
 			}
 		} finally {
@@ -75,11 +83,11 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 	}
 
 	// Select the correct generator based on operation
-	let runFunc: InstructionRun;
+	let run: InstructionRun;
 	switch (plan.operation) {
-		case 'insert': runFunc = runInsert; break;
-		case 'update': runFunc = runUpdate; break;
-		case 'delete': runFunc = runDelete; break;
+		case 'insert': run = runInsert as InstructionRun; break;
+		case 'update': run = runUpdate as InstructionRun; break;
+		case 'delete': run = runDelete as InstructionRun; break;
 		default:
 			throw new QuereusError(`Unknown DML operation: ${plan.operation}`, StatusCode.INTERNAL);
 	}
@@ -88,7 +96,7 @@ export function emitDmlExecutor(plan: DmlExecutorNode, ctx: EmissionContext): In
 
 	return {
 		params: [sourceInstruction],
-		run: runFunc,
+		run,
 		note: `execute${plan.operation}(${plan.table.tableSchema.name})`
 	};
 }

package/src/runtime/emit/drop-assertion.ts

@@ -0,0 +1,45 @@
+import type { DropAssertionNode } from '../../planner/nodes/drop-assertion-node.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
+import type { EmissionContext } from '../emission-context.js';
+import { QuereusError } from '../../common/errors.js';
+import { SqlValue, StatusCode } from '../../common/types.js';
+import { createLogger } from '../../common/logger.js';
+
+const log = createLogger('runtime:emit:drop-assertion');
+
+export function emitDropAssertion(plan: DropAssertionNode, _ctx: EmissionContext): Instruction {
+
+	async function run(rctx: RuntimeContext): Promise<SqlValue> {
+		const schemaManager = rctx.db.schemaManager;
+		const schema = schemaManager.getMainSchema(); // Look in main schema for now
+
+		const existing = schema.getAssertion(plan.name);
+		if (!existing) {
+			if (plan.ifExists) {
+				log('Assertion %s not found, but IF EXISTS specified', plan.name);
+				return null;
+			}
+			throw new QuereusError(
+				`Assertion ${plan.name} not found`,
+				StatusCode.NOTFOUND
+			);
+		}
+
+		const removed = schema.removeAssertion(plan.name);
+		if (!removed && !plan.ifExists) {
+			throw new QuereusError(
+				`Failed to remove assertion ${plan.name}`,
+				StatusCode.INTERNAL
+			);
+		}
+
+		log('Dropped assertion %s', plan.name);
+		return null;
+	}
+
+	return {
+		params: [],
+		run: run as InstructionRun,
+		note: `dropAssertion(${plan.name})`
+	};
+}

package/src/runtime/emit/filter.ts

@@ -1,7 +1,7 @@
 import type { FilterNode } from '../../planner/nodes/filter.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
 import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
-import { type Row } from '../../common/types.js';
+import { OutputValue, type Row } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
 import { buildRowDescriptor } from '../../util/row-descriptor.js';
 import { withRowContextGenerator } from '../context-helpers.js';
@@ -13,7 +13,7 @@ export function emitFilter(plan: FilterNode, ctx: EmissionContext): Instruction
 	// Create row descriptor for source attributes
 	const sourceRowDescriptor = buildRowDescriptor(plan.source.getAttributes());
 
-	async function* run(ctx: RuntimeContext, source: AsyncIterable<Row>, predicate: (ctx: RuntimeContext) => any): AsyncIterable<Row> {
+	async function* run(ctx: RuntimeContext, source: AsyncIterable<Row>, predicate: (ctx: RuntimeContext) => OutputValue): AsyncIterable<Row> {
 		yield* withRowContextGenerator(ctx, sourceRowDescriptor, source, async function* (sourceRow) {
 			const result = await predicate(ctx);
 			if (result) {
@@ -24,7 +24,7 @@ export function emitFilter(plan: FilterNode, ctx: EmissionContext): Instruction
 
 	return {
 		params: [sourceInstruction, predicateFunc],
-		run: run as any,
+		run: run as InstructionRun,
 		note: `filter(${plan.predicate.toString()})`
 	};
 }

package/src/runtime/emit/join.ts

@@ -1,12 +1,13 @@
 import type { JoinNode } from '../../planner/nodes/join-node.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
 import { emitCallFromPlan, emitPlanNode } from '../emitters.js';
-import type { Row } from '../../common/types.js';
+import type { Row, OutputValue } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
 import { createLogger } from '../../common/logger.js';
 import { compareSqlValues } from '../../util/comparison.js';
 import { buildRowDescriptor } from '../../util/row-descriptor.js';
 import { createRowSlot } from '../context-helpers.js';
+import type { Attribute } from '../../planner/nodes/plan-node.js';
 
 const log = createLogger('runtime:emit:join');
 
@@ -23,7 +24,7 @@ export function emitLoopJoin(plan: JoinNode, ctx: EmissionContext): Instruction
 	const rightRowDescriptor = buildRowDescriptor(rightAttributes);
 
 	// NOTE: rightSource must be re-startable (optimizer facilitates through cache node)
-	async function* run(rctx: RuntimeContext, leftSource: AsyncIterable<Row>, rightCallback: (ctx: RuntimeContext) => AsyncIterable<Row>, conditionCallback?: (ctx: RuntimeContext) => any): AsyncIterable<Row> {
+	async function* run(rctx: RuntimeContext, leftSource: AsyncIterable<Row>, rightCallback: (ctx: RuntimeContext) => AsyncIterable<Row>, conditionCallback?: (ctx: RuntimeContext) => OutputValue): AsyncIterable<Row> {
 		const joinType = plan.joinType;
 
 		log('Starting %s join between %d left attrs and %d right attrs',
@@ -106,7 +107,7 @@ export function emitLoopJoin(plan: JoinNode, ctx: EmissionContext): Instruction
 
 	return {
 		params,
-		run: run as any,
+		run: run as InstructionRun,
 		note: `${plan.joinType} join (nested loop)`
 	};
 }
@@ -117,9 +118,9 @@ export function emitLoopJoin(plan: JoinNode, ctx: EmissionContext): Instruction
 function evaluateUsingCondition(
 	leftRow: Row,
 	rightRow: Row,
-	usingColumns: string[],
-	leftAttributes: any[],
-	rightAttributes: any[]
+	usingColumns: readonly string[],
+	leftAttributes: readonly Attribute[],
+	rightAttributes: readonly Attribute[]
 ): boolean {
 	for (const columnName of usingColumns) {
 		const leftColName = columnName.toLowerCase();

package/src/runtime/emit/limit-offset.ts

@@ -1,5 +1,5 @@
 import type { LimitOffsetNode } from '../../planner/nodes/limit-offset.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
 import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
 import { type SqlValue, type Row, MaybePromise } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
@@ -67,7 +67,7 @@ export function emitLimitOffset(plan: LimitOffsetNode, ctx: EmissionContext): In
 
 	return {
 		params,
-		run: run as any,
+		run: run as InstructionRun,
 		note: `limit_offset(${plan.limit ? 'LIMIT' : ''}${plan.limit && plan.offset ? ',' : ''}${plan.offset ? 'OFFSET' : ''})`
 	};
 }

package/src/runtime/emit/pragma.ts

@@ -1,7 +1,7 @@
 import type { EmissionContext } from '../emission-context.js';
 import type { PragmaPlanNode } from '../../planner/nodes/pragma.js';
 import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import type { Row } from '../../common/types.js';
+import type { Row, SqlValue } from '../../common/types.js';
 import { createLogger } from '../../common/logger.js';
 import { QuereusError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
@@ -32,7 +32,7 @@ export function emitPragma(plan: PragmaPlanNode, _ctx: EmissionContext): Instruc
 			log(`PRAGMA ${pragmaName} (reading)`);
 
 			try {
-				const currentValue = rctx.db.getOption(pragmaName);
+				const currentValue = rctx.db.getOption(pragmaName) as SqlValue;
 				log(`Read option ${pragmaName} = ${currentValue}`);
 				// Return as a single-row result with the pragma name as column
 				yield [pragmaName, currentValue];

package/src/runtime/emit/project.ts

@@ -1,5 +1,5 @@
 import type { ProjectNode } from '../../planner/nodes/project-node.js';
-import type { Instruction, RuntimeContext } from '../types.js';
+import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
 import { emitPlanNode, emitCallFromPlan } from '../emitters.js';
 import { type Row } from '../../common/types.js';
 import { type OutputValue } from '../../common/types.js';
@@ -40,7 +40,7 @@ export function emitProject(plan: ProjectNode, ctx: EmissionContext): Instructio
 
 	return {
 		params: [sourceInstruction, ...projectionFuncs],
-		run: run as any,
+		run: run as InstructionRun,
 		note: `project(${plan.projections.length} cols)`
 	};
 }