@prisma/orm-target-sqlite 8.0.0-rc.17-dev.36 → 8.0.0-rc.17-dev.38

package/dist/{op-factory-call-gwVgzGbc-caCULmpj.mjs → op-factory-call-hxIbAMSY-CinxsQHg.mjs}

@@ -2,21 +2,22 @@ import { o as sqliteInteger } from "./data-types-pFQMl37_-B-3aK_wd.mjs";
 import { n as sqliteError } from "./errors-DnR-sMHS-KkMLIP2U.mjs";
 import { n as decodeSqliteDatetime, r as encodeSqliteDatetime } from "./codecs-BctEWIFt-DgMd3dUl.mjs";
 import { a as tableExistsAst, i as indexExistsAst, n as columnNameTakenAst, o as tableNameTakenAst, r as createTable, t as columnExistsAst } from "./ddl-CDoa1Ehx-BOT670XL.mjs";
-import { n as quoteIdentifier, t as escapeLiteral } from "./sql-utils-C2O4zVkP-Dz3Hb85I.mjs";
+import { n as escapeLiteral, r as quoteIdentifier, t as SQLITE_QUOTING } from "./sql-utils-XGT5Esi2-5k9pvJeF.mjs";
 import { r as stripOuterParens } from "./default-normalizer-Ch3VFnEH-C-h1XtlJ.mjs";
 import { t as buildTargetDetails } from "./planner-target-details-CIQ789Gc-C5U4yVY9.mjs";
 import { DdlColumn, FunctionColumnDefault, LiteralColumnDefault, opaqueSql } from "@prisma/orm-family-sql/relational-core/ast";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { dataTypeParams, renderSqlTypeName, sqlDataTypeOfCodec } from "@prisma/orm-family-sql/contract/data-type";
+import { type } from "arktype";
 import { issueOutcome } from "@prisma/orm-framework/components/control";
-import { createSqlTextSources } from "@prisma/orm-family-sql/family/control";
+import { checkSqlExpressionText, convertedColumnMeta, createSqlTextSources, isUnfilledSlot, requiredColumnMeta, slotSource, sqlOfSlot } from "@prisma/orm-family-sql/family/control";
 import { RelationalSchemaNodeKind } from "@prisma/orm-family-sql/schema-ir/types";
 import { assertNever } from "@prisma/orm-framework/utils/internal-error";
 import { errorMigrationOperationOptionRemoved, unfilledPlaceholderOperation } from "@prisma/orm-framework/errors/migration";
 import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
 import { TsExpression, jsonToTsSource, tsArraySource, tsObjectSource, tsQuotedTextSource } from "@prisma/orm-framework/ts-render";
