@prisma/orm-family-sql 8.0.0-rc.17-dev.37 → 8.0.0-rc.17-dev.39

package/dist/{control-uICV4VAt.mjs → control-Bvnz4Uk4.mjs}

@@ -1,15 +1,15 @@
 import { u as namingOf } from "./naming-CT8tRisJ-DLHKo0Hm.mjs";
 import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-dmXkOR4a.mjs";
-import { a as renderSqlTypeName, l as sqlDataTypeOfCodec, t as dataTypeParams, u as unquotedSqlBaseName } from "./data-type-C_PI_Jsa.mjs";
+import { a as renderSqlTypeName, d as unquotedSqlBaseName, t as dataTypeParams, u as sqlDataTypeOfCodec } from "./data-type-BgP6Wv48.mjs";
 import { c as StorageTable } from "./storage-table-B7OSPl3G-p1j6AjMS.mjs";
 import { c as SqlSchemaIR, n as RelationalSchemaNodeKind, u as SqlTableIR } from "./types-D0GFxty0-CP8b4dR3.mjs";
 import { p as sqlExpressionRegistration } from "./sql-expression-DSRILiU2.mjs";
 import { u as isStorageTypeInstance } from "./types-DXrO0fxT.mjs";
 import { g as valueObjectStorageTypeMissingMessage } from "./validators-BMWQ7-5D.mjs";
-import { S as sqlAttributeSpecs, a as describeUnsupportedSqlAttribute } from "./psl-field-resolution-D4jnVVTd-CyGA5a3e.mjs";
+import { S as sqlAttributeSpecs, a as describeUnsupportedSqlAttribute } from "./psl-field-resolution-D4jnVVTd-B396sZmO.mjs";
 import { t as sqlEmission } from "./dist-D8EkCena.mjs";
-import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringTypes, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringFieldPresets } from "./authoring-type-constructors-0Iv2zdwS-CjonPCuf.mjs";
-import { c as verifySqlSchemaByDiff, n as classifyDiffSubjectGranularity, o as enforceSqlDataTypeInvariants, t as classifyDiffEntityKind } from "./schema-verify-DIfHSB4I-Bbek1093.mjs";
+import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringTypes, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringFieldPresets } from "./authoring-type-constructors-0Iv2zdwS-ZTBL7w8X.mjs";
+import { c as verifySqlSchemaByDiff, n as classifyDiffSubjectGranularity, o as enforceSqlDataTypeInvariants, t as classifyDiffEntityKind } from "./schema-verify-DIfHSB4I-Du0-5I8k.mjs";
 import { t as sqlFamilyError } from "./errors-B5g0xWro-mWH2C07F.mjs";
 import { t as SqlContractSerializer } from "./sql-contract-serializer-DDaAVCQr-BAb4jKvV.mjs";
 import { t as collectSupportedCodecTypeIds } from "./verify-BVk5bjdH-dq5M4iIh.mjs";
@@ -21,10 +21,12 @@ import { UNBOUND_NAMESPACE_ID, isPlainRecord } from "@prisma/orm-framework/compo
 import { assembleDataTypes, canonicalFormOf } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { type } from "arktype";
 import { asNamespaceId, effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
-import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions, describeMigrationStatement, extractCodecLookup, issueOutcome, modelDisplayName, sameMarkerHashes } from "@prisma/orm-framework/components/control";
+import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions, describeMigrationStatement, extractCodecLookup, fieldStatementText, issueOutcome, modelDisplayName, sameMarkerHashes } from "@prisma/orm-framework/components/control";
 import { assertDescriptorSelfConsistency } from "@prisma/orm-toolchain/migration-tools/spaces";
