syncorejs 0.2.1 → 0.2.2

package/dist/_vendor/core/runtime/internal/engines/executionEngine.mjs

@@ -0,0 +1,617 @@
+import { toCanonicalComponentFunctionName } from "../../components.mjs";
+import { generateId } from "../../id.mjs";
+import { fieldExpression, normalizeOptionalArgs, omitSystemFields, quoteIdentifier, resolveSearchIndexTableName, splitSchedulerArgs, stableStringify } from "./shared.mjs";
+import { createEmptyExecutionResult } from "../transactionCoordinator.mjs";
+//#region src/runtime/internal/engines/executionEngine.ts
+const DEFAULT_MISFIRE_POLICY = { type: "catch_up" };
+var RuntimeFilterBuilder = class {
+	eq(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: "=",
+				value
+			}
+		};
+	}
+	gt(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: ">",
+				value
+			}
+		};
+	}
+	gte(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: ">=",
+				value
+			}
+		};
+	}
+	lt(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: "<",
+				value
+			}
+		};
+	}
+	lte(field, value) {
+		return {
+			type: "condition",
+			condition: {
+				field,
+				operator: "<=",
+				value
+			}
+		};
+	}
+	and(...expressions) {
+		return {
+			type: "and",
+			expressions
+		};
+	}
+	or(...expressions) {
+		return {
+			type: "or",
+			expressions
+		};
+	}
+};
+var RuntimeIndexRangeBuilder = class {
+	conditions = [];
+	eq(field, value) {
+		this.conditions.push({
+			field,
+			operator: "=",
+			value
+		});
+		return this;
+	}
+	gt(field, value) {
+		this.conditions.push({
+			field,
+			operator: ">",
+			value
+		});
+		return this;
+	}
+	gte(field, value) {
+		this.conditions.push({
+			field,
+			operator: ">=",
+			value
+		});
+		return this;
+	}
+	lt(field, value) {
+		this.conditions.push({
+			field,
+			operator: "<",
+			value
+		});
+		return this;
+	}
+	lte(field, value) {
+		this.conditions.push({
+			field,
+			operator: "<=",
+			value
+		});
+		return this;
+	}
+	build() {
+		return [...this.conditions];
+	}
+};
+var RuntimeSearchIndexBuilder = class {
+	searchField;
+	searchText;
+	filters = [];
+	search(field, value) {
+		this.searchField = field;
+		this.searchText = value;
+		return this;
+	}
+	eq(field, value) {
+		this.filters.push({
+			field,
+			operator: "=",
+			value
+		});
+		return this;
+	}
+	build() {
+		if (!this.searchField || !this.searchText) throw new Error("Search queries require a search field and search text.");
+		return {
+			searchField: this.searchField,
+			searchText: this.searchText,
+			filters: [...this.filters]
+		};
+	}
+};
+var RuntimeQueryBuilder = class {
+	orderDirection = "asc";
+	source = { type: "table" };
+	filterExpression;
+	constructor(executeQuery, tableName, dependencyCollector) {
+		this.executeQuery = executeQuery;
+		this.tableName = tableName;
+		this.dependencyCollector = dependencyCollector;
+	}
+	withIndex(indexName, builder) {
+		this.source = {
+			type: "index",
+			name: indexName,
+			range: builder?.(new RuntimeIndexRangeBuilder()).build() ?? []
+		};
+		return this;
+	}
+	withSearchIndex(indexName, builder) {
+		this.source = {
+			type: "search",
+			name: indexName,
+			query: builder(new RuntimeSearchIndexBuilder()).build()
+		};
+		return this;
+	}
+	order(order) {
+		this.orderDirection = order;
+		return this;
+	}
+	filter(builder) {
+		this.filterExpression = builder(new RuntimeFilterBuilder());
+		return this;
+	}
+	async collect() {
+		return this.execute();
+	}
+	async take(count) {
+		return this.execute({ limit: count });
+	}
+	async first() {
+		return (await this.execute({ limit: 1 }))[0] ?? null;
+	}
+	async unique() {
+		const results = await this.execute({ limit: 2 });
+		if (results.length > 1) throw new Error("Expected a unique result but found multiple rows.");
+		return results[0] ?? null;
+	}
+	async paginate(options) {
+		const offset = options.cursor ? Number.parseInt(options.cursor, 10) : 0;
+		const page = await this.execute({
+			limit: options.numItems,
+			offset
+		});
+		const nextCursor = page.length < options.numItems ? null : String(offset + page.length);
+		return {
+			page,
+			cursor: nextCursor,
+			isDone: nextCursor === null
+		};
+	}
+	async execute(options) {
+		this.dependencyCollector?.add(`table:${this.tableName}`);
+		const queryOptions = {
+			tableName: this.tableName,
+			source: this.source,
+			filterExpression: this.filterExpression,
+			orderDirection: this.orderDirection
+		};
+		if (this.dependencyCollector) queryOptions.dependencyCollector = this.dependencyCollector;
+		if (options?.limit !== void 0) queryOptions.limit = options.limit;
+		if (options?.offset !== void 0) queryOptions.offset = options.offset;
+		return this.executeQuery(queryOptions);
+	}
+};
+var ExecutionEngine = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	createClient() {
+		return {
+			query: (reference, ...args) => this.runQuery(reference, normalizeOptionalArgs(args)),
+			mutation: (reference, ...args) => this.runMutation(reference, normalizeOptionalArgs(args)),
+			action: (reference, ...args) => this.runAction(reference, normalizeOptionalArgs(args)),
+			watchQuery: (reference, ...args) => this.watchQuery(reference, normalizeOptionalArgs(args)),
+			watchRuntimeStatus: () => this.deps.runtimeStatus.watch()
+		};
+	}
+	watchQuery(reference, args = {}) {
+		return this.deps.reactivity.watchQuery(reference, args);
+	}
+	async runQuery(reference, args = {}, meta = {}) {
+		const definition = this.resolveFunction(reference, "query");
+		const dependencyCollector = /* @__PURE__ */ new Set();
+		const startedAt = Date.now();
+		const result = await this.invokeFunction(definition, args, {
+			mutationDepth: 0,
+			changedTables: /* @__PURE__ */ new Set(),
+			storageChanges: [],
+			dependencyCollector,
+			componentMetadata: definition.__syncoreComponent
+		});
+		this.deps.devtools.emit({
+			type: "query.executed",
+			runtimeId: this.deps.runtimeId,
+			queryId: reference.name,
+			functionName: reference.name,
+			...definition.__syncoreComponent ? {
+				componentPath: definition.__syncoreComponent.componentPath,
+				componentName: definition.__syncoreComponent.componentName
+			} : {},
+			dependencies: [...dependencyCollector],
+			durationMs: Date.now() - startedAt,
+			timestamp: Date.now(),
+			...meta.origin ? { origin: meta.origin } : {}
+		});
+		return result;
+	}
+	async runMutation(reference, args = {}, meta = {}) {
+		const definition = this.resolveFunction(reference, "mutation");
+		const mutationId = generateId();
+		const startedAt = Date.now();
+		const execution = await this.deps.transactionCoordinator.runInTransaction(async (transactionState) => this.invokeFunction(definition, args, {
+			mutationDepth: 1,
+			changedTables: transactionState.changedTables,
+			storageChanges: transactionState.storageChanges,
+			componentMetadata: definition.__syncoreComponent
+		}));
+		await this.finalizeStatefulExecution(mutationId, execution, Date.now() - startedAt);
+		this.deps.devtools.emit({
+			type: "mutation.committed",
+			runtimeId: this.deps.runtimeId,
+			mutationId,
+			functionName: reference.name,
+			...definition.__syncoreComponent ? {
+				componentPath: definition.__syncoreComponent.componentPath,
+				componentName: definition.__syncoreComponent.componentName
+			} : {},
+			changedTables: [...execution.changedTables],
+			durationMs: Date.now() - startedAt,
+			timestamp: Date.now(),
+			...meta.origin ? { origin: meta.origin } : {}
+		});
+		return execution.result;
+	}
+	async runAction(reference, args = {}, meta = {}) {
+		const definition = this.resolveFunction(reference, "action");
+		const actionId = generateId();
+		const startedAt = Date.now();
+		const state = this.deps.transactionCoordinator.createState();
+		try {
+			const result = await this.invokeFunction(definition, args, {
+				mutationDepth: 0,
+				changedTables: state.changedTables,
+				storageChanges: state.storageChanges,
+				componentMetadata: definition.__syncoreComponent
+			});
+			await this.finalizeStatefulExecution(actionId, createEmptyExecutionResult(result, state), Date.now() - startedAt);
+			this.deps.devtools.emit({
+				type: "action.completed",
+				runtimeId: this.deps.runtimeId,
+				actionId,
+				functionName: reference.name,
+				...definition.__syncoreComponent ? {
+					componentPath: definition.__syncoreComponent.componentPath,
+					componentName: definition.__syncoreComponent.componentName
+				} : {},
+				durationMs: Date.now() - startedAt,
+				timestamp: Date.now(),
+				...meta.origin ? { origin: meta.origin } : {}
+			});
+			return result;
+		} catch (error) {
+			this.deps.devtools.emit({
+				type: "action.completed",
+				runtimeId: this.deps.runtimeId,
+				actionId,
+				functionName: reference.name,
+				...definition.__syncoreComponent ? {
+					componentPath: definition.__syncoreComponent.componentPath,
+					componentName: definition.__syncoreComponent.componentName
+				} : {},
+				durationMs: Date.now() - startedAt,
+				timestamp: Date.now(),
+				...meta.origin ? { origin: meta.origin } : {},
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw error;
+		}
+	}
+	async runDevtoolsMutation(callback, meta = {}) {
+		const mutationId = generateId();
+		const startedAt = Date.now();
+		const execution = await this.deps.transactionCoordinator.runInTransaction(async (transactionState) => callback({ db: this.createDatabaseWriter({
+			mutationDepth: 1,
+			changedTables: transactionState.changedTables,
+			storageChanges: transactionState.storageChanges
+		}) }));
+		await this.finalizeStatefulExecution(mutationId, execution, Date.now() - startedAt);
+		this.deps.devtools.emit({
+			type: "mutation.committed",
+			runtimeId: this.deps.runtimeId,
+			mutationId,
+			functionName: "__devtools__/mutation",
+			changedTables: [...execution.changedTables],
+			durationMs: Date.now() - startedAt,
+			timestamp: Date.now(),
+			...meta.origin ? { origin: meta.origin } : {}
+		});
+		return execution.result;
+	}
+	async finalizeStatefulExecution(executionId, execution, durationMs) {
+		const changedScopes = collectChangedScopes(execution.changedTables, execution.storageChanges);
+		if (changedScopes.size > 0) await this.deps.reactivity.refreshQueriesForScopes(changedScopes, `Execution ${executionId} touched ${[...changedScopes].join(", ")}`);
+		if (execution.changedTables.size > 0) await this.deps.reactivity.publishExternalChange({
+			scope: "database",
+			reason: "commit",
+			changedScopes: [...changedScopes].filter((scope) => scope.startsWith("table:")),
+			changedTables: [...execution.changedTables]
+		});
+		await this.deps.reactivity.publishStorageChanges(execution.storageChanges);
+	}
+	async collectQueryDependencies(functionName, args) {
+		const definition = this.resolveFunction({
+			kind: "query",
+			name: functionName
+		}, "query");
+		const dependencyCollector = /* @__PURE__ */ new Set();
+		await this.invokeFunction(definition, args, {
+			mutationDepth: 0,
+			changedTables: /* @__PURE__ */ new Set(),
+			storageChanges: [],
+			dependencyCollector,
+			componentMetadata: definition.__syncoreComponent
+		});
+		return dependencyCollector;
+	}
+	async executeQueryBuilder(options) {
+		const table = this.deps.schema.getTableDefinition(options.tableName);
+		const params = [];
+		const whereClauses = [];
+		const orderClauses = [];
+		let joinClause = "";
+		const source = options.source;
+		if (source.type === "index") {
+			const index = table.indexes.find((candidate) => candidate.name === source.name);
+			if (!index) throw new Error(`Unknown index "${source.name}" on table "${options.tableName}".`);
+			for (const condition of source.range) whereClauses.push(this.renderCondition("t", condition, params));
+			const primaryField = index.fields[0];
+			if (primaryField) orderClauses.push(`${fieldExpression("t", primaryField)} ${options.orderDirection.toUpperCase()}`);
+		}
+		if (source.type === "search") {
+			const searchIndex = table.searchIndexes.find((candidate) => candidate.name === source.name);
+			if (!searchIndex) throw new Error(`Unknown search index "${source.name}" on table "${options.tableName}".`);
+			if (searchIndex.searchField !== source.query.searchField) throw new Error(`Search index "${searchIndex.name}" expects field "${searchIndex.searchField}".`);
+			if (this.deps.schema.isSearchIndexDisabled(options.tableName, searchIndex.name)) {
+				whereClauses.push(`${fieldExpression("t", searchIndex.searchField)} LIKE ?`);
+				params.push(`%${source.query.searchText}%`);
+			} else {
+				joinClause = `JOIN ${quoteIdentifier(resolveSearchIndexTableName(options.tableName, searchIndex.name))} s ON s._id = t._id`;
+				whereClauses.push(`s.search_value MATCH ?`);
+				params.push(source.query.searchText);
+			}
+			for (const condition of source.query.filters) whereClauses.push(this.renderCondition("t", condition, params));
+		}
+		if (options.filterExpression) whereClauses.push(this.renderExpression("t", options.filterExpression, params));
+		if (orderClauses.length === 0) orderClauses.push(`t._creationTime ${options.orderDirection.toUpperCase()}`);
+		orderClauses.push(`t._id ${options.orderDirection.toUpperCase()}`);
+		const sql = [
+			`SELECT t._id, t._creationTime, t._json FROM ${quoteIdentifier(options.tableName)} t`,
+			joinClause,
+			whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "",
+			`ORDER BY ${orderClauses.join(", ")}`,
+			options.limit !== void 0 ? `LIMIT ${options.limit}` : "",
+			options.offset !== void 0 ? `OFFSET ${options.offset}` : ""
+		].filter(Boolean).join(" ");
+		return (await this.deps.driver.all(sql, params)).map((row) => this.deps.schema.deserializeDocument(options.tableName, row));
+	}
+	async invokeFunction(definition, rawArgs, state) {
+		const args = definition.argsValidator.parse(rawArgs);
+		const ctx = this.createContext(definition.kind, {
+			...state,
+			componentMetadata: definition.__syncoreComponent ?? state.componentMetadata
+		});
+		const result = await definition.handler(ctx, args);
+		if (definition.returnsValidator) return definition.returnsValidator.parse(result);
+		return result;
+	}
+	createContext(kind, state) {
+		const db = kind === "mutation" ? this.createDatabaseWriter(state) : this.createDatabaseReader(state);
+		const storage = this.deps.storage.createStorageApi(state);
+		const scheduler = this.createSchedulerApi(state.componentMetadata);
+		const callerMetadata = state.componentMetadata;
+		return {
+			db,
+			storage,
+			capabilities: this.deps.capabilities,
+			capabilityDescriptors: this.deps.capabilityDescriptors,
+			...callerMetadata ? { component: {
+				path: callerMetadata.componentPath,
+				name: callerMetadata.componentName,
+				version: callerMetadata.version,
+				capabilities: callerMetadata.grantedCapabilities
+			} } : {},
+			scheduler,
+			runQuery: (reference, ...args) => this.runQuery(this.resolveReferenceForCaller(reference, "query", callerMetadata), normalizeOptionalArgs(args)),
+			runMutation: (reference, ...args) => {
+				const resolvedReference = this.resolveReferenceForCaller(reference, "mutation", callerMetadata);
+				const normalizedArgs = normalizeOptionalArgs(args);
+				if (kind === "mutation") return this.deps.driver.withSavepoint(`sp_${generateId().replace(/-/g, "_")}`, () => this.invokeFunction(this.resolveFunction(resolvedReference, "mutation", callerMetadata), normalizedArgs, {
+					mutationDepth: state.mutationDepth + 1,
+					changedTables: state.changedTables,
+					storageChanges: state.storageChanges,
+					componentMetadata: callerMetadata
+				}));
+				return this.runMutation(resolvedReference, normalizedArgs);
+			},
+			runAction: (reference, ...args) => this.runAction(this.resolveReferenceForCaller(reference, "action", callerMetadata), normalizeOptionalArgs(args))
+		};
+	}
+	createDatabaseReader(state) {
+		return {
+			get: async (tableName, id) => {
+				const scopedTableName = this.resolveTableName(tableName, state.componentMetadata);
+				state.dependencyCollector?.add(`table:${scopedTableName}`);
+				state.dependencyCollector?.add(`row:${scopedTableName}:${id}`);
+				const row = await this.deps.driver.get(`SELECT _id, _creationTime, _json FROM ${quoteIdentifier(scopedTableName)} WHERE _id = ?`, [id]);
+				return row ? this.deps.schema.deserializeDocument(scopedTableName, row) : null;
+			},
+			query: (tableName) => new RuntimeQueryBuilder((options) => this.executeQueryBuilder({
+				...options,
+				tableName: this.resolveTableName(tableName, state.componentMetadata)
+			}), this.resolveTableName(tableName, state.componentMetadata), state.dependencyCollector),
+			raw: (sql, params) => this.deps.driver.all(sql, params)
+		};
+	}
+	createDatabaseWriter(state) {
+		const reader = this.createDatabaseReader(state);
+		return {
+			...reader,
+			insert: async (tableName, value) => {
+				const scopedTableName = this.resolveTableName(tableName, state.componentMetadata);
+				const validated = this.deps.schema.validateDocument(scopedTableName, value);
+				const id = generateId();
+				const creationTime = Date.now();
+				const json = stableStringify(validated);
+				await this.deps.driver.run(`INSERT INTO ${quoteIdentifier(scopedTableName)} (_id, _creationTime, _json) VALUES (?, ?, ?)`, [
+					id,
+					creationTime,
+					json
+				]);
+				await this.deps.schema.syncSearchIndexes(scopedTableName, {
+					_id: id,
+					_creationTime: creationTime,
+					_json: json
+				});
+				state.changedTables.add(scopedTableName);
+				return id;
+			},
+			patch: async (tableName, id, value) => {
+				const scopedTableName = this.resolveTableName(tableName, state.componentMetadata);
+				const current = await reader.get(tableName, id);
+				if (!current) throw new Error(`Document "${id}" does not exist in "${scopedTableName}".`);
+				const merged = {
+					...omitSystemFields(current),
+					...value
+				};
+				for (const key of Object.keys(merged)) if (merged[key] === void 0) delete merged[key];
+				const validated = this.deps.schema.validateDocument(scopedTableName, merged);
+				await this.deps.driver.run(`UPDATE ${quoteIdentifier(scopedTableName)} SET _json = ? WHERE _id = ?`, [stableStringify(validated), id]);
+				const row = await this.deps.driver.get(`SELECT _id, _creationTime, _json FROM ${quoteIdentifier(scopedTableName)} WHERE _id = ?`, [id]);
+				if (row) await this.deps.schema.syncSearchIndexes(scopedTableName, row);
+				state.changedTables.add(scopedTableName);
+			},
+			replace: async (tableName, id, value) => {
+				const scopedTableName = this.resolveTableName(tableName, state.componentMetadata);
+				const validated = this.deps.schema.validateDocument(scopedTableName, value);
+				await this.deps.driver.run(`UPDATE ${quoteIdentifier(scopedTableName)} SET _json = ? WHERE _id = ?`, [stableStringify(validated), id]);
+				const row = await this.deps.driver.get(`SELECT _id, _creationTime, _json FROM ${quoteIdentifier(scopedTableName)} WHERE _id = ?`, [id]);
+				if (!row) throw new Error(`Document "${id}" does not exist in "${scopedTableName}".`);
+				await this.deps.schema.syncSearchIndexes(scopedTableName, row);
+				state.changedTables.add(scopedTableName);
+			},
+			delete: async (tableName, id) => {
+				const scopedTableName = this.resolveTableName(tableName, state.componentMetadata);
+				await this.deps.driver.run(`DELETE FROM ${quoteIdentifier(scopedTableName)} WHERE _id = ?`, [id]);
+				await this.deps.schema.removeSearchIndexes(scopedTableName, id);
+				state.changedTables.add(scopedTableName);
+			}
+		};
+	}
+	createSchedulerApi(componentMetadata) {
+		return {
+			runAfter: async (delayMs, reference, ...args) => {
+				if (componentMetadata && !componentMetadata.grantedCapabilities.includes("scheduler")) throw new Error(`Component ${JSON.stringify(componentMetadata.componentPath)} does not have scheduler capability.`);
+				const schedulerArgs = splitSchedulerArgs(args);
+				const functionArgs = schedulerArgs[0];
+				const misfirePolicy = schedulerArgs[1] ?? DEFAULT_MISFIRE_POLICY;
+				const resolvedReference = this.resolveReferenceForCaller(reference, reference.kind, componentMetadata);
+				return this.deps.scheduler.scheduleJob(Date.now() + delayMs, resolvedReference, functionArgs, misfirePolicy, componentMetadata ? `component:${componentMetadata.componentPath}:` : void 0);
+			},
+			runAt: async (timestamp, reference, ...args) => {
+				if (componentMetadata && !componentMetadata.grantedCapabilities.includes("scheduler")) throw new Error(`Component ${JSON.stringify(componentMetadata.componentPath)} does not have scheduler capability.`);
+				const schedulerArgs = splitSchedulerArgs(args);
+				const functionArgs = schedulerArgs[0];
+				const misfirePolicy = schedulerArgs[1] ?? DEFAULT_MISFIRE_POLICY;
+				const value = timestamp instanceof Date ? timestamp.getTime() : timestamp;
+				const resolvedReference = this.resolveReferenceForCaller(reference, reference.kind, componentMetadata);
+				return this.deps.scheduler.scheduleJob(value, resolvedReference, functionArgs, misfirePolicy, componentMetadata ? `component:${componentMetadata.componentPath}:` : void 0);
+			},
+			cancel: async (id) => {
+				await this.deps.scheduler.cancelScheduledJob(id);
+			}
+		};
+	}
+	resolveFunction(reference, expectedKind, callerMetadata) {
+		const resolvedReference = this.resolveReferenceForCaller(reference, expectedKind, callerMetadata);
+		const definition = this.deps.functions[resolvedReference.name];
+		if (!definition) throw new Error(`Unknown function "${resolvedReference.name}".`);
+		if (definition.kind !== expectedKind) throw new Error(`Function "${resolvedReference.name}" is a ${definition.kind}, expected ${expectedKind}.`);
+		const metadata = definition.__syncoreComponent;
+		if (metadata?.visibility === "internal") {
+			if (!callerMetadata) throw new Error(`Function "${resolvedReference.name}" is internal to component "${metadata.componentPath}".`);
+			if (callerMetadata.componentPath !== metadata.componentPath) throw new Error(`Function "${resolvedReference.name}" is internal to component "${metadata.componentPath}" and cannot be called from "${callerMetadata.componentPath}".`);
+		}
+		return definition;
+	}
+	renderExpression(tableAlias, expression, params) {
+		if (expression.type === "condition") return this.renderCondition(tableAlias, expression.condition, params);
+		const separator = expression.type === "and" ? " AND " : " OR ";
+		return `(${expression.expressions.map((child) => this.renderExpression(tableAlias, child, params)).join(separator)})`;
+	}
+	renderCondition(tableAlias, condition, params) {
+		params.push(condition.value);
+		return `${fieldExpression(tableAlias, condition.field)} ${condition.operator} ?`;
+	}
+	resolveReferenceForCaller(reference, expectedKind, callerMetadata) {
+		if (!callerMetadata) return reference;
+		if (reference.name.startsWith("components/")) return reference;
+		const bindingMatch = /^binding:([^/]+)\/(.+)$/.exec(reference.name);
+		if (bindingMatch) {
+			const bindingName = bindingMatch[1];
+			const localName = bindingMatch[2];
+			const targetComponentPath = callerMetadata.bindings[bindingName];
+			if (!targetComponentPath) throw new Error(`Component ${JSON.stringify(callerMetadata.componentPath)} does not define binding ${JSON.stringify(bindingName)}.`);
+			return {
+				kind: expectedKind,
+				name: toCanonicalComponentFunctionName(targetComponentPath, "public", localName)
+			};
+		}
+		const internalName = toCanonicalComponentFunctionName(callerMetadata.componentPath, "internal", reference.name);
+		if (this.deps.functions[internalName]) return {
+			kind: expectedKind,
+			name: internalName
+		};
+		const publicName = toCanonicalComponentFunctionName(callerMetadata.componentPath, "public", reference.name);
+		if (this.deps.functions[publicName]) return {
+			kind: expectedKind,
+			name: publicName
+		};
+		return reference;
+	}
+	resolveTableName(tableName, componentMetadata) {
+		if (!componentMetadata) return tableName;
+		const scopedTableName = componentMetadata.localTables[tableName];
+		if (!scopedTableName) throw new Error(`Table ${JSON.stringify(tableName)} is not available inside component ${JSON.stringify(componentMetadata.componentPath)}.`);
+		return scopedTableName;
+	}
+};
+function collectChangedScopes(changedTables, storageChanges) {
+	return new Set([...[...changedTables].map((tableName) => `table:${tableName}`), ...storageChanges.map((change) => `storage:${change.storageId}`)]);
+}
+//#endregion
+export { ExecutionEngine };
+
+//# sourceMappingURL=executionEngine.mjs.map