-//#region ../../../3-targets/3-targets/sqlite/dist/op-factory-call-gwVgzGbc.mjs
+//#region ../../../3-targets/3-targets/sqlite/dist/op-factory-call-hxIbAMSY.mjs
 /**
 * Low-level DDL fragment builders for SQLite migrations.
 *
@@ -260,18 +261,35 @@ function renameTableSteps(fromName, toName) {
 	const via = quoteIdentifier(viaName);
 	return [step(`rename table "${fromName}" to "${viaName}" (SQLite table names are case-insensitive)`, `ALTER TABLE ${from} RENAME TO ${via}`), step(`rename table "${viaName}" to "${toName}"`, `ALTER TABLE ${via} RENAME TO ${to}`)];
 }
+/** The table a rebuild of `tableName` creates, copies into, and renames to `tableName`. */
+function rebuiltTableName(tableName) {
+	return `_prisma_new_${tableName}`;
+}
 async function recreateTable(args, lowerer) {
-	const { tableName, contractTable, schemaColumnNames, indexes, summary, postchecks, operationClass } = args;
+	const { tableName, contractTable, schemaColumnNames, indexes, summary, postchecks, operationClass, copyExpressions = {}, temporaryValues = {}, retypedColumns = [] } = args;
 	refuseEarlierColumnSpecs("recreateTable", tableName, contractTable.columns);
-	const tempName = `_prisma_new_${tableName}`;
+	const tempName = rebuiltTableName(tableName);
 	const liveSet = new Set(schemaColumnNames);
-	const sharedColumns = contractTable.columns.filter((c) => liveSet.has(c.name)).map((c) => c.name);
+	const convertedBy = (column) => Object.hasOwn(copyExpressions, column) ? copyExpressions[column] : void 0;
+	const copiedFrom = (column) => convertedBy(column) ?? (Object.hasOwn(temporaryValues, column) ? temporaryValues[column] : void 0);
+	const sharedColumns = contractTable.columns.filter((c) => liveSet.has(c.name) || copiedFrom(c.name) !== void 0).map((c) => c.name);
 	const columnList = sharedColumns.map(quoteIdentifier).join(", ");
+	const selectList = sharedColumns.map((column) => copiedFrom(column) ?? quoteIdentifier(column)).join(", ");
 	const indexStatements = indexes.map((idx) => ({
 		description: `recreate index "${idx.name}" on "${tableName}"`,
 		sql: buildCreateIndexSql(tableName, idx.name, idx.columns)
 	}));
-	const copyStep = sharedColumns.length > 0 ? [step(`copy data from "${tableName}" to "${tempName}"`, `INSERT INTO ${quoteIdentifier(tempName)} (${columnList}) SELECT ${columnList} FROM ${quoteIdentifier(tableName)}`)] : [];
+	const conversions = Object.fromEntries(sharedColumns.flatMap((column) => {
+		const expression = convertedBy(column);
+		return expression === void 0 ? [] : [[column, expression]];
+	}));
+	const copyStep = sharedColumns.length > 0 ? [{
+		...step(`copy data from "${tableName}" to "${tempName}"`, `INSERT INTO ${quoteIdentifier(tempName)} (${columnList}) SELECT ${selectList} FROM ${quoteIdentifier(tableName)}`),
+		...Object.keys(conversions).length === 0 ? {} : { meta: { conversionCopy: {
+			table: tableName,
+			expressions: conversions
+		} } }
+	}] : [];
 	const defaultClauses = await renderSpecDefaults(contractTable, tableName, lowerer);
 	const clauseByColumn = new Map(contractTable.columns.map((column, index) => [column.name, defaultClauses[index] ?? ""]));
 	const tableSteps = await tableExistsSteps(lowerer, tableName);
@@ -296,10 +314,70 @@ async function recreateTable(args, lowerer) {
 		postcheck: [
 			step(`verify table "${tableName}" exists`, tableSteps.present.sql, tableSteps.present.params),
 			step(`verify temp table "${tempName}" is gone`, tempSteps.absent.sql, tempSteps.absent.params),
-			...postchecks.flatMap((check) => "sql" in check ? [check] : defaultPostcheck(tableName, check, clauseByColumn.get(check.columnDefault)))
+			...postchecks.flatMap((check) => "sql" in check ? [markedStep(tableName, check)] : defaultPostcheck(tableName, check, clauseByColumn.get(check.columnDefault))),
+			...contractTable.columns.flatMap((column) => {
+				const by = Object.hasOwn(conversions, column.name) ? "conversion" : retypedColumns.includes(column.name) ? "cast" : void 0;
+				return by === void 0 ? [] : [{
+					...storageClassCheck(tableName, column),
+					meta: convertedColumnMeta(tableName, column.name, by)
+				}];
+			})
 		]
 	};
 }
