@quereus/quereus 0.6.2 → 0.6.3

package/src/util/hash.ts

@@ -0,0 +1,90 @@
+/**
+ * Hash and encoding utilities
+ */
+
+/**
+ * Computes FNV-1a hash of a string (64-bit variant)
+ * Returns an 8-byte array representing the hash
+ * 
+ * FNV-1a is a fast, non-cryptographic hash function with good distribution.
+ * See: http://www.isthe.com/chongo/tech/comp/fnv/
+ */
+export function fnv1aHash(str: string): Uint8Array {
+	// FNV-1a 64-bit parameters
+	// Using two 32-bit integers to represent 64-bit hash (JavaScript limitation)
+	let hashHigh = 0xcbf29ce4; // Upper 32 bits of FNV offset basis
+	let hashLow = 0x84222325;  // Lower 32 bits of FNV offset basis
+	
+	const fnvPrimeHigh = 0x00000100; // Upper 32 bits of FNV prime
+	const fnvPrimeLow = 0x000001b3;  // Lower 32 bits of FNV prime
+
+	for (let i = 0; i < str.length; i++) {
+		const charCode = str.charCodeAt(i);
+		
+		// XOR with byte (handle multi-byte characters)
+		hashLow ^= charCode & 0xff;
+		
+		// Multiply by FNV prime (64-bit multiplication using 32-bit parts)
+		const aHigh = hashHigh;
+		const aLow = hashLow;
+		
+		hashLow = (aLow * fnvPrimeLow) >>> 0;
+		hashHigh = (aHigh * fnvPrimeLow + aLow * fnvPrimeHigh + (hashLow / 0x100000000)) >>> 0;
+		hashLow = hashLow >>> 0;
+		
+		// Handle high byte of character if present
+		if (charCode > 0xff) {
+			hashLow ^= (charCode >>> 8) & 0xff;
+			const bHigh = hashHigh;
+			const bLow = hashLow;
+			hashLow = (bLow * fnvPrimeLow) >>> 0;
+			hashHigh = (bHigh * fnvPrimeLow + bLow * fnvPrimeHigh + (hashLow / 0x100000000)) >>> 0;
+			hashLow = hashLow >>> 0;
+		}
+	}
+
+	// Convert to 8-byte array
+	const bytes = new Uint8Array(8);
+	bytes[0] = (hashHigh >>> 24) & 0xff;
+	bytes[1] = (hashHigh >>> 16) & 0xff;
+	bytes[2] = (hashHigh >>> 8) & 0xff;
+	bytes[3] = hashHigh & 0xff;
+	bytes[4] = (hashLow >>> 24) & 0xff;
+	bytes[5] = (hashLow >>> 16) & 0xff;
+	bytes[6] = (hashLow >>> 8) & 0xff;
+	bytes[7] = hashLow & 0xff;
+	
+	return bytes;
+}
+
+/**
+ * Converts a byte array to base64url encoding
+ * (URL-safe base64 without padding: uses - and _ instead of + and /, no = padding)
+ * 
+ * Base64url is defined in RFC 4648 Section 5.
+ */
+export function toBase64Url(bytes: Uint8Array): string {
+	const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+	let result = '';
+	
+	for (let i = 0; i < bytes.length; i += 3) {
+		// Get 3 bytes (24 bits) and convert to 4 base64 characters (6 bits each)
+		const byte1 = bytes[i];
+		const byte2 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+		const byte3 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+		
+		const triplet = (byte1 << 16) | (byte2 << 8) | byte3;
+		
+		result += base64Chars[(triplet >>> 18) & 0x3f];
+		result += base64Chars[(triplet >>> 12) & 0x3f];
+		if (i + 1 < bytes.length) {
+			result += base64Chars[(triplet >>> 6) & 0x3f];
+		}
+		if (i + 2 < bytes.length) {
+			result += base64Chars[triplet & 0x3f];
+		}
+	}
+	
+	return result;
+}
+

package/src/vtab/memory/table.ts

