@quereus/quereus 0.7.3 → 0.7.5

package/src/runtime/emit/table-valued-function.ts

@@ -1,106 +0,0 @@
-import type { Instruction, InstructionRun, RuntimeContext } from '../types.js';
-import { emitPlanNode, createValidatedInstruction } from '../emitters.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode, type SqlValue, type Row } from '../../common/types.js';
-import type { FunctionSchema, IntegratedTableValuedFunc, TableValuedFunc } from '../../schema/function.js';
-import { isTableValuedFunctionSchema } from '../../schema/function.js';
-import type { EmissionContext } from '../emission-context.js';
-import type { TableFunctionCallNode } from '../../planner/nodes/table-function-call.js';
-import { buildRowDescriptor } from '../../util/row-descriptor.js';
-import { withRowContextGenerator } from '../context-helpers.js';
-
-export function emitTableValuedFunctionCall(plan: TableFunctionCallNode, ctx: EmissionContext): Instruction {
-	const functionName = plan.functionName.toLowerCase();
-	const numArgs = plan.operands.length;
-
-	// Create row descriptor for function output attributes
-	const rowDescriptor = buildRowDescriptor(plan.getAttributes());
-
-	// Look up the function during emission and record the dependency
-	// First try exact argument count, then try variable argument function
-	let functionSchema = ctx.findFunction(functionName, numArgs);
-	if (!functionSchema) {
-		functionSchema = ctx.findFunction(functionName, -1); // Try variable argument function
-	}
-	if (!functionSchema) {
-		throw new QuereusError(`Unknown function: ${functionName}/${numArgs}`, StatusCode.ERROR);
-	}
-	if (!isTableValuedFunctionSchema(functionSchema)) {
-		throw new QuereusError(`Function ${functionName}/${numArgs} is not a table-valued function`, StatusCode.ERROR);
-	}
-
-	// Capture the function key for runtime retrieval (use the actual function's numArgs)
-	const functionKey = `function:${functionName}/${functionSchema.numArgs}`;
-
-	async function* runIntegrated(innerCtx: RuntimeContext, ...args: Array<SqlValue>): AsyncIterable<Row> {
-		// Use the captured function schema instead of doing a fresh lookup
-		const capturedFunction = ctx.getCapturedSchemaObject<FunctionSchema>(functionKey);
-		if (!capturedFunction) {
-			throw new QuereusError(`Function ${functionName}/${numArgs} was not captured during emission`, StatusCode.INTERNAL);
-		}
-
-		if (!isTableValuedFunctionSchema(capturedFunction)) {
-			throw new QuereusError(`Function ${functionName}/${numArgs} is not a table-valued function at runtime`, StatusCode.INTERNAL);
-		}
-
-		try {
-			// Check if this is a database-aware function
-			const result = (capturedFunction.implementation as IntegratedTableValuedFunc)!(innerCtx.db, ...args);
-
-			// Handle both direct AsyncIterable and Promise<AsyncIterable>
-			const iterable = result instanceof Promise ? await result : result;
-
-			yield* withRowContextGenerator(innerCtx, rowDescriptor, iterable, async function* (row) {
-				yield row;
-			});
-		} catch (error: any) {
-			throw new QuereusError(`Table-valued function ${functionName} failed: ${error.message}`, StatusCode.ERROR, error);
-		}
-	}
-
-	async function* run(innerCtx: RuntimeContext, ...args: Array<SqlValue>): AsyncIterable<Row> {
-		// Use the captured function schema instead of doing a fresh lookup
-		const capturedFunction = ctx.getCapturedSchemaObject<FunctionSchema>(functionKey);
-		if (!capturedFunction) {
-			throw new QuereusError(`Function ${functionName}/${functionSchema!.numArgs} was not captured during emission`, StatusCode.INTERNAL);
-		}
-
-		if (!isTableValuedFunctionSchema(capturedFunction)) {
-			throw new QuereusError(`Function ${functionName}/${numArgs} is not a table-valued function at runtime`, StatusCode.INTERNAL);
-		}
-
-		// Validate argument count for variable argument functions
-		if (capturedFunction.numArgs === -1) {
-			// Special validation for known variable argument functions
-			if (functionName === 'json_each' || functionName === 'json_tree') {
-				if (args.length < 1 || args.length > 2) {
-					throw new QuereusError(`${functionName} requires 1 or 2 arguments (jsonSource, [rootPath])`, StatusCode.ERROR);
-				}
-			}
-		}
-
-		try {
-			// Check if this is a database-aware function
-			const result = (capturedFunction.implementation as TableValuedFunc)!(...args);
-
-			// Handle both direct AsyncIterable and Promise<AsyncIterable>
-			const iterable = result instanceof Promise ? await result : result;
-
-			yield* withRowContextGenerator(innerCtx, rowDescriptor, iterable, async function* (row) {
-				yield row;
-			});
-		} catch (error: any) {
-			throw new QuereusError(`Table-valued function ${functionName} failed: ${error.message}`, StatusCode.ERROR, error);
-		}
-	}
-
-	const operandExprs = plan.operands.map(operand => emitPlanNode(operand, ctx));
-	const runFunction = functionSchema.isIntegrated ? runIntegrated : run;
-
-	return createValidatedInstruction(
-		[...operandExprs],
-		runFunction as InstructionRun,
-		ctx,
-		`TVF:${plan.functionName}(${plan.operands.length})`
-	);
-}