+function markedStep(tableName, check) {
+	const { requiredColumn, ...step } = check;
+	const meta = { ...requiredColumn === void 0 ? {} : requiredColumnMeta(tableName, requiredColumn.column, requiredColumn.reason) };
+	return Object.keys(meta).length === 0 ? step : {
+		...step,
+		meta
+	};
+}
+/**
+* The storage classes SQLite keeps a value in once a column of `typeSql` has taken it: the column's
+* type affinity converts what it can, so a value of another class is one it could not convert.
+* See https://www.sqlite.org/datatype3.html#determination_of_column_affinity.
+*/
+function affinityStorageClasses(typeSql) {
+	const declared = typeSql.toUpperCase();
+	if (declared.includes("INT")) return ["integer"];
+	if ([
+		"CHAR",
+		"CLOB",
+		"TEXT"
+	].some((part) => declared.includes(part))) return ["text"];
+	if (declared === "" || declared.includes("BLOB")) return ["blob"];
+	if ([
+		"REAL",
+		"FLOA",
+		"DOUB"
+	].some((part) => declared.includes(part))) return ["real"];
+	return ["integer", "real"];
+}
+/**
+* The check that the copy into a rebuilt table converted every value of a retyped column to the
+* column's new type. SQLite keeps a value it cannot convert in its old storage class, so a value of
+* any other class than the column's affinity keeps fails the check.
+*/
+function storageClassCheck(tableName, column) {
+	const classes = ["null", ...affinityStorageClasses(column.typeSql)].map((storageClass) => `'${storageClass}'`).join(", ");
+	return {
+		description: `verify every value of "${column.name}" on "${tableName}" is stored as ${column.typeSql}`,
+		sql: `SELECT NOT EXISTS (SELECT 1 FROM ${quoteIdentifier(tableName)} WHERE typeof(${quoteIdentifier(column.name)}) NOT IN (${classes}))`
+	};
+}
+const ConversionCopyMeta = type({ conversionCopy: {
+	table: "string",
+	expressions: "Record<string, string>"
+} });
+/**
+* The table a rebuild's copy step reads and the copy expression of each column its conversions
+* convert, when the step converts any: an error of the step may be an error of one of them.
+*/
+function conversionCopyOf(step) {
+	const meta = ConversionCopyMeta(step.meta ?? {});
+	return meta instanceof type.errors ? void 0 : meta.conversionCopy;
+}
 function renderSpecDefaults(spec, tableName, lowerer) {
 	return Promise.all(spec.columns.map((column) => renderSpecDefault$1(column, tableName, lowerer)));
 }