+import { jsonToTsSource } from "@prisma/orm-framework/ts-render";
 //#region ../../../2-sql/9-family/dist/control.mjs
 function tablesOf(storage) {
 	return Object.entries(storage.namespaces).flatMap(([namespaceId, namespace]) => Object.entries(namespace.entries["table"] ?? {}).map(([tableName, table]) => ({
@@ -1700,6 +1702,84 @@ function planStatements(input) {
 		appliedStatements
 	});
 }
+/**
+* The column of each field a convert or backfill statement names, as the destination contract
+* stores it. These statements rename nothing, so the strategies that plan a field's change read
+* them instead of the working schema. A field with no column has none to list.
+*/
+function fieldStatementColumns(statements, contract) {
+	const columnsOf = (kind) => statements.flatMap((statement) => {
+		if (statement.kind !== kind) return [];
+		const table = modelTable(contract, statement.field);
+		const column = fieldColumn(contract, statement.field);
+		return table === void 0 || column === void 0 ? [] : [{
+			...table,
+			column,
+			field: statement.field,
+			text: fieldStatementText(contract, statement.field)
+		}];
+	});
+	return {
+		convert: columnsOf("convert"),
+		backfill: columnsOf("backfill")
+	};
+}
+/**
+* A conflict for the first backfill statement that names a field the origin model does not have and
+* whose column has a default: the default fills the existing rows when the column is added, so the
+* statement has nothing to fill. A field already in the origin keeps its backfill, since a default
+* does not fill the rows that hold NULL when the column becomes required.
+*/
+function backfillOfDefaultedField(statements, fromContract, contract) {
+	for (const statement of statements) {
+		if (statement.kind !== "backfill" || fromContract === null) continue;
+		const originModel = sqlModelStorage(fromContract, statement.field);
+		if (originModel === void 0 || Object.hasOwn(originModel.fields, statement.field.field)) continue;
+		const table = modelTable(contract, statement.field);
+		const column = fieldColumn(contract, statement.field);
+		if (table === void 0 || column === void 0) continue;
+		if ((contract.storage.namespaces[table.namespaceId]?.entries.table?.[table.table]?.columns[column])?.default === void 0) continue;
+		return statementRefused(statement, `${describeMigrationStatement(statement, fromContract, contract)}: the field is new and has a default`, "The default fills the existing rows when the column is added, so there is nothing to backfill. Leave out the --backfill statement.", {
+			namespaceId: table.namespaceId,
+			table: table.table,
+			column
+		});
+	}
+}
+/**
+* Every statement of a plan in the order given, with the operations it accounts for: a rename's
+* from `renames`, and none yet for any other statement.
+*/
+function appliedStatementsInOrder(statements, renames) {
+	return statements.map((statement) => renames.find((applied) => applied.statement === statement) ?? {
+		statement,
+		operationIndexes: []
+	});
+}
+/**
+* The field of `contract` that stores `column` of `table`, or undefined when no field stores it or
+* tables of two storage namespaces share the table's name.
+*/
+function fieldOfColumn(contract, table, column) {
+	const fields = Object.entries(contract.domain.namespaces).flatMap(([namespaceId, namespace]) => Object.entries(namespace.models).flatMap(([model, definition]) => {
+		const { storage } = definition;
+		if (!isSqlModelStorage(storage) || storage.table !== table) return [];
+		const field = Object.entries(storage.fields).find(([, stored]) => stored.column === column);
+		if (field === void 0) return [];
+		return [{
+			storageNamespace: storage.namespaceId,
+			isRoot: definition.base === void 0,
+			subject: {
+				kind: "field",
+				namespaceId: asNamespaceId(namespaceId),
+				model,
+				field: field[0]
+			}
+		}];
+	}));
+	if (new Set(fields.map(({ storageNamespace }) => storageNamespace)).size !== 1) return void 0;
+	return (fields.find(({ isRoot }) => isRoot) ?? fields[0])?.subject;
+}
 /** What a codec hook's call is about: the column of the field event it was returned for. */
 function fieldEventStorage(field) {
 	return {
@@ -1731,7 +1811,7 @@ function unknownCallNames(calls) {
 }
 function originTable(context, namespaceId, table) {
 	for (const statement of context.statements) {
-		if (statement.entity !== "model") continue;
+		if (statement.kind !== "rename" || statement.entity !== "model") continue;
 		const effect = modelRenameStorageEffect(statement, context.fromContract, context.contract);
 		if (!effect.ok || effect.value.kind !== "renameTable") continue;
 		const { rename } = effect.value;
@@ -1741,7 +1821,7 @@ function originTable(context, namespaceId, table) {
 }
 function originColumn(context, namespaceId, table, column) {
 	for (const statement of context.statements) {
-		if (statement.entity !== "field") continue;
+		if (statement.kind !== "rename" || statement.entity !== "field") continue;
 		const effect = fieldRenameStorageEffect(statement, context.fromContract, context.contract);
 		if (!effect.ok || effect.value.kind !== "renameColumn") continue;
 		const rename = effect.value;
@@ -1824,18 +1904,25 @@ function keepTableAdvice(target, subject, context) {
 function subjectsOfCalls(calls, context) {
 	const dataLoss = [];
 	const accessWidening = [];
+	const temporaryValues = [];
 	let operationIndex = 0;
 	for (const call of calls) {
+		for (const { table, column, value } of call.temporaryValues) temporaryValues.push({
+			operationIndex,
+			subject: fieldOfColumn(context.contract, table, column) ?? {
+				kind: "storage",
+				name: `${table}.${column}`
+			},
+			value
+		});
 		for (const target of call.dataLoss) {
 			const subject = subjectOf(target, context);
-			const keepDataAdvice = keepTableAdvice(target, subject, context);
-			dataLoss.push(keepDataAdvice === void 0 ? {
-				operationIndex,
-				subject
-			} : {
+			dataLoss.push({
 				operationIndex,
 				subject,
-				keepDataAdvice
+				loss: target.loss,
+				label: call.label,
+				...ifDefined("keepDataAdvice", keepTableAdvice(target, subject, context))
 			});
 		}
 		for (const target of call.accessWidening) accessWidening.push({
@@ -1847,7 +1934,8 @@ function subjectsOfCalls(calls, context) {
 	}
 	return {
 		dataLoss,
-		accessWidening
+		accessWidening,
+		temporaryValues
 	};
 }
 const readOnlyEmptyObject = Object.freeze({});
@@ -1912,6 +2000,7 @@ function plannerSuccess(plan, appliedStatements, subjects, warnings) {
 		appliedStatements: Object.freeze([...appliedStatements]),
 		dataLoss: Object.freeze([...subjects.dataLoss]),
 		accessWidening: Object.freeze([...subjects.accessWidening]),
+		temporaryValues: Object.freeze([...subjects.temporaryValues]),
 		...warnings && warnings.length > 0 ? { warnings: Object.freeze(warnings.map((conflict) => Object.freeze({
 			kind: conflict.kind,
 			summary: conflict.summary,
@@ -1954,13 +2043,206 @@ function runnerFailure(code, summary, options) {
 		code,
 		summary,
 		...options?.why ? { why: options.why } : {},
-		...options?.meta ? { meta: cloneRecord(options.meta) } : {}
+		...options?.meta ? { meta: cloneRecord(options.meta) } : {},
+		...ifDefined("failedTypeChange", options?.failedTypeChange),
+		...ifDefined("rowsWithoutValue", options?.rowsWithoutValue)
 	}));
 }
 /**
 * Policy used by `db init`: additive-only operations, no widening/destructive steps.
 */
 const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.freeze(["additive"]) });
+const RequiredColumnMeta = type({ requiredColumn: {
+	table: "string",
+	column: "string",
+	reason: "'nullValues' | 'newField' | 'backfillMissedRows'"
+} });
+/**
+* The meta of a step that fails when rows have no value for a column that is to become required:
+* rows hold NULL in it, or, for a new column that can be added to an empty table only, the table
+* has rows. When the step fails, the runner counts those rows.
+*/
+function requiredColumnMeta(table, column, reason) {
+	return { requiredColumn: {
+		table,
+		column,
+		reason
+	} };
+}
+/** The column a step checks before it becomes required, as {@link requiredColumnMeta} marks it. */
+function requiredColumnOf(step) {
+	const meta = RequiredColumnMeta(step.meta ?? {});
+	return meta instanceof type.errors ? void 0 : meta.requiredColumn;
+}
+/** What a runner failure says of the rows a column that is to become required has no value in. */
+function rowsWithoutValueSummary(required, rows) {
+	const { table, column } = required;
+	if (required.reason === "newField") return `"${table}" has ${rows} ${rows === 1 ? "row" : "rows"}, so the new required column "${column}" cannot be added: it can be added to an empty table only.`;
+	const counted = `${rows} ${rows === 1 ? "row" : "rows"} of "${table}"`;
+	if (required.reason === "backfillMissedRows") return `${counted} still ${rows === 1 ? "holds" : "hold"} NULL in "${column}" after its backfill step, so it cannot become required.`;
+	return `${counted} ${rows === 1 ? "holds" : "hold"} NULL in "${column}", so it cannot become required.`;
+}
+function migrationRange(edges, operationIndex, operationCount) {
+	let start = 0;
+	for (const edge of edges) {
+		const end = start + edge.operationCount;
+		if (operationIndex < end) return {
+			start,
+			end
+		};
+		start = end;
+	}
+	return {
+		start: 0,
+		end: operationCount
+	};
+}
+/**
+* The marks of the steps of `operations` that belong to the same migration as the operation at
+* `operationIndex`, in plan order: `edges` say how many operations each migration of the plan has.
+*/
+function requiredColumnsOfMigration(operations, edges, operationIndex) {
+	const { start, end } = migrationRange(edges, operationIndex, operations.length);
+	return operations.slice(start, end).flatMap((operation, offset) => [
+		...operation.precheck,
+		...operation.execute,
+		...operation.postcheck
+	].flatMap((step) => {
+		const required = requiredColumnOf(step);
+		return required === void 0 ? [] : [{
+			operation,
+			operationIndex: start + offset,
+			required
+		}];
+	}));
+}
+/**
+* A runner failure's summary and reports for the rows that columns becoming required have no value
+* in. The failed operation's marks are counted first, and the first of them with such rows is the
+* one the summary names; undefined when none has any. The other marks of the same migration are
+* counted after it, until a count fails, such as for a column an earlier operation adds, so that
+* the advice can name every field that needs a value.
+*/
+async function rowsWithoutValueFailure(input) {
+	const report = (mark, rows) => ({
+		field: fieldOfColumn(input.contract, mark.required.table, mark.required.column),
+		reason: mark.required.reason,
+		rows,
+		operationIndex: mark.operationIndex
+	});
+	for (const mark of input.failed) {
+		const rows = await input.count(mark);
+		if (rows === 0) continue;
+		const reports = [report(mark, rows)];
+		for (const other of input.others) {
+			if (other.required.table === mark.required.table && other.required.column === mark.required.column) continue;
+			let otherRows;
+			try {
+				otherRows = await input.count(other);
+			} catch {
+				break;
+			}
+			if (otherRows > 0) reports.push(report(other, otherRows));
+		}
+		return {
+			summary: rowsWithoutValueSummary(mark.required, rows),
+			reports
+		};
+	}
+}
+/** Keywords that end an expression and continue the statement around it. */
+const STATEMENT_KEYWORDS = /* @__PURE__ */ new Set([
+	"FROM",
+	"WHERE",
+	"UNION",
+	"INTERSECT",
+	"EXCEPT",
+	"GROUP",
+	"ORDER",
+	"HAVING",
+	"LIMIT",
+	"RETURNING",
+	"WINDOW"
+]);
+const WORD = /[A-Za-z_][A-Za-z0-9_$]*/y;
+const DOLLAR_QUOTE = /\$[A-Za-z_]*\$/y;
+function quoteAt(text, index, quoting) {
+	return quoting.find((quote) => text.slice(index, index + quote.open.length).toUpperCase() === quote.open.toUpperCase());
+}
+function endOfQuote(text, start, quote) {
+	let index = start + quote.open.length;
+	while (index < text.length) {
+		if (quote.backslashEscapes && text[index] === "\\") {
+			index += 2;
+			continue;
+		}
+		if (text.startsWith(quote.close, index)) {
+			const after = index + quote.close.length;
+			if (!quote.doubledCloseEscapes || !text.startsWith(quote.close, after)) return after;
+			index = after + quote.close.length;
+			continue;
+		}
+		index += 1;
+	}
+}
+/**
+* Returns what in `text` could end or extend the statement a migration writes it into, such as the
+* conversion of an `ALTER COLUMN … USING` clause or a column of an `INSERT … SELECT` list, or
+* undefined when it finds nothing. Text inside the quotes of `quoting` may hold anything; outside
+* them the text may not hold a semicolon, a SQL comment, dollar quoting, or, outside parentheses
+* and brackets, a comma or a keyword that would end the expression. `FROM` directly after
+* `DISTINCT`, as in `IS DISTINCT FROM`, belongs to the expression. It checks for these mistakes
+* only; it does not parse the SQL.
+*/
+function checkSqlExpressionText(text, quoting) {
+	let depth = 0;
+	let index = 0;
+	let previousWord;
+	while (index < text.length) {
+		const character = text[index] ?? "";
+		const quote = quoteAt(text, index, quoting);
+		if (quote !== void 0) {
+			const end = endOfQuote(text, index, quote);
+			if (end === void 0) return "a quote that is not closed";
+			index = end;
+			previousWord = void 0;
+			continue;
+		}
+		if (character === ";") return "a semicolon outside a quoted literal";
+		if (text.startsWith("--", index) || text.startsWith("/*", index)) return "a SQL comment";
+		DOLLAR_QUOTE.lastIndex = index;
+		if (character === "$" && DOLLAR_QUOTE.test(text)) return "dollar quoting";
+		if (character === "," && depth === 0) return "a comma outside parentheses";
+		if (character === "(" || character === "[") depth += 1;
+		if (character === ")" || character === "]") {
+			depth -= 1;
+			if (depth < 0) return "parentheses that do not match";
+		}
+		WORD.lastIndex = index;
+		const word = /[A-Za-z_]/.test(character) ? WORD.exec(text)?.[0].toUpperCase() : void 0;
+		if (word !== void 0) {
+			if (depth === 0 && STATEMENT_KEYWORDS.has(word) && !(word === "FROM" && previousWord === "DISTINCT")) return `the keyword ${word} outside parentheses`;
+			previousWord = word;
+			index += word.length;
+			continue;
+		}
+		if (!/\s/.test(character)) previousWord = void 0;
+		index += 1;
+	}
+	return depth === 0 ? void 0 : "parentheses that do not match";
+}
+/** Whether `slot` is a placeholder the user has not filled yet. */
+function isUnfilledSlot(slot) {
+	return slot?.kind === "placeholder";
+}
+/** The SQL of a written slot; undefined for an unfilled one or none. */
+function sqlOfSlot(slot) {
+	return slot?.kind === "sql" ? slot.sql : void 0;
+}
+/** The slot as `migration.ts` writes it: SQL text written through `sql`, or a `placeholder(...)` call. */
+function slotSource(slot, sql) {
+	return slot.kind === "placeholder" ? `placeholder(${jsonToTsSource(slot.slot)})` : sql.source(slot.sql);
+}
 /** `moduleSpecifier` is the module the generated file imports `sql` from. */
 function createSqlTextSources(moduleSpecifier) {
 	let usesTag = false;
@@ -2052,6 +2334,44 @@ function detectTableNameCaseChanges(input) {
 	}
 	return conflicts;
 }
+/**
+* Whether a required column the plan adds to a table with rows may take one temporary value in
+* every row. Not when it is in the primary key, a unique constraint or a foreign key, which one
+* value in every row would break, and not when its values come from a value set, since no one value
+* stands for every member. Such a column is added for an empty table only.
+*/
+function columnTakesTemporaryValue(table, column) {
+	return table.columns[column]?.valueSet === void 0 && !(table.primaryKey?.columns.includes(column) ?? false) && !table.uniques.some(({ columns }) => columns.includes(column)) && !table.foreignKeys.some(({ source }) => source.columns.includes(column));
+}
+const ConvertedColumnMeta = type({ convertedColumn: {
+	table: "string",
+	column: "string",
+	by: "'cast' | 'conversion'"
+} });
+/**
+* The meta of a step that converts the values of `column` in `table` to the column's new type, or
+* checks that it did. When the step fails, the runner names the field that stores the column.
+*/
+function convertedColumnMeta(table, column, by) {
+	return { convertedColumn: {
+		table,
+		column,
+		by
+	} };
+}
+/** The column a step converts to its new type, as {@link convertedColumnMeta} marks it. */
+function convertedColumnOf(step) {
+	const meta = ConvertedColumnMeta(step.meta ?? {});
+	return meta instanceof type.errors ? void 0 : meta.convertedColumn;
+}
+/**
+* The field of `contract` whose column a failed step converts, or undefined when the step
+* converts no column, no field stores the column, or tables of two storage namespaces share its name.
+*/
+function unconvertedFieldOf(step, contract) {
+	const converted = convertedColumnOf(step);
+	return converted === void 0 ? void 0 : fieldOfColumn(contract, converted.table, converted.column);
+}
 function temporalStringAuthoringPresets(input) {
 	const presets = temporalAuthoringPresets(input);
 	return {
@@ -2099,6 +2419,6 @@ function temporalCodecPresetWithPrecision(input) {
 }
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { temporalCodecPresetWithPrecision as A, resolveColumnRenameAgainst as C, sqlTypeLookupsOf as D, runnerSuccess as E, unknownCallNames as M, unmatchedColumnRename as N, storageNameOfOperation as O, unmatchedTableRename as P, plannerSuccess as S, runnerFailure as T, partitionIssuesByControlPolicy as _, contractNamespaceToSchemaIR as a, planStatements as b, control_default as c, detectDestructiveChanges as d, detectTableNameCaseChanges as f, partitionCallsByControlPolicy as g, modelRenameStorageEffect as h, assembleAuthoringContributions as i, temporalStringAuthoringPresets as j, subjectsOfCalls as k, createMigrationPlan as l, fieldRenameStorageEffect as m, INIT_ADDITIVE_POLICY as n, contractToSchemaIR as o, fieldEventStorage as p, TABLE_NAME_CASE_CHANGED_CODE as r, controlPolicyForCall as s, COLUMN_RENAME_UNMATCHED_CODE as t, createSqlTextSources as u, planFieldEventCalls as v, resolveTableRenameAgainst as w, plannerFailure as x, planFieldEventOperations as y };
+export { plannerFailure as A, runnerSuccess as B, isUnfilledSlot as C, planFieldEventCalls as D, partitionIssuesByControlPolicy as E, resolveColumnRenameAgainst as F, subjectsOfCalls as G, sqlOfSlot as H, resolveTableRenameAgainst as I, unconvertedFieldOf as J, temporalCodecPresetWithPrecision as K, rowsWithoutValueFailure as L, requiredColumnMeta as M, requiredColumnOf as N, planFieldEventOperations as O, requiredColumnsOfMigration as P, rowsWithoutValueSummary as R, fieldStatementColumns as S, partitionCallsByControlPolicy as T, sqlTypeLookupsOf as U, slotSource as V, storageNameOfOperation as W, unmatchedColumnRename as X, unknownCallNames as Y, unmatchedTableRename as Z, detectDestructiveChanges as _, assembleAuthoringContributions as a, fieldOfColumn as b, columnTakesTemporaryValue as c, controlPolicyForCall as d, control_default as f, createSqlTextSources as g, createMigrationPlan as h, appliedStatementsInOrder as i, plannerSuccess as j, planStatements as k, contractNamespaceToSchemaIR as l, convertedColumnOf as m, INIT_ADDITIVE_POLICY as n, backfillOfDefaultedField as o, convertedColumnMeta as p, temporalStringAuthoringPresets as q, TABLE_NAME_CASE_CHANGED_CODE as r, checkSqlExpressionText as s, COLUMN_RENAME_UNMATCHED_CODE as t, contractToSchemaIR as u, detectTableNameCaseChanges as v, modelRenameStorageEffect as w, fieldRenameStorageEffect as x, fieldEventStorage as y, runnerFailure as z };
 
-//# sourceMappingURL=control-uICV4VAt.mjs.map
+//# sourceMappingURL=control-Bvnz4Uk4.mjs.map