package/src/runtime/emit/temporal-arithmetic.ts

@@ -1,302 +0,0 @@
-import { StatusCode } from "../../common/types.js";
-import { QuereusError } from "../../common/errors.js";
-import type { SqlValue } from "../../common/types.js";
-import type { Instruction, InstructionRun, RuntimeContext } from "../types.js";
-import type { BinaryOpNode } from "../../planner/nodes/scalar.js";
-import { emitPlanNode } from "../emitters.js";
-import type { EmissionContext } from "../emission-context.js";
-import { Temporal } from 'temporal-polyfill';
-import { TIMESPAN_TYPE } from "../../types/temporal-types.js";
-
-/**
- * Check if a value is a date string (YYYY-MM-DD format)
- */
-function isDateValue(v: SqlValue): boolean {
-	if (typeof v !== 'string') return false;
-	// Simple check for ISO 8601 date format
-	return /^\d{4}-\d{2}-\d{2}$/.test(v);
-}
-
-/**
- * Check if a value is a time string (HH:MM:SS format)
- */
-function isTimeValue(v: SqlValue): boolean {
-	if (typeof v !== 'string') return false;
-	// Simple check for ISO 8601 time format
-	return /^\d{2}:\d{2}:\d{2}/.test(v);
-}
-
-/**
- * Check if a value is a datetime string (ISO 8601 format)
- */
-function isDateTimeValue(v: SqlValue): boolean {
-	if (typeof v !== 'string') return false;
-	// Check for ISO 8601 datetime format (with T separator)
-	return v.includes('T') && /^\d{4}-\d{2}-\d{2}T/.test(v);
-}
-
-/**
- * Check if a value is a timespan/duration string (ISO 8601 duration format)
- */
-function isTimespanValue(v: SqlValue): boolean {
-	if (typeof v !== 'string') return false;
-	// ISO 8601 duration starts with P (or -P for negative)
-	return v.startsWith('P') || v.startsWith('-P');
-}
-
-/**
- * Try to perform temporal arithmetic on two values.
- * Returns the result if successful, or undefined if the values are not temporal types.
- * Throws QuereusError if the operation is invalid.
- */
-export function tryTemporalArithmetic(operator: string, v1: SqlValue, v2: SqlValue): SqlValue | undefined {
-		if (v1 === null || v2 === null) return null;
-
-		// Detect types at runtime
-		const isV1Date = isDateValue(v1);
-		const isV1Time = isTimeValue(v1);
-		const isV1DateTime = isDateTimeValue(v1);
-		const isV1Timespan = isTimespanValue(v1);
-
-		const isV2Date = isDateValue(v2);
-		const isV2Time = isTimeValue(v2);
-		const isV2DateTime = isDateTimeValue(v2);
-		const isV2Timespan = isTimespanValue(v2);
-
-		// If neither operand is temporal, return undefined to signal non-temporal operation
-		const isV1Temporal = isV1Date || isV1Time || isV1DateTime || isV1Timespan;
-		const isV2Temporal = isV2Date || isV2Time || isV2DateTime || isV2Timespan;
-		if (!isV1Temporal && !isV2Temporal) {
-			return undefined;
-		}
-
-		try {
-
-			// DATE/DATETIME - DATE/DATETIME → TIMESPAN
-			if (operator === '-' &&
-				(isV1Date || isV1DateTime) &&
-				(isV2Date || isV2DateTime)) {
-
-				// Parse both values as dates
-				const date1 = isV1DateTime
-					? Temporal.PlainDateTime.from(v1 as string).toPlainDate()
-					: Temporal.PlainDate.from(v1 as string);
-				const date2 = isV2DateTime
-					? Temporal.PlainDateTime.from(v2 as string).toPlainDate()
-					: Temporal.PlainDate.from(v2 as string);
-
-				const duration = date1.since(date2);
-				return duration.toString();
-			}
-
-			// TIME - TIME → TIMESPAN
-			if (operator === '-' && isV1Time && isV2Time) {
-				const time1 = Temporal.PlainTime.from(v1 as string);
-				const time2 = Temporal.PlainTime.from(v2 as string);
-				const duration = time1.since(time2);
-				return duration.toString();
-			}
-
-			// DATE + TIMESPAN → DATE
-			if (operator === '+' && isV1Date && isV2Timespan) {
-				const date = Temporal.PlainDate.from(v1 as string);
-				const duration = Temporal.Duration.from(v2 as string);
-				const result = date.add(duration);
-				return result.toString();
-			}
-
-			// TIMESPAN + DATE → DATE (commutative)
-			if (operator === '+' && isV1Timespan && isV2Date) {
-				const duration = Temporal.Duration.from(v1 as string);
-				const date = Temporal.PlainDate.from(v2 as string);
-				const result = date.add(duration);
-				return result.toString();
-			}
-
-			// DATE - TIMESPAN → DATE
-			if (operator === '-' && isV1Date && isV2Timespan) {
-				const date = Temporal.PlainDate.from(v1 as string);
-				const duration = Temporal.Duration.from(v2 as string);
-				const result = date.subtract(duration);
-				return result.toString();
-			}
-
-			// DATETIME + TIMESPAN → DATETIME
-			if (operator === '+' && isV1DateTime && isV2Timespan) {
-				const dt = Temporal.PlainDateTime.from(v1 as string);
-				const duration = Temporal.Duration.from(v2 as string);
-				const result = dt.add(duration);
-				return result.toString();
-			}
-
-			// TIMESPAN + DATETIME → DATETIME (commutative)
-			if (operator === '+' && isV1Timespan && isV2DateTime) {
-				const duration = Temporal.Duration.from(v1 as string);
-				const dt = Temporal.PlainDateTime.from(v2 as string);
-				const result = dt.add(duration);
-				return result.toString();
-			}
-
-			// DATETIME - TIMESPAN → DATETIME
-			if (operator === '-' && isV1DateTime && isV2Timespan) {
-				const dt = Temporal.PlainDateTime.from(v1 as string);
-				const duration = Temporal.Duration.from(v2 as string);
-				const result = dt.subtract(duration);
-				return result.toString();
-			}
-
-			// TIME + TIMESPAN → TIME
-			if (operator === '+' && isV1Time && isV2Timespan) {
-				const time = Temporal.PlainTime.from(v1 as string);
-				const duration = Temporal.Duration.from(v2 as string);
-				const result = time.add(duration);
-				return result.toString();
-			}
-
-			// TIMESPAN + TIME → TIME (commutative)
-			if (operator === '+' && isV1Timespan && isV2Time) {
-				const duration = Temporal.Duration.from(v1 as string);
-				const time = Temporal.PlainTime.from(v2 as string);
-				const result = time.add(duration);
-				return result.toString();
-			}
-
-			// TIME - TIMESPAN → TIME
-			if (operator === '-' && isV1Time && isV2Timespan) {
-				const time = Temporal.PlainTime.from(v1 as string);
-				const duration = Temporal.Duration.from(v2 as string);
-				const result = time.subtract(duration);
-				return result.toString();
-			}
-
-			// TIMESPAN + TIMESPAN → TIMESPAN
-			if (operator === '+' && isV1Timespan && isV2Timespan) {
-				const d1 = Temporal.Duration.from(v1 as string);
-				const d2 = Temporal.Duration.from(v2 as string);
-				const result = d1.add(d2);
-				return result.toString();
-			}
-
-			// TIMESPAN - TIMESPAN → TIMESPAN
-			if (operator === '-' && isV1Timespan && isV2Timespan) {
-				const d1 = Temporal.Duration.from(v1 as string);
-				const d2 = Temporal.Duration.from(v2 as string);
-				const result = d1.subtract(d2);
-				return result.toString();
-			}
-
-			// TIMESPAN * NUMBER → TIMESPAN
-			if (operator === '*' && isV1Timespan && typeof v2 === 'number') {
-				const duration = Temporal.Duration.from(v1 as string);
-				// Convert to seconds, multiply, convert back
-				const totalSeconds = duration.total({ unit: 'seconds' });
-				const newDuration = Temporal.Duration.from({ seconds: totalSeconds * v2 });
-				return newDuration.toString();
-			}
-
-			// NUMBER * TIMESPAN → TIMESPAN (commutative)
-			if (operator === '*' && typeof v1 === 'number' && isV2Timespan) {
-				const duration = Temporal.Duration.from(v2 as string);
-				const totalSeconds = duration.total({ unit: 'seconds' });
-				const newDuration = Temporal.Duration.from({ seconds: totalSeconds * v1 });
-				return newDuration.toString();
-			}
-
-			// TIMESPAN / NUMBER → TIMESPAN
-			if (operator === '/' && isV1Timespan && typeof v2 === 'number') {
-				if (v2 === 0) return null;
-				const duration = Temporal.Duration.from(v1 as string);
-				const totalSeconds = duration.total({ unit: 'seconds' });
-				const newDuration = Temporal.Duration.from({ seconds: totalSeconds / v2 });
-				return newDuration.toString();
-			}
-
-			// TIMESPAN / TIMESPAN → NUMBER (ratio)
-			if (operator === '/' && isV1Timespan && isV2Timespan) {
-				const d1 = Temporal.Duration.from(v1 as string);
-				const d2 = Temporal.Duration.from(v2 as string);
-				const total1 = d1.total({ unit: 'seconds' });
-				const total2 = d2.total({ unit: 'seconds' });
-				if (total2 === 0) return null;
-				return total1 / total2;
-			}
-
-			// If we get here, the operation is not supported
-			throw new QuereusError(
-				`Unsupported temporal operation`,
-				StatusCode.UNSUPPORTED
-			);
-		} catch (e) {
-			// Invalid temporal operation - return null
-			if (e instanceof QuereusError) throw e;
-			return null;
-		}
-}
-
-/**
- * Emit temporal arithmetic operations
- * Handles operations between temporal types (DATE, TIME, DATETIME, TIMESPAN)
- */
-export function emitTemporalArithmetic(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	const operator = plan.expression.operator;
-
-	function run(ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue {
-		return tryTemporalArithmetic(operator, v1, v2) ?? null;
-	}
-
-	const leftExpr = emitPlanNode(plan.left, ctx);
-	const rightExpr = emitPlanNode(plan.right, ctx);
-
-	return {
-		params: [leftExpr, rightExpr],
-		run: run as InstructionRun,
-		note: `${operator}(temporal)`
-	};
-}
-
-/**
- * Attempts to perform temporal comparison. Returns undefined if not a temporal comparison.
- * This allows the caller to fall back to standard comparison logic.
- *
- * Temporal types that need special comparison logic (beyond lexicographic string comparison):
- * - TIMESPAN: Durations need to be compared semantically, not lexicographically
- *   (e.g., "PT30M" > "PT1H" lexicographically, but 30 minutes < 1 hour semantically)
- *
- * Note: DATE, TIME, and DATETIME use ISO 8601 format which compares correctly lexicographically,
- * so they don't need special handling here.
- *
- * @param operator The comparison operator (=, !=, <, <=, >, >=)
- * @param v1 First value
- * @param v2 Second value
- * @returns Comparison result (boolean) if temporal comparison, undefined otherwise
- */
-export function tryTemporalComparison(operator: string, v1: SqlValue, v2: SqlValue): SqlValue | undefined {
-	// Check if both values are timespans
-	// Timespans are the only temporal type that needs special comparison logic
-	// because ISO 8601 duration strings don't compare correctly lexicographically
-	if (!isTimespanValue(v1) || !isTimespanValue(v2)) {
-		return undefined;
-	}
-
-	// Use the TIMESPAN_TYPE's compare function
-	const cmp = TIMESPAN_TYPE.compare!(v1, v2);
-
-	switch (operator) {
-		case '=':
-		case '==':
-			return cmp === 0;
-		case '!=':
-		case '<>':
-			return cmp !== 0;
-		case '<':
-			return cmp < 0;
-		case '<=':
-			return cmp <= 0;
-		case '>':
-			return cmp > 0;
-		case '>=':
-			return cmp >= 0;
-		default:
-			return undefined;
-	}
-}

package/src/runtime/emit/transaction.ts

@@ -1,205 +0,0 @@
-import type { EmissionContext } from '../emission-context.js';
-import type { TransactionNode } from '../../planner/nodes/transaction-node.js';
-import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
-import type { SqlValue } from '../../common/types.js';
-import { createLogger } from '../../common/logger.js';
-import { quereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-
-const log = createLogger('runtime:emit:transaction');
-
-// Simple hash function to convert savepoint names to indices
-function hashSavepointName(name: string): number {
-	let hash = 0;
-	for (let i = 0; i < name.length; i++) {
-		const char = name.charCodeAt(i);
-		hash = ((hash << 5) - hash) + char;
-		hash = hash & hash; // Convert to 32-bit integer
-	}
-	return Math.abs(hash);
-}
-
-export function emitTransaction(plan: TransactionNode, _ctx: EmissionContext): Instruction {
-	// Select the operation function at emit time
-	let run: (ctx: RuntimeContext) => Promise<SqlValue | undefined>;
-	let note: string;
-
-	switch (plan.operation) {
-		case 'begin': {
-			run = async (rctx: RuntimeContext) => {
-				const connections = rctx.db.getAllConnections();
-				log(`BEGIN: Found ${connections.length} active connections`);
-
-				for (const connection of connections) {
-					try {
-						await connection.begin();
-						log(`BEGIN: Successfully called on connection ${connection.connectionId}`);
-					} catch (error) {
-						log(`BEGIN: Error on connection ${connection.connectionId}: %O`, error);
-						throw error;
-					}
-				}
-				// Reflect explicit transaction state in Database
-				rctx.db.markExplicitTransactionStart();
-				// Reset any prior change tracking at the start of an explicit transaction
-				rctx.db._clearChangeLog();
-				return null;
-			};
-			note = 'BEGIN';
-			break;
-		}
-		case 'commit': {
-			run = async (rctx: RuntimeContext) => {
-				// Snapshot connections before evaluating deferred constraints
-				// (constraint evaluation may open additional connections that shouldn't be committed)
-				const connectionsToCommit = rctx.db.getAllConnections();
-				log(`COMMIT: Found ${connectionsToCommit.length} active connections`);
-
-				try {
-					// Evaluate global assertions and deferred row-level constraints BEFORE committing connections.
-					await rctx.db.runGlobalAssertions();
-					await rctx.db.runDeferredRowConstraints();
-
-					// Mark coordinated commit to relax layer validation for sibling layers
-					rctx.db._beginCoordinatedCommit();
-					try {
-						// Commit sequentially to avoid race conditions with layer promotion
-						for (const connection of connectionsToCommit) {
-							try {
-								await connection.commit();
-								log(`COMMIT: Successfully called on connection ${connection.connectionId}`);
-							} catch (error) {
-								log(`COMMIT: Error on connection ${connection.connectionId}: %O`, error);
-								throw error;
-							}
-						}
-					} finally {
-						rctx.db._endCoordinatedCommit();
-					}
-				} catch (e) {
-					// If assertions fail (or a commit throws), rollback all connections
-					await Promise.allSettled(rctx.db.getAllConnections().map(c => c.rollback()));
-					throw e;
-				} finally {
-					// Always mark end of explicit transaction and clear change tracking
-					rctx.db.markExplicitTransactionEnd();
-					rctx.db._clearChangeLog();
-				}
-				return null;
-			};
-			note = 'COMMIT';
-			break;
-		}
-
-		case 'rollback': {
-			if (plan.savepoint) {
-				const savepointIndex = hashSavepointName(plan.savepoint); // Convert name to index
-				run = async (rctx: RuntimeContext) => {
-					const connections = rctx.db.getAllConnections();
-					log(`ROLLBACK TO SAVEPOINT ${savepointIndex}: Found ${connections.length} active connections`);
-
-					for (const connection of connections) {
-						try {
-							await connection.rollbackToSavepoint(savepointIndex);
-							log(`ROLLBACK TO SAVEPOINT ${savepointIndex}: Successfully called on connection ${connection.connectionId}`);
-						} catch (error) {
-							log(`ROLLBACK TO SAVEPOINT ${savepointIndex}: Error on connection ${connection.connectionId}: %O`, error);
-							throw error;
-						}
-					}
-					// Discard top change layer
-					rctx.db._rollbackSavepointLayer();
-					return null;
-				};
-				note = `ROLLBACK TO SAVEPOINT ${plan.savepoint}`;
-			} else {
-				run = async (rctx: RuntimeContext) => {
-					const connections = rctx.db.getAllConnections();
-					log(`ROLLBACK: Found ${connections.length} active connections`);
-
-					for (const connection of connections) {
-						try {
-							await connection.rollback();
-							log(`ROLLBACK: Successfully called on connection ${connection.connectionId}`);
-						} catch (error) {
-							log(`ROLLBACK: Error on connection ${connection.connectionId}: %O`, error);
-							throw error;
-						}
-					}
-					// Reflect explicit transaction end and clear change tracking
-					rctx.db.markExplicitTransactionEnd();
-					rctx.db._clearChangeLog();
-					return null;
-				};
-				note = 'ROLLBACK';
-			}
-			break;
-		}
-
-		case 'savepoint': {
-			if (!plan.savepoint) {
-				quereusError('Savepoint name is required for SAVEPOINT operation', StatusCode.MISUSE);
-			}
-			const savepointIndex = hashSavepointName(plan.savepoint); // Convert name to index
-			run = async (rctx: RuntimeContext) => {
-				const connections = rctx.db.getAllConnections();
-				log(`SAVEPOINT ${savepointIndex}: Found ${connections.length} active connections`);
-
-				for (const connection of connections) {
-					try {
-						await connection.createSavepoint(savepointIndex);
-						log(`SAVEPOINT ${savepointIndex}: Successfully called on connection ${connection.connectionId}`);
-					} catch (error) {
-						log(`SAVEPOINT ${savepointIndex}: Error on connection ${connection.connectionId}: %O`, error);
-						throw error;
-					}
-				}
-				// Mark database as in explicit transaction (savepoints require explicit transaction context)
-				rctx.db.markExplicitTransactionStart();
-				// Track change layer
-				rctx.db._beginSavepointLayer();
-				return null;
-			};
-			note = `SAVEPOINT ${plan.savepoint}`;
-			break;
-		}
-
-		case 'release': {
-			if (!plan.savepoint) {
-				quereusError('Savepoint name is required for RELEASE operation', StatusCode.MISUSE);
-			}
-			const releaseSavepointIndex = hashSavepointName(plan.savepoint); // Convert name to index
-			run = async (rctx: RuntimeContext) => {
-				const connections = rctx.db.getAllConnections();
-				log(`RELEASE SAVEPOINT ${releaseSavepointIndex}: Found ${connections.length} active connections`);
-
-				for (const connection of connections) {
-					try {
-						await connection.releaseSavepoint(releaseSavepointIndex);
-						log(`RELEASE SAVEPOINT ${releaseSavepointIndex}: Successfully called on connection ${connection.connectionId}`);
-					} catch (error) {
-						log(`RELEASE SAVEPOINT ${releaseSavepointIndex}: Error on connection ${connection.connectionId}: %O`, error);
-						throw error;
-					}
-				}
-				// Merge top change layer into below
-				rctx.db._releaseSavepointLayer();
-				return null;
-			};
-			note = `RELEASE SAVEPOINT ${plan.savepoint}`;
-			break;
-		}
-
-		default:
-			quereusError(
-				`Unsupported transaction operation: ${plan.operation}`,
-				StatusCode.UNSUPPORTED
-			);
-	}
-
-	return {
-		params: [],
-		run: run as InstructionRun,
-		note
-	};
-}