@@ -386,7 +464,7 @@ function columnNameFromDefaultIssuePath(issue) {
 * `RecreateTableCall` doesn't have to carry `SchemaDiffIssue` objects through
 * to render time.
 */
-function buildRecreatePostchecks(tableName, issues, spec) {
+function buildRecreatePostchecks(tableName, issues, spec, copiedColumns = /* @__PURE__ */ new Set(), backfilledColumns = /* @__PURE__ */ new Set()) {
 	const checks = [];
 	const t = escapeLiteral(tableName);
 	const byName = new Map(spec.columns.map((c) => [c.name, c]));
@@ -395,6 +473,24 @@ function buildRecreatePostchecks(tableName, issues, spec) {
 	let hasFkIssue = false;
 	for (const issue of issues) {
 		const nodeKind = nodeKindOf(issue);
+		if (nodeKind === RelationalSchemaNodeKind.column && issueOutcome(issue) === "not-found") {
+			const columnName = columnNameFromNode(issue);
+			const column = columnName === void 0 ? void 0 : byName.get(columnName);
+			if (columnName === void 0 || column === void 0) continue;
+			const takesNoValue = !column.nullable && column.default === void 0 && !copiedColumns.has(columnName);
+			checks.push({
+				description: `verify "${columnName}" nullability on "${tableName}"`,
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${escapeLiteral(columnName)}' AND "notnull" = ${column.nullable ? 0 : 1}`,
+				...backfilledColumns.has(columnName) ? { requiredColumn: {
+					column: columnName,
+					reason: "backfillMissedRows"
+				} } : takesNoValue ? { requiredColumn: {
+					column: columnName,
+					reason: "newField"
+				} } : {}
+			});
+			continue;
+		}
 		if (nodeKind === RelationalSchemaNodeKind.column && issueOutcome(issue) === "not-equal") {
 			const columnName = columnNameFromNode(issue);
 			if (columnName === void 0) continue;
@@ -403,7 +499,11 @@ function buildRecreatePostchecks(tableName, issues, spec) {
 			const actual = blindCast(issue.actual);
 			if (expected.nullable !== actual.nullable) checks.push({
 				description: `verify "${columnName}" nullability on "${tableName}"`,
-				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND "notnull" = ${expected.nullable ? 0 : 1}`
+				sql: `SELECT COUNT(*) > 0 FROM pragma_table_info('${t}') WHERE name = '${c}' AND "notnull" = ${expected.nullable ? 0 : 1}`,
+				...expected.nullable ? {} : { requiredColumn: {
+					column: columnName,
+					reason: backfilledColumns.has(columnName) ? "backfillMissedRows" : "nullValues"
+				} }
 			});
 			if (columnTypeChanged(expected, actual)) {
 				const colSpec = byName.get(columnName);
@@ -791,6 +891,86 @@ var RenameColumnCall = class extends SqliteOpFactoryCallNode {
 		return [];
 	}
 };
+function refuseUnsafeCopyExpressions(tableName, option, expressions) {
+	for (const [column, expression] of Object.entries(expressions)) {
+		if (expression.kind !== "sql") continue;
+		const refused = checkSqlExpressionText(expression.sql, SQLITE_QUOTING);
+		if (refused === void 0) continue;
+		const call = `recreateTable({ tableName: ${jsonToTsSource(tableName)} })`;
+		throw sqliteError("MIGRATION.SQL_EXPRESSION_INVALID", `${call}: ${option}.${column} ${JSON.stringify(expression.sql)} holds ${refused}, which could end or extend the INSERT … SELECT statement it is written into`, {
+			why: "A copy expression or a temporary value is written into the SELECT that copies the rows into the rebuilt table. The check refuses a semicolon, a SQL comment, dollar quoting, and a comma or a statement keyword outside parentheses, since each could end or extend that statement; it does not check that the text is valid SQL.",
+			fix: `Write ${option}.${column} as one SQL expression over the old table's columns, such as CAST("${column}" AS INTEGER). If it holds a comma or a keyword such as FROM outside parentheses, wrap it in parentheses.`,
+			meta: {
+				call,
+				field: `${option}.${column}`,
+				expression: expression.sql,
+				refused
+			}
+		});
+	}
+}
+function refuseUnknownCopyExpressionColumns(tableName, contractTable, named) {
+	const columns = contractTable.columns.map((column) => column.name);
+	const unknown = [
+		...Object.keys(named.copyExpressions).map((key) => ({
+			option: `copyExpressions.${key}`,
+			key
+		})),
+		...Object.keys(named.temporaryValues).map((key) => ({
+			option: `temporaryValues.${key}`,
+			key
+		})),
+		...named.retypedColumns.map((key) => ({
+			option: `retypedColumns entry ${JSON.stringify(key)}`,
+			key
+		}))
+	].find(({ key }) => !columns.includes(key));
+	if (unknown === void 0) return;
+	const call = `recreateTable({ tableName: ${jsonToTsSource(tableName)} })`;
+	throw sqliteError("MIGRATION.COPY_EXPRESSION_COLUMN_UNKNOWN", `${call}: ${unknown.option} names no column of the new table. Its columns are ${columns.map((column) => JSON.stringify(column)).join(", ")}.`, {
+		why: "Each key of copyExpressions and temporaryValues, and each entry of retypedColumns, names a column of the new table. One that names no column applies to nothing, so the column meant would be copied unchanged or left without a value, or its values would go unchecked.",
+		fix: "Name a column in contractTable.columns, with the same letters and case.",
+		meta: {
+			call,
+			key: unknown.key,
+			columns
+		}
+	});
+}
+/**
+* A temporary value fills a column the old table does not have, and only that: for a column the
+* old table has it would replace every existing value, and a column with a copy expression is
+* already filled by its conversion.
+*/
+function refuseMisplacedTemporaryValues(tableName, schemaColumnNames, copyExpressions, temporaryValues) {
+	const call = `recreateTable({ tableName: ${jsonToTsSource(tableName)} })`;
+	for (const column of Object.keys(temporaryValues)) {
+		if (schemaColumnNames.includes(column)) throw sqliteError("MIGRATION.TEMPORARY_VALUE_INVALID", `${call}: temporaryValues.${column} names a column the old table already has, so the copy would replace every value of it.`, {
+			why: "A temporary value fills a new column in the existing rows. A column the old table has keeps its values through the copy, or is converted by a copy expression.",
+			fix: `Remove temporaryValues.${column}. To change the values of "${column}", write a conversion in copyExpressions.${column} instead.`,
+			meta: {
+				call,
+				column,
+				reason: "existingColumn"
+			}
+		});
+		if (Object.hasOwn(copyExpressions, column)) throw sqliteError("MIGRATION.TEMPORARY_VALUE_INVALID", `${call}: "${column}" is named in both copyExpressions and temporaryValues, so it would be filled twice.`, {
+			why: "A column is filled either by the conversion in copyExpressions or by a temporary value, not both.",
+			fix: `Keep one of copyExpressions.${column} and temporaryValues.${column}.`,
+			meta: {
+				call,
+				column,
+				reason: "alsoConverted"
+			}
+		});
+	}
+}
+function sqlOfSlots(slots) {
+	return Object.fromEntries(Object.entries(slots).flatMap(([column, slot]) => {
+		const sql = sqlOfSlot(slot);
+		return sql === void 0 ? [] : [[column, sql]];
+	}));
+}
 var RecreateTableCall = class extends SqliteOpFactoryCallNode {
 	factoryName = "recreateTable";
 	operationClass;
@@ -801,14 +981,25 @@ var RecreateTableCall = class extends SqliteOpFactoryCallNode {
 	summary;
 	postchecks;
 	label;
-	/**
-	* The columns whose values the copy can change, because their type changes. The planner reads
-	* them to name what the recreate loses; they never reach the operation or `migration.ts`.
-	*/
-	lossyColumns;
-	constructor(args, lossyColumns = []) {
+	/** The conversion each named column of the new table is copied through, in place of the live column. */
+	copyExpressions;
+	/** The value each named new column takes in the existing rows. */
+	temporaryValues;
+	/** The columns whose type changes; the rebuild checks each after its copy, as a conversion when it has a copy expression and as SQLite's cast otherwise. */
+	retypedColumns;
+	constructor(args) {
 		super();
-		this.lossyColumns = Object.freeze([...lossyColumns]);
+		refuseUnsafeCopyExpressions(args.tableName, "copyExpressions", args.copyExpressions ?? {});
+		refuseUnsafeCopyExpressions(args.tableName, "temporaryValues", args.temporaryValues ?? {});
+		refuseUnknownCopyExpressionColumns(args.tableName, args.contractTable, {
+			copyExpressions: args.copyExpressions ?? {},
+			temporaryValues: args.temporaryValues ?? {},
+			retypedColumns: args.retypedColumns ?? []
+		});
+		refuseMisplacedTemporaryValues(args.tableName, args.schemaColumnNames, args.copyExpressions ?? {}, args.temporaryValues ?? {});
+		this.copyExpressions = Object.freeze({ ...args.copyExpressions });
+		this.temporaryValues = Object.freeze({ ...args.temporaryValues });
+		this.retypedColumns = Object.freeze([...args.retypedColumns ?? []]);
 		this.tableName = args.tableName;
 		this.contractTable = args.contractTable;
 		this.schemaColumnNames = args.schemaColumnNames;
@@ -824,6 +1015,8 @@ var RecreateTableCall = class extends SqliteOpFactoryCallNode {
 			factory: this.factoryName,
 			tableName: this.tableName
 		} });
+		const copies = Object.entries(this.copyExpressions);
+		if (copies.some(([, expression]) => isUnfilledSlot(expression))) return unfilledPlaceholderOperation(this.label);
 		return recreateTable({
 			tableName: this.tableName,
 			contractTable: this.contractTable,
@@ -831,14 +1024,23 @@ var RecreateTableCall = class extends SqliteOpFactoryCallNode {
 			indexes: this.indexes,
 			summary: this.summary,
 			postchecks: this.postchecks,
-			operationClass: this.operationClass
+			operationClass: this.operationClass,
+			retypedColumns: this.retypedColumns,
+			...copies.length === 0 ? {} : { copyExpressions: sqlOfSlots(this.copyExpressions) },
+			...Object.keys(this.temporaryValues).length === 0 ? {} : { temporaryValues: sqlOfSlots(this.temporaryValues) }
 		}, lowerer);
 	}
+	#slotsSource(slots, sql) {
+		return `{ ${Object.entries(slots).map(([column, expression]) => `${jsonToTsSource(column)}: ${slotSource(expression, sql)}`).join(", ")} }`;
+	}
 	renderTypeScript() {
 		return this.#written().source;
 	}
 	importRequirements() {
-		return this.#written().imports;
+		return [...Object.values(this.copyExpressions).some(isUnfilledSlot) ? [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: "placeholder"
+		}] : [], ...this.#written().imports];
 	}
 	#written() {
 		const sql = createSqlTextSources(TARGET_MIGRATION_MODULE);
@@ -850,7 +1052,10 @@ var RecreateTableCall = class extends SqliteOpFactoryCallNode {
 				["indexes", jsonToTsSource(this.indexes)],
 				["summary", jsonToTsSource(this.summary)],
 				["postchecks", tsArraySource(this.postchecks.map(renderPostcheck))],
-				["operationClass", jsonToTsSource(this.operationClass)]
+				["operationClass", jsonToTsSource(this.operationClass)],
+				...Object.keys(this.copyExpressions).length === 0 ? [] : [["copyExpressions", this.#slotsSource(this.copyExpressions, sql)]],
+				...Object.keys(this.temporaryValues).length === 0 ? [] : [["temporaryValues", this.#slotsSource(this.temporaryValues, sql)]],
+				...this.retypedColumns.length === 0 ? [] : [["retypedColumns", jsonToTsSource(this.retypedColumns)]]
 			])})`,
 			imports: sql.imports()
 		};
@@ -1051,19 +1256,22 @@ var DataTransformCall = class extends SqliteOpFactoryCallNode {
 	label;
 	tableName;
 	columnName;
-	constructor(id, label, tableName, columnName) {
+	/** The slot the user fills with the statement that fills the column: `<Model.field>:run`. */
+	slot;
+	constructor(id, label, tableName, columnName, slot) {
 		super();
 		this.id = id;
 		this.label = label;
 		this.tableName = tableName;
 		this.columnName = columnName;
+		this.slot = slot;
 		this.freeze();
 	}
 	toOp(_lowerer) {
 		return unfilledPlaceholderOperation(this.label);
 	}
 	renderTypeScript() {
-		const slot = `${this.tableName}-${this.columnName}-backfill-sql`;
+		const slot = this.slot;
 		return [
 			"dataTransform({",
 			`  id: ${jsonToTsSource(this.id)},`,
@@ -1146,7 +1354,8 @@ function renderSpecDefault(columnDefault, sql) {
 function renderPostcheck(postcheck) {
 	if ("sql" in postcheck) return tsObjectSource(definedSourceEntries({
 		description: jsonToTsSource(postcheck.description),
-		sql: tsQuotedTextSource(postcheck.sql)
+		sql: tsQuotedTextSource(postcheck.sql),
+		requiredColumn: postcheck.requiredColumn === void 0 ? void 0 : jsonToTsSource(postcheck.requiredColumn)
 	}));
 	return tsObjectSource(definedSourceEntries({
 		description: jsonToTsSource(postcheck.description),
@@ -1154,6 +1363,6 @@ function renderPostcheck(postcheck) {
 	}));
 }
 //#endregion
-export { renameTableSteps as _, DropColumnCall as a, sqliteIdentifiersCollide as b, RawSqlCall as c, RenameTableCall as d, buildColumnTypeSql as f, isSqliteOpFactoryCall as g, indexReplacementCalls as h, DataTransformCall as i, RecreateTableCall as l, buildRecreateSummary as m, CreateIndexCall as n, DropIndexCall as o, buildRecreatePostchecks as p, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, RenameColumnCall as u, renderDefaultLiteral as v, step as x, sqliteDefaultToDdlColumnDefault as y };
+export { sqliteIdentifiersCollide as C, sqliteDefaultToDdlColumnDefault as S, indexReplacementCalls as _, DropColumnCall as a, renameTableSteps as b, RawSqlCall as c, RenameTableCall as d, affinityStorageClasses as f, conversionCopyOf as g, buildRecreateSummary as h, DataTransformCall as i, RecreateTableCall as l, buildRecreatePostchecks as m, CreateIndexCall as n, DropIndexCall as o, buildColumnTypeSql as p, CreateTableCall as r, DropTableCall as s, AddColumnCall as t, RenameColumnCall as u, isSqliteOpFactoryCall as v, step as w, renderDefaultLiteral as x, rebuiltTableName as y };
 
-//# sourceMappingURL=op-factory-call-gwVgzGbc-caCULmpj.mjs.map
+//# sourceMappingURL=op-factory-call-hxIbAMSY-CinxsQHg.mjs.map