@baseplate-dev/plugin-auth 0.6.17 → 0.6.19

package/dist/web/assets/model-utils-C0WDb_Ec.js

@@ -1,1599 +0,0 @@
-import { n as __mf_0 } from "./_virtual_mf___mfe_internal__plugin_mf_2_auth__loadShare__zod__loadShare__.js-BEZ7A-cz.js";
-//#region ../../packages/project-builder-lib/dist/plugins/spec/types.js
-/**
-* Creates a plugin spec with init and use phases.
-*
-* @example
-* ```typescript
-* const mySpec = createPluginSpec('core/my-spec', {
-*   initializer: () => {
-*     const items = new Map<string, Item>();
-*     return {
-*       init: {
-*         register: (item: Item) => items.set(item.name, item),
-*       },
-*       use: () => ({
-*         get: (name: string) => items.get(name),
-*         getAll: () => [...items.values()],
-*       }),
-*     };
-*   },
-* });
-* ```
-*
-* @param name - Unique identifier for the spec (e.g., 'core/my-spec')
-* @param options - Options including the initializer function
-* @returns A plugin spec that can be used with SpecStore
-*/
-function createPluginSpec(name, options) {
-	const { initializer } = options;
-	return {
-		type: "plugin-spec",
-		name,
-		initializer
-	};
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/_internal/compareValues.mjs
-function nullishRank(value) {
-	if (value === null) return 1;
-	if (value === void 0) return 2;
-	return 0;
-}
-function compareAscending(a, b) {
-	const aRank = nullishRank(a);
-	const bRank = nullishRank(b);
-	if (aRank < bRank) return -1;
-	if (aRank > bRank) return 1;
-	if (aRank !== 0) return 0;
-	if (a < b) return -1;
-	if (a > b) return 1;
-	return 0;
-}
-function compareValues(a, b, order) {
-	return order === "asc" ? compareAscending(a, b) : compareAscending(b, a);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/array/orderBy.mjs
-/**
-* Sorts an array of objects based on the given `criteria` and their corresponding order directions.
-*
-* - If you provide keys, it sorts the objects by the values of those keys.
-* - If you provide functions, it sorts based on the values returned by those functions.
-*
-* The function returns the array of objects sorted in corresponding order directions.
-* If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
-* If the number of orders is less than the number of criteria, it uses the last order for the rest of the criteria.
-*
-* @template T - The type of elements in the array.
-* @param arr - The array of objects to be sorted.
-* @param criteria  - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
-* @param orders - An array of order directions ('asc' for ascending or 'desc' for descending).
-* @returns The sorted array.
-*
-* @example
-* // Sort an array of objects by 'user' in ascending order and 'age' in descending order.
-* const users = [
-*   { user: 'fred', age: 48 },
-*   { user: 'barney', age: 34 },
-*   { user: 'fred', age: 40 },
-*   { user: 'barney', age: 36 },
-* ];
-*
-* const result = orderBy(users, [obj => obj.user, 'age'], ['asc', 'desc']);
-* // result will be:
-* // [
-* //   { user: 'barney', age: 36 },
-* //   { user: 'barney', age: 34 },
-* //   { user: 'fred', age: 48 },
-* //   { user: 'fred', age: 40 },
-* // ]
-*/
-function orderBy(arr, criteria, orders) {
-	return arr.slice().sort((a, b) => {
-		const ordersLength = orders.length;
-		for (let i = 0; i < criteria.length; i++) {
-			const order = ordersLength > i ? orders[i] : orders[ordersLength - 1];
-			const criterion = criteria[i];
-			const criterionIsFunction = typeof criterion === "function";
-			const result = compareValues(criterionIsFunction ? criterion(a) : a[criterion], criterionIsFunction ? criterion(b) : b[criterion], order);
-			if (result !== 0) return result;
-		}
-		return 0;
-	});
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/array/sortBy.mjs
-/**
-* Sorts an array of objects based on the given `criteria`.
-*
-* - If you provide keys, it sorts the objects by the values of those keys.
-* - If you provide functions, it sorts based on the values returned by those functions.
-*
-* The function returns the array of objects sorted in ascending order.
-* If two objects have the same value for the current criterion, it uses the next criterion to determine their order.
-*
-* @template T - The type of the objects in the array.
-* @param arr - The array of objects to be sorted.
-* @param criteria - The criteria for sorting. This can be an array of object keys or functions that return values used for sorting.
-* @returns The sorted array.
-*
-* @example
-* const users = [
-*  { user: 'foo', age: 24 },
-*  { user: 'bar', age: 7 },
-*  { user: 'foo', age: 8 },
-*  { user: 'bar', age: 29 },
-* ];
-*
-* sortBy(users, ['user', 'age']);
-* sortBy(users, [obj => obj.user, 'age']);
-* // results will be:
-* // [
-* //   { user : 'bar', age: 7 },
-* //   { user : 'bar', age: 29 },
-* //   { user : 'foo', age: 8 },
-* //   { user : 'foo', age: 24 },
-* // ]
-*/
-function sortBy(arr, criteria) {
-	return orderBy(arr, criteria, ["asc"]);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/_internal/globalThis.mjs
-var globalThis_ = typeof globalThis === "object" && globalThis || typeof window === "object" && window || typeof self === "object" && self || typeof global === "object" && global || (function() {
-	return this;
-})();
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/function/noop.mjs
-/**
-* A no-operation function that does nothing.
-* This can be used as a placeholder or default function.
-*
-* @example
-* noop(); // Does nothing
-*
-* @returns This function does not return anything.
-*/
-function noop() {}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isBuffer.mjs
-/**
-* Checks if the given value is a Buffer instance.
-*
-* This function tests whether the provided value is an instance of Buffer.
-* It returns `true` if the value is a Buffer, and `false` otherwise.
-*
-* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Buffer`.
-*
-* @param x - The value to check if it is a Buffer.
-* @returns Returns `true` if `x` is a Buffer, else `false`.
-*
-* @example
-* const buffer = Buffer.from("test");
-* console.log(isBuffer(buffer)); // true
-*
-* const notBuffer = "not a buffer";
-* console.log(isBuffer(notBuffer)); // false
-*/
-function isBuffer(x) {
-	return typeof globalThis_.Buffer !== "undefined" && globalThis_.Buffer.isBuffer(x);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
-function getSymbols(object) {
-	return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
-/**
-* Gets the `toStringTag` of `value`.
-*
-* @private
-* @param {T} value The value to query.
-* @returns {string} Returns the `Object.prototype.toString.call` result.
-*/
-function getTag(value) {
-	if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
-	return Object.prototype.toString.call(value);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
-var regexpTag = "[object RegExp]";
-var stringTag = "[object String]";
-var numberTag = "[object Number]";
-var booleanTag = "[object Boolean]";
-var argumentsTag = "[object Arguments]";
-var symbolTag = "[object Symbol]";
-var dateTag = "[object Date]";
-var mapTag = "[object Map]";
-var setTag = "[object Set]";
-var arrayTag = "[object Array]";
-var functionTag = "[object Function]";
-var arrayBufferTag = "[object ArrayBuffer]";
-var objectTag = "[object Object]";
-var errorTag = "[object Error]";
-var dataViewTag = "[object DataView]";
-var uint8ArrayTag = "[object Uint8Array]";
-var uint8ClampedArrayTag = "[object Uint8ClampedArray]";
-var uint16ArrayTag = "[object Uint16Array]";
-var uint32ArrayTag = "[object Uint32Array]";
-var bigUint64ArrayTag = "[object BigUint64Array]";
-var int8ArrayTag = "[object Int8Array]";
-var int16ArrayTag = "[object Int16Array]";
-var int32ArrayTag = "[object Int32Array]";
-var bigInt64ArrayTag = "[object BigInt64Array]";
-var float32ArrayTag = "[object Float32Array]";
-var float64ArrayTag = "[object Float64Array]";
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
-/**
-* Checks if a given value is a plain object.
-*
-* @param value - The value to check.
-* @returns True if the value is a plain object, otherwise false.
-*
-* @example
-* ```typescript
-* // ✅👇 True
-*
-* isPlainObject({ });                       // ✅
-* isPlainObject({ key: 'value' });          // ✅
-* isPlainObject({ key: new Date() });       // ✅
-* isPlainObject(new Object());              // ✅
-* isPlainObject(Object.create(null));       // ✅
-* isPlainObject({ nested: { key: true} });  // ✅
-* isPlainObject(new Proxy({}, {}));         // ✅
-* isPlainObject({ [Symbol('tag')]: 'A' });  // ✅
-*
-* // ✅👇 (cross-realms, node context, workers, ...)
-* const runInNewContext = await import('node:vm').then(
-*     (mod) => mod.runInNewContext
-* );
-* isPlainObject(runInNewContext('({})'));   // ✅
-*
-* // ❌👇 False
-*
-* class Test { };
-* isPlainObject(new Test())           // ❌
-* isPlainObject(10);                  // ❌
-* isPlainObject(null);                // ❌
-* isPlainObject('hello');             // ❌
-* isPlainObject([]);                  // ❌
-* isPlainObject(new Date());          // ❌
-* isPlainObject(new Uint8Array([1])); // ❌
-* isPlainObject(Buffer.from('ABC'));  // ❌
-* isPlainObject(Promise.resolve({})); // ❌
-* isPlainObject(Object.create({}));   // ❌
-* isPlainObject(new (class Cls {}));  // ❌
-* isPlainObject(globalThis);          // ❌,
-* ```
-*/
-function isPlainObject(value) {
-	if (!value || typeof value !== "object") return false;
-	const proto = Object.getPrototypeOf(value);
-	if (!(proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null)) return false;
-	return Object.prototype.toString.call(value) === "[object Object]";
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/compat/util/eq.mjs
-/**
-* Performs a `SameValueZero` comparison between two values to determine if they are equivalent.
-*
-* @param value The value to compare.
-* @param other The other value to compare.
-* @returns Returns `true` if the values are equivalent, else `false`.
-*
-* @example
-* eq(1, 1); // true
-* eq(0, -0); // true
-* eq(NaN, NaN); // true
-* eq('a', Object('a')); // false
-*/
-function eq(value, other) {
-	return value === other || Number.isNaN(value) && Number.isNaN(other);
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
-/**
-* Compares two values for equality using a custom comparison function.
-*
-* The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison.
-*
-* This function also uses the custom equality function to compare values inside objects,
-* arrays, maps, sets, and other complex structures, ensuring a deep comparison.
-*
-* This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases.
-*
-* The custom comparison function can take up to six parameters:
-* - `x`: The value from the first object `a`.
-* - `y`: The value from the second object `b`.
-* - `property`: The property key used to get `x` and `y`.
-* - `xParent`: The parent of the first value `x`.
-* - `yParent`: The parent of the second value `y`.
-* - `stack`: An internal stack (Map) to handle circular references.
-*
-* @param a - The first value to compare.
-* @param b - The second value to compare.
-* @param areValuesEqual - A function to customize the comparison.
-*   If it returns a boolean, that result will be used. If it returns undefined,
-*   the default equality comparison will be used.
-* @returns `true` if the values are equal according to the customizer, otherwise `false`.
-*
-* @example
-* const customizer = (a, b) => {
-*   if (typeof a === 'string' && typeof b === 'string') {
-*     return a.toLowerCase() === b.toLowerCase();
-*   }
-* };
-* isEqualWith('Hello', 'hello', customizer); // true
-* isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true
-* isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true
-*/
-function isEqualWith(a, b, areValuesEqual) {
-	return isEqualWithImpl(a, b, void 0, void 0, void 0, void 0, areValuesEqual);
-}
-function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
-	const result = areValuesEqual(a, b, property, aParent, bParent, stack);
-	if (result !== void 0) return result;
-	if (typeof a === typeof b) switch (typeof a) {
-		case "bigint":
-		case "string":
-		case "boolean":
-		case "symbol":
-		case "undefined": return a === b;
-		case "number": return a === b || Object.is(a, b);
-		case "function": return a === b;
-		case "object": return areObjectsEqual(a, b, stack, areValuesEqual);
-	}
-	return areObjectsEqual(a, b, stack, areValuesEqual);
-}
-function areObjectsEqual(a, b, stack, areValuesEqual) {
-	if (Object.is(a, b)) return true;
-	let aTag = getTag(a);
-	let bTag = getTag(b);
-	if (aTag === "[object Arguments]") aTag = objectTag;
-	if (bTag === "[object Arguments]") bTag = objectTag;
-	if (aTag !== bTag) return false;
-	switch (aTag) {
-		case stringTag: return a.toString() === b.toString();
-		case numberTag: return eq(a.valueOf(), b.valueOf());
-		case booleanTag:
-		case dateTag:
-		case symbolTag: return Object.is(a.valueOf(), b.valueOf());
-		case regexpTag: return a.source === b.source && a.flags === b.flags;
-		case functionTag: return a === b;
-	}
-	stack = stack ?? /* @__PURE__ */ new Map();
-	const aStack = stack.get(a);
-	const bStack = stack.get(b);
-	if (aStack != null && bStack != null) return aStack === b;
-	stack.set(a, b);
-	stack.set(b, a);
-	try {
-		switch (aTag) {
-			case mapTag:
-				if (a.size !== b.size) return false;
-				for (const [key, value] of a.entries()) if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) return false;
-				return true;
-			case setTag: {
-				if (a.size !== b.size) return false;
-				const aValues = Array.from(a.values());
-				const bValues = Array.from(b.values());
-				for (let i = 0; i < aValues.length; i++) {
-					const aValue = aValues[i];
-					const index = bValues.findIndex((bValue) => {
-						return isEqualWithImpl(aValue, bValue, void 0, a, b, stack, areValuesEqual);
-					});
-					if (index === -1) return false;
-					bValues.splice(index, 1);
-				}
-				return true;
-			}
-			case arrayTag:
-			case uint8ArrayTag:
-			case uint8ClampedArrayTag:
-			case uint16ArrayTag:
-			case uint32ArrayTag:
-			case bigUint64ArrayTag:
-			case int8ArrayTag:
-			case int16ArrayTag:
-			case int32ArrayTag:
-			case bigInt64ArrayTag:
-			case float32ArrayTag:
-			case float64ArrayTag:
-				if (isBuffer(a) !== isBuffer(b)) return false;
-				if (a.length !== b.length) return false;
-				for (let i = 0; i < a.length; i++) if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) return false;
-				return true;
-			case arrayBufferTag:
-				if (a.byteLength !== b.byteLength) return false;
-				return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
-			case dataViewTag:
-				if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) return false;
-				return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
-			case errorTag: return a.name === b.name && a.message === b.message;
-			case objectTag: {
-				if (!(areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || isPlainObject(a) && isPlainObject(b))) return false;
-				const aKeys = [...Object.keys(a), ...getSymbols(a)];
-				const bKeys = [...Object.keys(b), ...getSymbols(b)];
-				if (aKeys.length !== bKeys.length) return false;
-				for (let i = 0; i < aKeys.length; i++) {
-					const propKey = aKeys[i];
-					const aProp = a[propKey];
-					if (!Object.hasOwn(b, propKey)) return false;
-					const bProp = b[propKey];
-					if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) return false;
-				}
-				return true;
-			}
-			default: return false;
-		}
-	} finally {
-		stack.delete(a);
-		stack.delete(b);
-	}
-}
-//#endregion
-//#region ../../node_modules/.pnpm/es-toolkit@1.50.0/node_modules/es-toolkit/dist/predicate/isEqual.mjs
-/**
-* Checks if two values are equal, including support for `Date`, `RegExp`, and deep object comparison.
-*
-* @param a - The first value to compare.
-* @param b - The second value to compare.
-* @returns `true` if the values are equal, otherwise `false`.
-*
-* @example
-* isEqual(1, 1); // true
-* isEqual({ a: 1 }, { a: 1 }); // true
-* isEqual(/abc/g, /abc/g); // true
-* isEqual(new Date('2020-01-01'), new Date('2020-01-01')); // true
-* isEqual([1, 2, 3], [1, 2, 3]); // true
-*/
-function isEqual(a, b) {
-	return isEqualWith(a, b, noop);
-}
-//#endregion
-//#region ../../packages/utils/dist/field-map/field-map.js
-/**
-* Field container for a single value that cannot be overridden once set
-*/
-var ScalarContainer = class {
-	_value;
-	defaultValue;
-	isSet = false;
-	setBySource;
-	getDynamicSource;
-	constructor(defaultValue, options) {
-		this.defaultValue = defaultValue;
-		this.getDynamicSource = options?.getDynamicSource;
-	}
-	getValue() {
-		return this._value === void 0 ? this.defaultValue : this._value;
-	}
-	set(value, source) {
-		const setBySource = source ?? this.getDynamicSource?.() ?? "unknown";
-		if (this.isSet) throw new Error(`Value has already been set by ${this.setBySource} and cannot be overwritten by ${setBySource}`);
-		this._value = value;
-		this.isSet = true;
-		this.setBySource = setBySource;
-	}
-};
-var ArrayContainer = class {
-	_stripDuplicates;
-	_value;
-	constructor(initialValue, options) {
-		this._stripDuplicates = options?.stripDuplicates ?? false;
-		this._value = initialValue ?? [];
-	}
-	push(...items) {
-		let currentValue = this._value;
-		if (this._stripDuplicates) currentValue = [.../* @__PURE__ */ new Set([...currentValue, ...items])];
-		else currentValue = [...currentValue, ...items];
-		this._value = currentValue;
-	}
-	getValue() {
-		return this._value;
-	}
-};
-var ObjectContainer = class {
-	map;
-	getDynamicSource;
-	constructor(initialValue, options) {
-		this.getDynamicSource = options?.getDynamicSource;
-		this.map = new Map(Object.entries(initialValue).map(([key, value]) => [key, {
-			value,
-			setBySource: this.getDynamicSource?.()
-		}]));
-	}
-	set(key, value, source) {
-		const existingValue = this.map.get(key);
-		const setBySource = source ?? this.getDynamicSource?.() ?? "unknown";
-		if (existingValue?.setBySource) throw new Error(`Value for key ${key} has already been set by ${existingValue.setBySource} and cannot be overwritten by ${setBySource}`);
-		this.map.set(key, {
-			value,
-			setBySource
-		});
-	}
-	merge(value, source) {
-		const mergeSource = source ?? this.getDynamicSource?.();
-		for (const [key, val] of Object.entries(value)) this.set(key, val, mergeSource);
-	}
-	getValue() {
-		return Object.fromEntries([...this.map.entries()].map(([key, value]) => [key, value.value]));
-	}
-};
-var MapContainer = class {
-	_value;
-	getDynamicSource;
-	constructor(initialValue, options) {
-		this.getDynamicSource = options?.getDynamicSource;
-		const initialMap = initialValue ?? /* @__PURE__ */ new Map();
-		this._value = new Map([...initialMap.entries()].map(([key, value]) => [key, {
-			value,
-			setBySource: this.getDynamicSource?.()
-		}]));
-	}
-	set(key, value, source) {
-		const existingValue = this._value.get(key);
-		const setBySource = source ?? this.getDynamicSource?.() ?? "unknown";
-		if (existingValue?.setBySource) throw new Error(`Value for key ${key} has already been set by ${existingValue.setBySource} and cannot be overwritten by ${setBySource}`);
-		this._value.set(key, {
-			value,
-			setBySource
-		});
-	}
-	merge(value, source) {
-		const mergeSource = source ?? this.getDynamicSource?.();
-		for (const [key, val] of value.entries()) this.set(key, val, mergeSource);
-	}
-	mergeObj(value, source) {
-		const mergeSource = source ?? this.getDynamicSource?.();
-		for (const [key, val] of Object.entries(value)) this.set(key, val, mergeSource);
-	}
-	getValue() {
-		return new Map([...this._value.entries()].map(([key, value]) => [key, value.value]));
-	}
-};
-/**
-* Named field container
-*
-* This container stores objects that contains a name field that can be used for
-* detecting duplicate names.
-*/
-var NamedArrayFieldContainer = class {
-	_value;
-	getDynamicSource;
-	constructor(initialValue, options) {
-		this.getDynamicSource = options?.getDynamicSource;
-		const value = initialValue ?? [];
-		this._value = new Map(value.map((val) => [val.name, {
-			value: val,
-			setBySource: this.getDynamicSource?.()
-		}]));
-	}
-	add(value, source) {
-		const existingValue = this._value.get(value.name);
-		const setBySource = source ?? this.getDynamicSource?.() ?? "unknown";
-		if (existingValue?.setBySource) throw new Error(`Value for name ${value.name} has already been set by ${existingValue.setBySource} and cannot be overwritten by ${setBySource}`);
-		this._value.set(value.name, {
-			value,
-			setBySource
-		});
-	}
-	addMany(values, source) {
-		for (const value of values) this.add(value, source);
-	}
-	getValue() {
-		return sortBy([...this._value.values()].map((value) => value.value), [(v) => v.name]);
-	}
-};
-/**
-* Named array field container that returns a map of names to values
-*/
-var NamedArrayToMapFieldContainer = class {
-	_namedFieldContainer;
-	constructor(initialValue, options) {
-		this._namedFieldContainer = new NamedArrayFieldContainer(initialValue, options);
-	}
-	add(value, source) {
-		this._namedFieldContainer.add(value, source);
-	}
-	addMany(values, source) {
-		this._namedFieldContainer.addMany(values, source);
-	}
-	getValue() {
-		return new Map(this._namedFieldContainer.getValue().map((value) => [value.name, value]));
-	}
-};
-var MapOfMapsContainer = class {
-	_value;
-	getDynamicSource;
-	constructor(initialValue, options) {
-		this.getDynamicSource = options?.getDynamicSource;
-		const initialMap = initialValue ?? /* @__PURE__ */ new Map();
-		this._value = new Map([...initialMap.entries()].map(([key1, innerMap]) => [key1, {
-			value: new Map([...innerMap.entries()].map(([key2, value]) => [key2, {
-				value,
-				setBySource: this.getDynamicSource?.()
-			}])),
-			setBySource: this.getDynamicSource?.()
-		}]));
-	}
-	set(key1, key2, value, source) {
-		const existingOuterValue = this._value.get(key1);
-		const setBySource = source ?? this.getDynamicSource?.() ?? "unknown";
-		if (!existingOuterValue) {
-			const newInnerMap = /* @__PURE__ */ new Map([[key2, {
-				value,
-				setBySource
-			}]]);
-			this._value.set(key1, {
-				value: newInnerMap,
-				setBySource
-			});
-			return;
-		}
-		const existingInnerValue = existingOuterValue.value.get(key2);
-		if (existingInnerValue?.setBySource) throw new Error(`Value for keys ${key1}+${key2} has already been set by ${existingInnerValue.setBySource} and cannot be overwritten by ${setBySource}`);
-		existingOuterValue.value.set(key2, {
-			value,
-			setBySource
-		});
-	}
-	merge(key1, value, source) {
-		const mergeSource = source ?? this.getDynamicSource?.() ?? "unknown";
-		for (const [key2, val] of value.entries()) this.set(key1, key2, val, mergeSource);
-	}
-	mergeObj(key1, value, source) {
-		const mergeSource = source ?? this.getDynamicSource?.() ?? "unknown";
-		for (const [key2, val] of Object.entries(value)) this.set(key1, key2, val, mergeSource);
-	}
-	getValue() {
-		return new Map([...this._value.entries()].map(([key1, outerValue]) => [key1, new Map([...outerValue.value.entries()].map(([key2, innerValue]) => [key2, innerValue.value]))]));
-	}
-};
-var FieldMapSchemaBuilder = class {
-	options;
-	constructor(options) {
-		this.options = options;
-	}
-	scalar(defaultValue) {
-		return new ScalarContainer(defaultValue, this.options);
-	}
-	string(defaultValue) {
-		return new ScalarContainer(defaultValue, this.options);
-	}
-	number(defaultValue) {
-		return new ScalarContainer(defaultValue, this.options);
-	}
-	boolean(defaultValue) {
-		return new ScalarContainer(defaultValue, this.options);
-	}
-	array(initialValue, options) {
-		return new ArrayContainer(initialValue, options);
-	}
-	object(defaultValue) {
-		return new ObjectContainer(defaultValue, this.options);
-	}
-	map(initialValue) {
-		return new MapContainer(initialValue ?? /* @__PURE__ */ new Map(), this.options);
-	}
-	mapFromObj(initialValue) {
-		return new MapContainer(new Map(Object.entries(initialValue ?? {})), this.options);
-	}
-	namedArray(initialValue) {
-		return new NamedArrayFieldContainer(initialValue, this.options);
-	}
-	namedArrayToMap(initialValue) {
-		return new NamedArrayToMapFieldContainer(initialValue, this.options);
-	}
-	mapOfMaps(initialValue) {
-		return new MapOfMapsContainer(initialValue ?? /* @__PURE__ */ new Map(), this.options);
-	}
-	mapOfMapsFromObj(initialValue) {
-		const map = /* @__PURE__ */ new Map();
-		if (initialValue) for (const [key1, innerObj] of Object.entries(initialValue)) map.set(key1, new Map(Object.entries(innerObj)));
-		return new MapOfMapsContainer(map, this.options);
-	}
-};
-/**
-* Creates a field map with type-safe field definitions
-*/
-function createFieldMap(schemaBuilder, options) {
-	const schema = schemaBuilder(new FieldMapSchemaBuilder(options));
-	return {
-		...schema,
-		getValues: () => {
-			const values = {};
-			for (const [key, container] of Object.entries(schema)) values[key] = container.getValue();
-			return values;
-		}
-	};
-}
-//#endregion
-//#region ../../node_modules/.pnpm/nanoid@6.0.0/node_modules/nanoid/index.browser.js
-var random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
-var customRandom = (alphabet, defaultSize, getRandom) => {
-	let safeByteCutoff = 256 - 256 % alphabet.length;
-	if (safeByteCutoff === 256) {
-		let mask = alphabet.length - 1;
-		return (size = defaultSize) => {
-			if (!size) return "";
-			let id = "";
-			while (true) {
-				let bytes = getRandom(size);
-				let j = size;
-				while (j--) {
-					id += alphabet[bytes[j] & mask];
-					if (id.length >= size) return id;
-				}
-			}
-		};
-	}
-	let step = Math.ceil(409.6 * defaultSize / safeByteCutoff);
-	return (size = defaultSize) => {
-		if (!size) return "";
-		let id = "";
-		while (true) {
-			let bytes = getRandom(step);
-			let j = step;
-			while (j--) if (bytes[j] < safeByteCutoff) {
-				id += alphabet[bytes[j] % alphabet.length];
-				if (id.length >= size) return id;
-			}
-		}
-	};
-};
-var customAlphabet = (alphabet, size = 21) => customRandom(alphabet, size | 0, random);
-//#endregion
-//#region ../../packages/utils/dist/string/random-key.js
-/**
-* Use custom ID generator for characters that be easily selected
-*/
-var customNanoid = customAlphabet(`0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_`, 12);
-/**
-* Generate a random key string made up of numbers, lowercase, and uppercase letters
-* @returns A random key string
-*/
-function randomKey(length = 12) {
-	return customNanoid(length);
-}
-//#endregion
-//#region ../../packages/utils/dist/validators/validation-hint-registry.js
-/**
-* Registry that stores human-readable validation hints on Zod schema instances.
-*
-* Used by `buildTsDescriptionRegistry` to annotate TypeScript type output with
-* validation constraints (e.g., "camelCase", "CONSTANT_CASE") as JSDoc comments.
-*
-* Validators register hints at module load time. The registry is consumed
-* during schema-to-TypeScript conversion to produce annotated output.
-*/
-var validationHintRegistry = __mf_0.registry();
-//#endregion
-//#region ../../packages/utils/dist/validators/case-validators.js
-/**
-* Regex for validating kebab case, e.g. "my-project".
-*/
-var KEBAB_CASE_REGEX = /^[a-z0-9-]+$/;
-/**
-* Regex for validating pascal case, e.g. "MyProject".
-*/
-var PASCAL_CASE_REGEX = /^[A-Z][a-zA-Z0-9]*$/;
-var CASE_VALIDATORS = {
-	/**
-	* Zod validator for validating kebab case, e.g. "my-project".
-	*/
-	KEBAB_CASE: __mf_0.string().regex(KEBAB_CASE_REGEX, { message: "Must be kebab case (e.g. \"my-project\")" }).register(validationHintRegistry, { description: "kebab-case (e.g. \"my-project\")" }),
-	/**
-	* Zod validator for validating pascal case, e.g. "MyProject".
-	*/
-	PASCAL_CASE: __mf_0.string().regex(PASCAL_CASE_REGEX, { message: "Must be pascal case (e.g. \"MyProject\")" }).register(validationHintRegistry, { description: "PascalCase (e.g. \"MyProject\")" }),
-	/**
-	* Zod validator for validating camel case, e.g. "myProject".
-	*/
-	CAMEL_CASE: __mf_0.string().regex(/^[a-z][a-zA-Z0-9]*$/, { message: "Must be camel case (e.g. \"myProject\")" }).register(validationHintRegistry, { description: "camelCase (e.g. \"myProject\")" }),
-	/**
-	* Zod validator for validating constant case, e.g. "MY_PROJECT".
-	*/
-	CONSTANT_CASE: __mf_0.string().regex(/^[A-Z][A-Z0-9_]*$/, { message: "Must be constant case (e.g. \"MY_PROJECT\")" }).register(validationHintRegistry, { description: "CONSTANT_CASE (e.g. \"MY_PROJECT\")" })
-};
-//#endregion
-//#region ../../packages/project-builder-lib/dist/plugins/context/plugin-context.js
-/**
-* Plugin context module for tracking the current plugin being initialized.
-*
-* Uses a simple synchronous context that works on both Node and browser platforms.
-* This is safe because plugin initialization is synchronous and single-threaded.
-*/
-var currentPluginContext;
-/**
-* Runs a function within a plugin context.
-*
-* This sets the current plugin context for the duration of the function execution,
-* allowing nested functions to access the plugin key via `getPluginContext()`.
-*
-* @param context - The plugin context to set
-* @param fn - The function to run within the context
-* @returns The result of the function
-*/
-function runInPluginContext(context, fn) {
-	const prev = currentPluginContext;
-	currentPluginContext = context;
-	try {
-		return fn();
-	} finally {
-		currentPluginContext = prev;
-	}
-}
-/**
-* Gets the current plugin context if one exists.
-*
-* @returns The current plugin context, or undefined if not in a plugin context
-*/
-function getPluginContext() {
-	return currentPluginContext;
-}
-//#endregion
-//#region ../../packages/project-builder-lib/dist/plugins/utils/create-plugin-field-map.js
-/**
-* Creates a field map that automatically tracks which plugin registered each value.
-*
-* Similar to `createConfigFieldMap` in the sync package, this utility uses the
-* current plugin context to track the source of registrations. This enables
-* clear error messages when registration conflicts occur.
-*
-* @example
-* ```typescript
-* const fieldMap = createPluginFieldMap((t) => ({
-*   transformers: t.map<string, Transformer>(),
-* }));
-*
-* // When a plugin tries to overwrite a value:
-* // Error: Value for key 'myTransformer' has already been set by plugin-auth
-* //        and cannot be overwritten by plugin-storage
-* ```
-*
-* @param schemaBuilder - A function that builds the field map schema
-* @returns A field map with automatic source tracking
-*/
-function createPluginFieldMap(schemaBuilder) {
-	return createFieldMap(schemaBuilder, { getDynamicSource: () => getPluginContext()?.pluginKey });
-}
-//#endregion
-//#region ../../packages/project-builder-lib/dist/plugins/utils/create-field-map-spec.js
-/**
-* Creates a plugin spec backed by a FieldMap for automatic source tracking.
-*
-* @param name - Unique identifier for the spec
-* @param schemaBuilder - Function that builds the field map schema
-* @param options - Optional configuration including custom use interface
-*/
-function createFieldMapSpec(name, schemaBuilder, options) {
-	return createPluginSpec(name, { initializer: () => {
-		const fieldMap = createPluginFieldMap(schemaBuilder);
-		return {
-			init: fieldMap,
-			use: () => {
-				const values = fieldMap.getValues();
-				if (options?.use) return options.use(values);
-				return values;
-			}
-		};
-	} });
-}
-//#endregion
-//#region ../../packages/project-builder-lib/dist/references/definition-ref-registry.js
-/**
-* Global registry that stores Baseplate metadata on Zod schema instances.
-*
-* Uses a plain WeakMap to avoid Zod's `$replace<Meta, S>` type substitution
-* which causes "type instantiation excessively deep" errors with complex unions.
-*
-* Stores an array of metadata per schema to support schemas that carry multiple
-* annotations (e.g. a schema that is both an `entity` and a `ref-context`).
-*
-* Used by `withEnt`, `withRef`, `withExpression`, and `refContext` to attach
-* metadata to schema nodes. The parallel schema+data walker reads this registry
-* to extract entity/reference/expression information after validation.
-*/
-var definitionRefRegistry = (() => {
-	const map = /* @__PURE__ */ new WeakMap();
-	return {
-		add(schema, meta) {
-			const existing = map.get(schema);
-			if (existing) {
-				if ((meta.kind === "entity" || meta.kind === "reference") && existing.some((e) => e.kind === meta.kind && e.type === meta.type)) throw new Error(`Duplicate definition ref metadata kind "${meta.kind}" for type "${meta.type.name}" on the same schema instance. This usually means a shared/module-level schema was passed to withEnt/withRef multiple times. Create a fresh schema instance instead.`);
-				existing.push(meta);
-			} else map.set(schema, [meta]);
-		},
-		getAll(schema) {
-			return map.get(schema) ?? [];
-		},
-		has(schema) {
-			return map.has(schema);
-		}
-	};
-})();
-//#endregion
-//#region ../../packages/project-builder-lib/dist/references/expression-parser-spec.js
-/**
-* Plugin spec for registering expression parsers.
-*
-* Expression parsers handle parsing, validation, and rename detection
-* for expression fields in the project definition (e.g., authorizer
-* role expressions).
-*
-* Built-in parsers (authorizer expressions) are registered by core modules.
-* Plugins can register additional parsers during initialization.
-*
-* @example
-* ```typescript
-* createPluginModule({
-*   dependencies: { expressionParsers: expressionParserSpec },
-*   initialize: ({ expressionParsers }) => {
-*     expressionParsers.parsers.set('my-expression', myParser);
-*   },
-* });
-* ```
-*/
-var expressionParserSpec = createFieldMapSpec("core/expression-parsers", (t) => ({ parsers: t.map() }), { use: (values) => ({ getParser: (name) => values.parsers.get(name) }) });
-//#endregion
-//#region ../../packages/project-builder-lib/dist/references/expression-types.js
-/**
-* A pluggable parser for ref expressions.
-*
-* The parser is format-agnostic - the core references system
-* doesn't know or care what format the expressions are in. The parser
-* handles all parsing, validation, and rename handling.
-*
-* Parsers can declare required slots via the TRequiredSlots generic parameter.
-* When a parser requires slots, TypeScript enforces that they are provided
-* when calling `withExpression()`.
-*
-* @typeParam TValue - The type of the raw expression value (e.g., string for TS expressions)
-* @typeParam TParseResult - The type of the parsed result (e.g., AST for TS expressions)
-* @typeParam TRequiredSlots - Record of required slot names to entity types
-*
-* @example
-* ```typescript
-* // A simple parser with no required slots
-* class StubParser extends RefExpressionParser<string, undefined> {
-*   readonly name = 'stub';
-*   parse(): undefined { return undefined; }
-*   getWarnings(): [] { return []; }
-*   getReferencedEntities(): [] { return []; }
-* }
-*
-* // A parser that requires a model slot
-* class AuthorizerParser extends RefExpressionParser<
-*   string,
-*   TsAst,
-*   { model: typeof modelEntityType }
-* > {
-*   readonly name = 'authorizer';
-*   // TypeScript enforces slot requirement in withExpression()
-* }
-* ```
-*/
-var RefExpressionParser = class {
-	/**
-	* One-line summary of the expression language, surfaced to MCP consumers by
-	* `get-entity-schema` so an agent editing this field knows it is a DSL rather
-	* than free-form text. Point at fuller docs rather than restating the grammar.
-	*/
-	description;
-	/**
-	* Convenience method that combines parse() and getWarnings() into a single call.
-	* Parses the expression and returns all validation warnings (including parse errors).
-	*
-	* @param value - The raw expression value
-	* @param projectDef - The project definition for context
-	* @param context - Validation context with project definition and plugin store
-	* @param resolvedSlots - The resolved slot paths for this expression
-	* @returns Array of warnings (empty if valid)
-	*/
-	validate(value, projectDef, context, resolvedSlots) {
-		const parseResult = this.parse(value, projectDef);
-		if (!parseResult.success) return [{ message: parseResult.error }];
-		return this.getWarnings(parseResult.value, context, resolvedSlots);
-	}
-	/**
-	* Phantom property for TRequiredSlots type inference.
-	* This is never actually used at runtime.
-	* @internal
-	*/
-	_requiredSlots;
-};
-//#endregion
-//#region ../../packages/project-builder-lib/dist/references/ref-context-slot.js
-/**
-* Creates a new ref context slot for the given entity type.
-* Each call creates a unique slot, even for the same entity type.
-*
-* @param name - A descriptive name for debugging (shows in Symbol description)
-* @param entityType - The entity type this slot will be associated with
-* @returns A new unique RefContextSlot instance
-*
-* @example
-* ```typescript
-* const modelSlot = createRefContextSlot('modelSlot', modelEntityType);
-* const anotherModelSlot = createRefContextSlot('anotherModelSlot', modelEntityType);
-*
-* // These are different slots despite same entity type
-* modelSlot.id !== anotherModelSlot.id
-* // modelSlot.id.toString() === 'Symbol(modelSlot)'
-* ```
-*/
-function createRefContextSlot(name, entityType) {
-	return {
-		entityType,
-		id: Symbol(name)
-	};
-}
-/**
-* Creates a RefContextSlotMap from a slot definition.
-* Used internally by ctx.refContext().
-*
-* @param slotDefinition - Map of slot names to entity types
-* @returns Map of slot names to RefContextSlot instances
-*/
-function createRefContextSlotMap(slotDefinition) {
-	return Object.fromEntries(Object.entries(slotDefinition).map(([key, entityType]) => [key, createRefContextSlot(key, entityType)]));
-}
-//#endregion
-//#region ../../packages/project-builder-lib/dist/references/extend-parser-context-with-refs.js
-/**
-* Creates a string schema annotated as a reference to another entity.
-*
-* Can be used standalone:
-* ```typescript
-* withRef({ type: modelEnumEntityType, onDelete: 'RESTRICT' })
-* ```
-*
-* Or on the parser context:
-* ```typescript
-* ctx.withRef({ type: modelEnumEntityType, onDelete: 'RESTRICT' })
-* ```
-*/
-function withRef(reference) {
-	const schema = __mf_0.string().min(1);
-	definitionRefRegistry.add(schema, {
-		kind: "reference",
-		type: reference.type,
-		onDelete: reference.onDelete,
-		parentSlot: reference.parentSlot,
-		provides: reference.provides
-	});
-	return schema;
-}
-/**
-* Creates a schema decorator that marks a schema as defining an entity.
-*
-* Can be used with `.apply()`:
-* ```typescript
-* schema.apply(withEnt({ type: modelEntityType, provides: modelSlot }))
-* ```
-*
-* Or via the parser context (2-arg legacy form):
-* ```typescript
-* ctx.withEnt(schema, { type: modelEntityType, provides: modelSlot })
-* ```
-*
-* @param entity - The entity definition input
-* @returns A function that decorates a schema with entity metadata
-*/
-function withEnt(entity) {
-	return (schema) => {
-		const idPath = entity.idPath ?? ["id"];
-		definitionRefRegistry.add(schema, {
-			kind: "entity",
-			type: entity.type,
-			idPath,
-			getNameResolver: entity.getNameResolver,
-			parentSlot: entity.parentSlot,
-			provides: entity.provides,
-			sortByName: entity.sortByName
-		});
-		return schema;
-	};
-}
-/**
-* Creates ref context slots for use within a schema definition.
-* Slots provide type-safe context for parent-child entity relationships.
-*
-* @example
-* ```typescript
-* ctx.refContext(
-*   { modelSlot: modelEntityType },
-*   ({ modelSlot }) =>
-*     ctx.withEnt(schema, {
-*       type: modelEntityType,
-*       provides: modelSlot,
-*     }),
-* );
-* ```
-*/
-function refContext(slotDefinition, schemaBuilder) {
-	const slots = createRefContextSlotMap(slotDefinition);
-	const schema = schemaBuilder(slots);
-	definitionRefRegistry.add(schema, {
-		kind: "ref-context",
-		slots: Object.values(slots)
-	});
-	return schema;
-}
-/**
-* Wraps a value with a ref expression parser for deferred validation.
-* The parser handles all parsing, validation, and rename handling.
-*
-* If the parser declares required slots (via TRequiredSlots), they must be
-* provided as the second argument. TypeScript enforces this at compile time.
-*
-* The parser's `createSchema()` method is called to get a fresh schema
-* instance per call site, allowing per-call metadata to be registered
-* independently in the Baseplate registry.
-*
-* @example
-* ```typescript
-* // Parser without required slots
-* const expressionSchema = ctx.withExpression(simpleParser);
-*
-* // Parser with required slots (TypeScript enforces the second argument)
-* ctx.refContext(
-*   { modelSlot: modelEntityType },
-*   ({ modelSlot }) =>
-*     z.object({
-*       condition: ctx.withExpression(authorizerParser, { model: modelSlot }),
-*     })
-* );
-* ```
-*/
-/**
-* Creates a `withExpression` function that resolves parser refs eagerly
-* from the plugin spec store at schema construction time.
-*/
-function createWithExpression(plugins) {
-	function withExpression(parserOrRef, slots) {
-		let parser;
-		if (parserOrRef instanceof RefExpressionParser) parser = parserOrRef;
-		else {
-			if (!plugins) throw new Error(`PluginSpecStore is required to resolve expression parser ref "${parserOrRef.name}". Ensure plugins are provided to createDefinitionSchemaParserContext.`);
-			const resolved = plugins.use(expressionParserSpec).getParser(parserOrRef.name);
-			if (!resolved) throw new Error(`Expression parser "${parserOrRef.name}" not found in expressionParserSpec. Ensure it is registered via a core module or plugin.`);
-			parser = resolved;
-		}
-		const schema = parser.createSchema();
-		definitionRefRegistry.add(schema, {
-			kind: "expression",
-			parser,
-			slots
-		});
-		return schema;
-	}
-	return withExpression;
-}
-function extendParserContextWithRefs(plugins) {
-	return {
-		withRef,
-		withEnt(schema, entity) {
-			return schema.apply(withEnt(entity));
-		},
-		refContext,
-		withExpression: createWithExpression(plugins)
-	};
-}
-//#endregion
-//#region ../../packages/project-builder-lib/dist/schema/creator/definition-default-registry.js
-/**
-* Registry that stores default-value metadata on Zod schema instances.
-*
-* Uses a WeakMap to avoid interfering with Zod's type system.
-* Annotated by `withDefault()`; read by `cleanDefaultValues()`.
-*/
-var definitionDefaultRegistry = (() => {
-	const map = /* @__PURE__ */ new WeakMap();
-	return {
-		set(schema, meta) {
-			map.set(schema, meta);
-		},
-		get(schema) {
-			return map.get(schema);
-		}
-	};
-})();
-//#endregion
-//#region ../../packages/project-builder-lib/dist/schema/creator/extend-parser-context-with-defaults.js
-/**
-* Creates a schema decorator that applies a default value.
-*
-* Uses `prefault` to ensure defaults are populated during Zod parse, and
-* registers the default value in the registry so `cleanDefaultValues()` can
-* strip matching values during serialization.
-*
-* Can be used standalone with `.apply()`:
-* ```typescript
-* z.boolean().apply(withDefault(false))
-* ```
-*
-* @param defaultValue - The default value to apply
-* @returns A function that decorates a schema with the default value
-*/
-function withDefault(defaultValue) {
-	return (schema) => {
-		const result = schema.prefault(defaultValue);
-		definitionDefaultRegistry.set(result, { defaultValue });
-		return result;
-	};
-}
-/**
-* Extends the parser context with default value handling functionality.
-*
-* @returns An object containing the withDefault method
-*/
-function extendParserContextWithDefaults() {
-	return { withDefault: (schema, defaultValue) => withDefault(defaultValue)(schema) };
-}
-//#endregion
-//#region ../../packages/project-builder-lib/dist/schema/creator/schema-creator.js
-var contextCache = /* @__PURE__ */ new WeakMap();
-function createDefinitionSchemaParserContext(options) {
-	const cached = contextCache.get(options.plugins);
-	if (cached) return cached;
-	const context = {
-		...options,
-		...extendParserContextWithRefs(options.plugins),
-		...extendParserContextWithDefaults()
-	};
-	contextCache.set(options.plugins, context);
-	return context;
-}
-function definitionSchema(creator) {
-	const cache = /* @__PURE__ */ new WeakMap();
-	return (context) => {
-		const cached = cache.get(context);
-		if (cached) return cached;
-		const result = creator(context);
-		cache.set(context, result);
-		return result;
-	};
-}
-/**
-* Creates a schema that requires slots to be passed from parent schemas.
-* Used when a schema needs to reference entities from a parent context.
-*
-* @example
-* ```typescript
-* // Child schema requiring modelSlot from parent
-* export const createModelScalarFieldSchema = definitionSchemaWithSlots(
-*   { modelSlot: modelEntityType },
-*   (ctx, { modelSlot }) =>
-*     ctx.withEnt(schema, {
-*       type: modelScalarFieldEntityType,
-*       parentSlot: modelSlot,
-*     }),
-* );
-*
-* // Called from parent:
-* createModelScalarFieldSchema(ctx, { modelSlot: parentModelSlot })
-* ```
-*/
-function definitionSchemaWithSlots(slotDefinition, creator) {
-	const creatorWithSlots = (context, slots) => creator(context, slots);
-	creatorWithSlots.slotDefinition = slotDefinition;
-	return creatorWithSlots;
-}
-/**
-* Wraps a schema creator that requires slots with placeholder slots,
-* producing a simple schema creator that can be used for validation-only
-* contexts (e.g., React Hook Form).
-*
-* The placeholder slots allow the schema to parse without actual parent context,
-* which is useful when you only need schema validation without ref extraction.
-*
-* @example
-* ```typescript
-* // Schema that normally requires modelSlot from parent
-* const createModelScalarFieldSchema = definitionSchemaWithSlots(
-*   { modelSlot: modelEntityType },
-*   (ctx, { modelSlot }) => ctx.withEnt(schema, { parentSlot: modelSlot }),
-* );
-*
-* // For React Hook Form validation, wrap with placeholder slots
-* const fieldSchema = withPlaceholderSlots(createModelScalarFieldSchema);
-* const zodSchema = fieldSchema(ctx); // No slots needed
-* ```
-*/
-function withPlaceholderSlots(schemaCreator) {
-	return (ctx) => {
-		return schemaCreator(ctx, createRefContextSlotMap(schemaCreator.slotDefinition));
-	};
-}
-//#endregion
-//#region ../../packages/project-builder-lib/dist/references/types.js
-/**
-* Definition of an entity type.
-*/
-var DefinitionEntityType = class {
-	prefix;
-	name;
-	parentType;
-	/**
-	* Creates a new entity type.
-	*
-	* @param name - The name of the entity type.
-	* @param prefix - The prefix of the entity type to use in the ID, defaults to the name.
-	* @param parentType - The type of the parent entity if any
-	*/
-	constructor(name, prefix, parentType) {
-		this.name = name;
-		this.parentType = parentType;
-		this.prefix = prefix ?? name.split("/").pop() ?? name;
-	}
-	/**
-	* Generates a new ID for the entity type.
-	*
-	* @returns The new ID.
-	*/
-	generateNewId() {
-		return `${this.prefix}:${randomKey()}`;
-	}
-	idFromKey(key) {
-		if (!key) return;
-		return `${this.prefix}:${key}`;
-	}
-	keyFromId(id) {
-		const key = id.split(":")[1];
-		if (key === void 0) throw new Error(`Invalid ${this.prefix} id: ${id}`);
-		return key;
-	}
-	isId(id) {
-		return id.startsWith(`${this.prefix}:`);
-	}
-};
-function createEntityType(name, options) {
-	const { parentType, prefix } = options ?? {};
-	return new DefinitionEntityType(name, prefix, parentType);
-}
-//#endregion
-//#region ../../packages/project-builder-lib/dist/schema/features/feature.js
-var featureEntityType = createEntityType("feature");
-var featureNameSchema = CASE_VALIDATORS.KEBAB_CASE;
-var createFeatureSchema = definitionSchema((ctx) => ctx.withEnt(__mf_0.object({
-	id: __mf_0.string(),
-	name: __mf_0.string().min(1).refine((name) => name.split("/").every((part) => featureNameSchema.safeParse(part).success), { message: "Feature name must be lowercase and contain only letters, numbers, and dashes" }),
-	parentRef: ctx.withRef({
-		type: featureEntityType,
-		onDelete: "DELETE_PARENT"
-	}).optional()
-}), {
-	type: featureEntityType,
-	sortByName: true
-}));
-var createFeaturesSchema = definitionSchema((ctx) => __mf_0.array(createFeatureSchema(ctx)).default([]));
-//#endregion
-//#region ../../packages/project-builder-lib/dist/definition/feature/feature-utils.js
-function getRootFeatures(projectDefinition) {
-	return projectDefinition.features.filter((f) => !f.parentRef);
-}
-function getFeatureById(projectDefinition, featureId) {
-	return projectDefinition.features.find((f) => f.id === featureId);
-}
-function getFeatureByIdOrThrow(projectDefinition, featureId) {
-	const feature = getFeatureById(projectDefinition, featureId);
-	if (!feature) throw new Error(`Could not find feature with ID ${featureId}`);
-	return feature;
-}
-function getFeatureChildren(projectDefinition, featureId) {
-	return projectDefinition.features.filter((f) => f.parentRef === featureId);
-}
-function getFeatureName(featureConfig) {
-	return featureConfig.name.split("/").pop() ?? "";
-}
-function getFeatureNameById(projectDefinition, featureId) {
-	return getFeatureName(getFeatureByIdOrThrow(projectDefinition, featureId));
-}
-function getFeaturePathByIdOrThrow(projectDefinition, featureId) {
-	return getFeatureByIdOrThrow(projectDefinition, featureId).name;
-}
-function validateFeatureName(name) {
-	return name.split("/").every((part) => featureNameSchema.safeParse(part).success);
-}
-function ensureFeatureByNameRecursively(projectDefinition, nameOrId) {
-	if (featureEntityType.isId(nameOrId)) return nameOrId;
-	const nameParts = nameOrId.split("/");
-	let lastName = "";
-	let parentRef = void 0;
-	for (const part of nameParts) {
-		const name = [lastName, part].filter(Boolean).join("/");
-		const feature = projectDefinition.features.find((f) => f.name === name && f.parentRef === parentRef);
-		if (feature) parentRef = feature.id;
-		else {
-			const newFeature = {
-				id: featureEntityType.generateNewId(),
-				name,
-				parentRef
-			};
-			projectDefinition.features.push(newFeature);
-			parentRef = newFeature.id;
-		}
-		lastName = name;
-	}
-	if (!parentRef) throw new Error("Failed to create feature");
-	return parentRef;
-}
-function createPartialFeatures(nameOrPath) {
-	if (!nameOrPath) return [];
-	const parts = nameOrPath.split("/");
-	return parts.map((_, i) => {
-		return {
-			name: parts.slice(0, i + 1).join("/"),
-			parentRef: i > 0 ? parts.slice(0, i).join("/") : void 0
-		};
-	});
-}
-function getFeatureByName(projectDefinition, name) {
-	return projectDefinition.features.find((f) => f.name === name);
-}
-function getFeatureIdByNameOrThrow(projectDefinition, name) {
-	const feature = getFeatureByName(projectDefinition, name);
-	if (!feature) throw new Error(`Could not find feature with name ${name}`);
-	return feature.id;
-}
-function getFeatureIdByNameOrDefault(projectDefinition, name) {
-	return getFeatureByName(projectDefinition, name)?.id ?? name;
-}
-function resolveFeatureName(projectDefinition, featureRef) {
-	if (!featureRef) return "";
-	if (featureEntityType.isId(featureRef)) return getFeaturePathByIdOrThrow(projectDefinition, featureRef);
-	return featureRef;
-}
-var FeatureUtils = {
-	getRootFeatures,
-	getFeatureById,
-	getFeatureByIdOrThrow,
-	getFeatureChildren,
-	getFeatureName,
-	getFeatureNameById,
-	getFeaturePathByIdOrThrow,
-	validateFeatureName,
-	ensureFeatureByNameRecursively,
-	createPartialFeatures,
-	getFeatureByName,
-	getFeatureIdByNameOrThrow,
-	getFeatureIdByNameOrDefault,
-	resolveFeatureName
-};
-//#endregion
-//#region ../../packages/project-builder-lib/dist/definition/model/model-utils.js
-function byId(projectDefinition, id) {
-	return projectDefinition.models.find((m) => m.id === id);
-}
-function byIdOrThrow(projectDefinition, id) {
-	const model = byId(projectDefinition, id);
-	if (!model) throw new Error(`Could not find model with ID ${id}`);
-	return model;
-}
-function byName(projectDefinition, name) {
-	return projectDefinition.models.find((m) => m.name === name);
-}
-function byNameOrThrow(projectDefinition, name) {
-	const model = byName(projectDefinition, name);
-	if (!model) throw new Error(`Could not find model with name ${name}`);
-	return model;
-}
-function getScalarFieldById(model, id) {
-	const field = model.model.fields.find((f) => f.id === id);
-	if (!field) throw new Error(`Could not find field with ID ${id}`);
-	return field;
-}
-function getRelationsToModel(projectDefinition, modelId) {
-	return projectDefinition.models.flatMap((m) => m.model.relations.filter((r) => r.modelRef === modelId).map((r) => ({
-		model: m,
-		relation: r
-	})));
-}
-function getModelsForFeature(projectDefinition, featureId) {
-	return projectDefinition.models.filter((m) => m.featureRef === featureId);
-}
-function getModelIdFields(model) {
-	return model.model.primaryKeyFieldRefs;
-}
-function hasService(model) {
-	return model.service.create.enabled || model.service.update.enabled || model.service.delete.enabled || model.service.transformers.length > 0;
-}
-function validateModelName(name) {
-	return PASCAL_CASE_REGEX.test(name);
-}
-/**
-* Returns the ID of a model by name, or the name if no model is found.
-* @param projectDefinition - The project definition.
-* @param name - The name of the model.
-* @returns The ID of the model, or the name if no model is found.
-*/
-function getModelIdByNameOrDefault(projectDefinition, name) {
-	return projectDefinition.models.find((m) => m.name === name)?.id ?? name;
-}
-function getPrimaryKeyFields(model) {
-	return model.model.primaryKeyFieldRefs.map((id) => getScalarFieldById(model, id));
-}
-/**
-* Whether a field with the given read-role restriction is safe to expose as
-* a where-filter operand on a query with the given read-role restriction.
-*
-* A field is safe to filter on only if every principal who can call the
-* query can also read the field's value — i.e. the field's own restriction
-* (if any) is no narrower than the query's. Role lists are OR'd (holding
-* *any* listed role grants access), and an EMPTY role list means
-* "unrestricted" (everyone), not "no one" — the widest grant, not the
-* narrowest. So:
-*  - field unrestricted (empty) -> always safe, regardless of the query.
-*  - query unrestricted (empty) but field restricted -> never safe (the
-*    query admits everyone; the field doesn't).
-*  - both restricted -> safe only if every query role is also a field role
-*    (the query's role set is a SUBSET of the field's), so no principal can
-*    pass the query's gate without also passing the field's.
-*
-* @param field - The field's `globalRoles`/`instanceRoles` restriction.
-* @param query - The query's `globalRoles`/`instanceRoles` restriction.
-* @returns Whether the field is safe to filter on given the query's gate.
-*/
-function isFieldSafeToFilter(field, query) {
-	if (!(field.globalRoles.length > 0 || field.instanceRoles.length > 0)) return true;
-	if (!(query.globalRoles.length > 0 || query.instanceRoles.length > 0)) return false;
-	const isSubset = (subset, superset) => subset.every((role) => superset.includes(role));
-	return isSubset(query.globalRoles, field.globalRoles) && isSubset(query.instanceRoles, field.instanceRoles);
-}
-/**
-* Returns the IDs of models that need an `OrderByInput` GraphQL type because
-* some *other* model exposes a list relation to them marked `orderable`.
-*
-* The `orderable` flag lives on the *referenced* model's foreign relation
-* entry (e.g. `User.todoLists`), but the input type belongs to the model the
-* relation is declared on (`TodoList`, whose `owner` relation carries the
-* matching globally-unique `foreignId`) — that is the model whose rows are
-* being sorted.
-*
-* @param projectDefinition - The project definition.
-* @returns The set of model IDs requiring an `OrderByInput` type.
-*/
-function getModelIdsRequiringOrderByInput(projectDefinition) {
-	const orderableForeignIds = new Set(projectDefinition.models.filter((m) => m.graphql.objectType.enabled).flatMap((m) => m.graphql.objectType.foreignRelations.filter((entry) => entry.orderable).map((entry) => entry.ref)));
-	return new Set(projectDefinition.models.filter((m) => m.model.relations.some((relation) => orderableForeignIds.has(relation.foreignId))).map((m) => m.id));
-}
-/**
-* Whether the model exposes any root query returning a list of its rows.
-*
-* Offset and cursor pagination are independent surfaces, but both read through
-* the same object type, `where`/`orderBy` inputs, and role checks — so either
-* one alone requires all of them. Gate shared generation on this rather than on
-* a single surface's flag.
-*
-* @param queries - The model's `graphql.queries` config.
-* @returns Whether a list-returning root query is enabled.
-*/
-function hasListSurface(queries) {
-	return queries.list.enabled || queries.connection.enabled;
-}
-var ModelUtils = {
-	byId,
-	hasListSurface,
-	byIdOrThrow,
-	byName,
-	byNameOrThrow,
-	getScalarFieldById,
-	getRelationsToModel,
-	getModelIdsRequiringOrderByInput,
-	getModelsForFeature,
-	getModelIdFields,
-	hasService,
-	validateModelName,
-	getModelIdByNameOrDefault,
-	getPrimaryKeyFields,
-	isFieldSafeToFilter
-};
-//#endregion
-export { getTag as $, isPlainObject as A, int32ArrayTag as B, createPluginFieldMap as C, validationHintRegistry as D, CASE_VALIDATORS as E, dataViewTag as F, regexpTag as G, mapTag as H, dateTag as I, symbolTag as J, setTag as K, float32ArrayTag as L, arrayBufferTag as M, arrayTag as N, isEqual as O, booleanTag as P, uint8ClampedArrayTag as Q, float64ArrayTag as R, createFieldMapSpec as S, runInPluginContext as T, numberTag as U, int8ArrayTag as V, objectTag as W, uint32ArrayTag as X, uint16ArrayTag as Y, uint8ArrayTag as Z, createRefContextSlot as _, featureEntityType as a, expressionParserSpec as b, createEntityType as c, definitionSchemaWithSlots as d, getSymbols as et, withPlaceholderSlots as f, withRef as g, withEnt as h, createFeaturesSchema as i, argumentsTag as j, eq as k, createDefinitionSchemaParserContext as l, definitionDefaultRegistry as m, FeatureUtils as n, sortBy as nt, featureNameSchema as o, withDefault as p, stringTag as q, createFeatureSchema as r, createPluginSpec as rt, DefinitionEntityType as s, ModelUtils as t, isBuffer as tt, definitionSchema as u, createRefContextSlotMap as v, getPluginContext as w, definitionRefRegistry as x, RefExpressionParser as y, int16ArrayTag as z };
-
-//# sourceMappingURL=model-utils-C0WDb_Ec.js.map