@@ -1,256 +1,256 @@
-import { VirtualTable } from '../table.js';
-import type { AnyVirtualTableModule, SchemaChangeInfo } from '../module.js';
-import type { Database } from '../../core/database.js';
-import type { Row } from '../../common/types.js';
-import { type IndexSchema, type TableSchema } from '../../schema/table.js';
-import { MemoryTableManager } from './layer/manager.js';
-import type { MemoryTableConnection } from './layer/connection.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import type { FilterInfo } from '../filter-info.js';
-import { buildScanPlanFromFilterInfo } from './layer/scan-plan.js';
-import type { ColumnDef as ASTColumnDef } from '../../parser/ast.js'; // Assuming this will be updated for renameColumn
-import { createMemoryTableLoggers } from './utils/logging.js';
-import { safeJsonStringify } from '../../util/serialization.js';
-import type { VirtualTableConnection } from '../connection.js';
-import { MemoryVirtualTableConnection } from './connection.js';
-import type { ConflictResolution } from '../../common/constants.js';
-
-const logger = createMemoryTableLoggers('table');
-
-/**
- * Represents a connection-specific instance of an in-memory table using the layer-based MVCC model.
- * This class acts as a thin wrapper around the shared MemoryTableManager,
- * holding the connection state.
- */
-export class MemoryTable extends VirtualTable {
-	/** @internal The shared manager handling layers, schema, and global state */
-	public readonly manager: MemoryTableManager;
-	/** @internal Connection state specific to this table instance (lazily initialized) */
-	private connection: MemoryTableConnection | null = null;
-
-	/**
-	 * @internal - Use MemoryTableModule.connect or create
-	 * Creates a connection-specific instance linked to a manager.
-	 */
-	constructor(
-		db: Database,
-		module: AnyVirtualTableModule,
-		manager: MemoryTableManager // Pass the shared manager instance
-	) {
-		// Use manager's schema and name for the base class constructor
-		super(db, module, manager.schemaName, manager.tableName);
-		this.manager = manager;
-		// Set the tableSchema directly from the manager's current canonical schema
-		// This ensures the VirtualTable base class has the correct schema reference.
-		this.tableSchema = manager.tableSchema;
-	}
-
-	/** Returns the canonical schema from the manager */
-	getSchema(): TableSchema | undefined {
-		// Always return the potentially updated schema from the manager
-		return this.manager.tableSchema;
-	}
-
-	/** Checks read-only status via the manager */
-	isReadOnly(): boolean {
-		// Access readOnly via a public method on the manager
-		return this.manager.isReadOnly;
-	}
-
-	/** Ensures the connection to the manager is established */
-	private async ensureConnection(): Promise<MemoryTableConnection> {
-		if (!this.connection) {
-			// Check if there's already an active connection for this table in the database
-			const existingConnections = this.db.getConnectionsForTable(this.tableName);
-			if (existingConnections.length > 0 && existingConnections[0] instanceof MemoryVirtualTableConnection) {
-				const memoryVirtualConnection = existingConnections[0] as MemoryVirtualTableConnection;
-				this.connection = memoryVirtualConnection.getMemoryConnection();
-				logger.debugLog(`ensureConnection: Reused existing connection ${this.connection.connectionId} for table ${this.tableName}`);
-			} else {
-				// Establish connection state with the manager upon first use
-				this.connection = this.manager.connect();
-
-				// Create a VirtualTableConnection wrapper and register it with the database
-				const vtabConnection = new MemoryVirtualTableConnection(this.tableName, this.connection);
-				await this.db.registerConnection(vtabConnection);
-
-				logger.debugLog(`ensureConnection: Created and registered new connection ${this.connection.connectionId} for table ${this.tableName}`);
-			}
-		}
-		return this.connection;
-	}
-
-	/** Sets an existing connection for this table instance (for transaction reuse) */
-	setConnection(memoryConnection: MemoryTableConnection): void {
-		logger.debugLog(`Setting connection ${memoryConnection.connectionId} for table ${this.tableName}`);
-		this.connection = memoryConnection;
-	}
-
-	/** Creates a new VirtualTableConnection for transaction support */
-	createConnection(): VirtualTableConnection {
-		const memoryConnection = this.manager.connect();
-		return new MemoryVirtualTableConnection(this.tableName, memoryConnection);
-	}
-
-	/** Gets the current connection if this table maintains one internally */
-	getConnection(): VirtualTableConnection | undefined {
-		if (!this.connection) {
-			return undefined;
-		}
-		return new MemoryVirtualTableConnection(this.tableName, this.connection);
-	}
-
-	// Direct async iteration for query execution
-	async* query(filterInfo: FilterInfo): AsyncIterable<Row> {
-		const conn = await this.ensureConnection();
-		logger.debugLog(`query using connection ${conn.connectionId} (pending: ${conn.pendingTransactionLayer?.getLayerId()}, read: ${conn.readLayer.getLayerId()})`);
-		const currentSchema = this.manager.tableSchema;
-		if (!currentSchema) {
-			logger.error('query', this.tableName, 'Table schema is undefined');
-			return;
-		}
-		const plan = buildScanPlanFromFilterInfo(filterInfo, currentSchema);
-		logger.debugLog(`query invoked for ${this.tableName} with plan: ${safeJsonStringify(plan)}`);
-
-		const startLayer = conn.pendingTransactionLayer ?? conn.readLayer;
-		logger.debugLog(`query reading from layer ${startLayer.getLayerId()}`);
-
-		// Delegate scanning to the manager, which handles layer recursion
-		yield* this.manager.scanLayer(startLayer, plan);
-	}
-
-	// Note: getBestAccessPlan is handled by the MemoryTableModule, not the table instance.
-
-	/** Performs mutation through the connection's transaction layer */
-	async update(
-		operation: 'insert' | 'update' | 'delete',
-		values: Row | undefined,
-		oldKeyValues?: Row,
-		onConflict?: ConflictResolution
-	): Promise<Row | undefined> {
-		const conn = await this.ensureConnection();
-		// Delegate mutation to the manager.
-		// This assumes manager.performMutation will be updated to this signature and logic.
-		return this.manager.performMutation(conn, operation, values, oldKeyValues, onConflict);
-	}
-
-	/** Begins a transaction for this connection */
-	async begin(): Promise<void> {
-		(await this.ensureConnection()).begin();
-	}
-
-	/** Commits this connection's transaction */
-	async commit(): Promise<void> {
-		// Only commit if a connection has actually been established
-		if (this.connection) {
-			await this.connection.commit();
-		}
-	}
-
-	/** Rolls back this connection's transaction */
-	async rollback(): Promise<void> {
-		// Only rollback if a connection has actually been established
-		if (this.connection) {
-			this.connection.rollback();
-		}
-	}
-
-	/** Sync operation (currently no-op for memory table layers) */
-	async sync(): Promise<void> {
-		// This might trigger background collapse in the manager in the future
-		// await this.manager.tryCollapseLayers(); // Optional: trigger collapse on sync?
-		return Promise.resolve();
-	}
-
-	/** Renames the underlying table via the manager */
-	async rename(newName: string): Promise<void> {
-		logger.operation('Rename', this.tableName, { newName });
-		await this.manager.renameTable(newName);
-		// Update this instance's schema reference after rename
-		this.tableSchema = this.manager.tableSchema;
-	}
-
-	// --- Savepoint operations ---
-	async savepoint(savepointIndex: number): Promise<void> {
-		const conn = await this.ensureConnection();
-		conn.createSavepoint(savepointIndex);
-	}
-
-	async release(savepointIndex: number): Promise<void> {
-		if (!this.connection) return; // No connection, no savepoints to release
-		this.connection.releaseSavepoint(savepointIndex);
-	}
-
-	async rollbackTo(savepointIndex: number): Promise<void> {
-		if (!this.connection) return; // No connection, no savepoints to rollback to
-		this.connection.rollbackToSavepoint(savepointIndex);
-	}
-	// --- End Savepoint operations ---
-
-
-	/** Handles schema changes via the manager */
-	async alterSchema(changeInfo: SchemaChangeInfo): Promise<void> {
-		const originalManagerSchema = this.manager.tableSchema; // For potential error recovery
-		try {
-			switch (changeInfo.type) {
-				case 'addColumn':
-					await this.manager.addColumn(changeInfo.columnDef);
-					break;
-				case 'dropColumn':
-					await this.manager.dropColumn(changeInfo.columnName);
-					break;
-				case 'renameColumn':
-					if (!('newColumnDefAst' in changeInfo)) {
-						throw new QuereusError('SchemaChangeInfo for renameColumn missing newColumnDefAst', StatusCode.INTERNAL);
-					}
-					await this.manager.renameColumn(changeInfo.oldName, changeInfo.newColumnDefAst as ASTColumnDef);
-					break;
-				default: {
-					const exhaustiveCheck: never = changeInfo;
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					throw new QuereusError(`Unhandled schema change: ${(exhaustiveCheck as any)?.type}`, StatusCode.INTERNAL);
-				}
-			}
-			this.tableSchema = this.manager.tableSchema; // Refresh local schema ref
-		} catch (e) {
-			logger.error('Schema Change', this.tableName, e);
-			// Manager DDL methods should handle reverting their own BaseLayer schema updates on error.
-			// Refresh local schema ref to ensure it's consistent with manager after potential error/revert.
-			this.tableSchema = originalManagerSchema;
-			// It might be safer for manager DDL to not alter its own this.tableSchema until baseLayer op succeeds.
-			// And if baseLayer op fails, manager DDL reverts baseLayer.tableSchema.
-			// Then here, we always sync from manager: this.tableSchema = this.manager.tableSchema;
-			throw e;
-		}
-	}
-
-	/** Disconnects this connection instance from the manager */
-	async disconnect(): Promise<void> {
-		if (this.connection) {
-			// Manager handles cleanup and potential layer collapse trigger
-			await this.manager.disconnect(this.connection.connectionId);
-			this.connection = null; // Clear connection reference on this instance
-		}
-	}
-
-	// --- Index DDL methods delegate to the manager ---
-	async createIndex(indexSchema: IndexSchema): Promise<void> {
-		logger.operation('Create Index', this.tableName, { indexName: indexSchema.name });
-		await this.manager.createIndex(indexSchema);
-		this.tableSchema = this.manager.tableSchema; // Refresh local schema ref
-	}
-
-	async dropIndex(indexName: string): Promise<void> {
-		logger.operation('Drop Index', this.tableName, { indexName });
-		await this.manager.dropIndex(indexName);
-		// Update schema reference
-		this.tableSchema = this.manager.tableSchema;
-	}
-	// --- End Index DDL methods ---
-}
-
-// Helper function (moved from MemoryTableCursor and adapted)
-// function buildScanPlanInternal(filterInfo: FilterInfo, tableSchema: TableSchema): ScanPlan { ... MOVED ... }
-
-
+import { VirtualTable } from '../table.js';
+import type { AnyVirtualTableModule, SchemaChangeInfo } from '../module.js';
+import type { Database } from '../../core/database.js';
+import type { Row } from '../../common/types.js';
+import { type IndexSchema, type TableSchema } from '../../schema/table.js';
+import { MemoryTableManager } from './layer/manager.js';
+import type { MemoryTableConnection } from './layer/connection.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import type { FilterInfo } from '../filter-info.js';
+import { buildScanPlanFromFilterInfo } from './layer/scan-plan.js';
+import type { ColumnDef as ASTColumnDef } from '../../parser/ast.js'; // Assuming this will be updated for renameColumn
+import { createMemoryTableLoggers } from './utils/logging.js';
+import { safeJsonStringify } from '../../util/serialization.js';
+import type { VirtualTableConnection } from '../connection.js';
+import { MemoryVirtualTableConnection } from './connection.js';
+import type { ConflictResolution } from '../../common/constants.js';
+
+const logger = createMemoryTableLoggers('table');
+
+/**
+ * Represents a connection-specific instance of an in-memory table using the layer-based MVCC model.
+ * This class acts as a thin wrapper around the shared MemoryTableManager,
+ * holding the connection state.
+ */
+export class MemoryTable extends VirtualTable {
+	/** @internal The shared manager handling layers, schema, and global state */
+	public readonly manager: MemoryTableManager;
+	/** @internal Connection state specific to this table instance (lazily initialized) */
+	private connection: MemoryTableConnection | null = null;
+
+	/**
+	 * @internal - Use MemoryTableModule.connect or create
+	 * Creates a connection-specific instance linked to a manager.
+	 */
+	constructor(
+		db: Database,
+		module: AnyVirtualTableModule,
+		manager: MemoryTableManager // Pass the shared manager instance
+	) {
+		// Use manager's schema and name for the base class constructor
+		super(db, module, manager.schemaName, manager.tableName);
+		this.manager = manager;
+		// Set the tableSchema directly from the manager's current canonical schema
+		// This ensures the VirtualTable base class has the correct schema reference.
+		this.tableSchema = manager.tableSchema;
+	}
+
+	/** Returns the canonical schema from the manager */
+	getSchema(): TableSchema | undefined {
+		// Always return the potentially updated schema from the manager
+		return this.manager.tableSchema;
+	}
+
+	/** Checks read-only status via the manager */
+	isReadOnly(): boolean {
+		// Access readOnly via a public method on the manager
+		return this.manager.isReadOnly;
+	}
+
+	/** Ensures the connection to the manager is established */
+	private async ensureConnection(): Promise<MemoryTableConnection> {
+		if (!this.connection) {
+			// Check if there's already an active connection for this table in the database
+			const existingConnections = this.db.getConnectionsForTable(this.tableName);
+			if (existingConnections.length > 0 && existingConnections[0] instanceof MemoryVirtualTableConnection) {
+				const memoryVirtualConnection = existingConnections[0] as MemoryVirtualTableConnection;
+				this.connection = memoryVirtualConnection.getMemoryConnection();
+				logger.debugLog(`ensureConnection: Reused existing connection ${this.connection.connectionId} for table ${this.tableName}`);
+			} else {
+				// Establish connection state with the manager upon first use
+				this.connection = this.manager.connect();
+
+				// Create a VirtualTableConnection wrapper and register it with the database
+				const vtabConnection = new MemoryVirtualTableConnection(this.tableName, this.connection);
+				await this.db.registerConnection(vtabConnection);
+
+				logger.debugLog(`ensureConnection: Created and registered new connection ${this.connection.connectionId} for table ${this.tableName}`);
+			}
+		}
+		return this.connection;
+	}
+
+	/** Sets an existing connection for this table instance (for transaction reuse) */
+	setConnection(memoryConnection: MemoryTableConnection): void {
+		logger.debugLog(`Setting connection ${memoryConnection.connectionId} for table ${this.tableName}`);
+		this.connection = memoryConnection;
+	}
+
+	/** Creates a new VirtualTableConnection for transaction support */
+	createConnection(): VirtualTableConnection {
+		const memoryConnection = this.manager.connect();
+		return new MemoryVirtualTableConnection(this.tableName, memoryConnection);
+	}
+
+	/** Gets the current connection if this table maintains one internally */
+	getConnection(): VirtualTableConnection | undefined {
+		if (!this.connection) {
+			return undefined;
+		}
+		return new MemoryVirtualTableConnection(this.tableName, this.connection);
+	}
+
+	// Direct async iteration for query execution
+	async* query(filterInfo: FilterInfo): AsyncIterable<Row> {
+		const conn = await this.ensureConnection();
+		logger.debugLog(`query using connection ${conn.connectionId} (pending: ${conn.pendingTransactionLayer?.getLayerId()}, read: ${conn.readLayer.getLayerId()})`);
+		const currentSchema = this.manager.tableSchema;
+		if (!currentSchema) {
+			logger.error('query', this.tableName, 'Table schema is undefined');
+			return;
+		}
+		const plan = buildScanPlanFromFilterInfo(filterInfo, currentSchema);
+		logger.debugLog(`query invoked for ${this.tableName} with plan: ${safeJsonStringify(plan)}`);
+
+		const startLayer = conn.pendingTransactionLayer ?? conn.readLayer;
+		logger.debugLog(`query reading from layer ${startLayer.getLayerId()}`);
+
+		// Delegate scanning to the manager, which handles layer recursion
+		yield* this.manager.scanLayer(startLayer, plan);
+	}
+
+	// Note: getBestAccessPlan is handled by the MemoryTableModule, not the table instance.
+
+	/** Performs mutation through the connection's transaction layer */
+	async update(
+		operation: 'insert' | 'update' | 'delete',
+		values: Row | undefined,
+		oldKeyValues?: Row,
+		onConflict?: ConflictResolution
+	): Promise<Row | undefined> {
+		const conn = await this.ensureConnection();
+		// Delegate mutation to the manager.
+		// This assumes manager.performMutation will be updated to this signature and logic.
+		return this.manager.performMutation(conn, operation, values, oldKeyValues, onConflict);
+	}
+
+	/** Begins a transaction for this connection */
+	async begin(): Promise<void> {
+		(await this.ensureConnection()).begin();
+	}
+
+	/** Commits this connection's transaction */
+	async commit(): Promise<void> {
+		// Only commit if a connection has actually been established
+		if (this.connection) {
+			await this.connection.commit();
+		}
+	}
+
+	/** Rolls back this connection's transaction */
+	async rollback(): Promise<void> {
+		// Only rollback if a connection has actually been established
+		if (this.connection) {
+			this.connection.rollback();
+		}
+	}
+
+	/** Sync operation (currently no-op for memory table layers) */
+	async sync(): Promise<void> {
+		// This might trigger background collapse in the manager in the future
+		// await this.manager.tryCollapseLayers(); // Optional: trigger collapse on sync?
+		return Promise.resolve();
+	}
+
+	/** Renames the underlying table via the manager */
+	async rename(newName: string): Promise<void> {
+		logger.operation('Rename', this.tableName, { newName });
+		await this.manager.renameTable(newName);
+		// Update this instance's schema reference after rename
+		this.tableSchema = this.manager.tableSchema;
+	}
+
+	// --- Savepoint operations ---
+	async savepoint(savepointIndex: number): Promise<void> {
+		const conn = await this.ensureConnection();
+		conn.createSavepoint(savepointIndex);
+	}
+
+	async release(savepointIndex: number): Promise<void> {
+		if (!this.connection) return; // No connection, no savepoints to release
+		this.connection.releaseSavepoint(savepointIndex);
+	}
+
+	async rollbackTo(savepointIndex: number): Promise<void> {
+		if (!this.connection) return; // No connection, no savepoints to rollback to
+		this.connection.rollbackToSavepoint(savepointIndex);
+	}
+	// --- End Savepoint operations ---
+
+
+	/** Handles schema changes via the manager */
+	async alterSchema(changeInfo: SchemaChangeInfo): Promise<void> {
+		const originalManagerSchema = this.manager.tableSchema; // For potential error recovery
+		try {
+			switch (changeInfo.type) {
+				case 'addColumn':
+					await this.manager.addColumn(changeInfo.columnDef);
+					break;
+				case 'dropColumn':
+					await this.manager.dropColumn(changeInfo.columnName);
+					break;
+				case 'renameColumn':
+					if (!('newColumnDefAst' in changeInfo)) {
+						throw new QuereusError('SchemaChangeInfo for renameColumn missing newColumnDefAst', StatusCode.INTERNAL);
+					}
+					await this.manager.renameColumn(changeInfo.oldName, changeInfo.newColumnDefAst as ASTColumnDef);
+					break;
+				default: {
+					const exhaustiveCheck: never = changeInfo;
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					throw new QuereusError(`Unhandled schema change: ${(exhaustiveCheck as any)?.type}`, StatusCode.INTERNAL);
+				}
+			}
+			this.tableSchema = this.manager.tableSchema; // Refresh local schema ref
+		} catch (e) {
+			logger.error('Schema Change', this.tableName, e);
+			// Manager DDL methods should handle reverting their own BaseLayer schema updates on error.
+			// Refresh local schema ref to ensure it's consistent with manager after potential error/revert.
+			this.tableSchema = originalManagerSchema;
+			// It might be safer for manager DDL to not alter its own this.tableSchema until baseLayer op succeeds.
+			// And if baseLayer op fails, manager DDL reverts baseLayer.tableSchema.
+			// Then here, we always sync from manager: this.tableSchema = this.manager.tableSchema;
+			throw e;
+		}
+	}
+
+	/** Disconnects this connection instance from the manager */
+	async disconnect(): Promise<void> {
+		if (this.connection) {
+			// Manager handles cleanup and potential layer collapse trigger
+			await this.manager.disconnect(this.connection.connectionId);
+			this.connection = null; // Clear connection reference on this instance
+		}
+	}
+
+	// --- Index DDL methods delegate to the manager ---
+	async createIndex(indexSchema: IndexSchema): Promise<void> {
+		logger.operation('Create Index', this.tableName, { indexName: indexSchema.name });
+		await this.manager.createIndex(indexSchema);
+		this.tableSchema = this.manager.tableSchema; // Refresh local schema ref
+	}
+
+	async dropIndex(indexName: string): Promise<void> {
+		logger.operation('Drop Index', this.tableName, { indexName });
+		await this.manager.dropIndex(indexName);
+		// Update schema reference
+		this.tableSchema = this.manager.tableSchema;
+	}
+	// --- End Index DDL methods ---
+}
+
+// Helper function (moved from MemoryTableCursor and adapted)
+// function buildScanPlanInternal(filterInfo: FilterInfo, tableSchema: TableSchema): ScanPlan { ... MOVED ... }
+
+