@baseplate-dev/plugin-auth 4.0.0 → 4.0.1

package/dist/web/assets/__federation_shared_@baseplate-dev/{project-builder-lib-CcNtL_U6.js → project-builder-lib-CmgMfkI5.js}

@@ -1,1208 +1,74 @@
-import { c as createPluginSpec, m as mapValues, a as createEntityType, d as definitionSchemaWithSlots, D as DefinitionReferenceMarker, R as REF_ANNOTATIONS_MARKER_SYMBOL, s as stripRefMarkers, b as createDefinitionSchemaParserContext, g as get, e as set$1, f as definitionSchema, h as modelForeignRelationEntityType, i as modelLocalRelationEntityType, j as modelScalarFieldEntityType, k as modelEntityType, l as modelTransformerEntityType, n as modelEnumValueEntityType, o as modelEnumEntityType, p as featureEntityType, q as modelUniqueConstraintEntityType, r as createFeaturesSchema, M as ModelUtils, t as omit, u as cloneDeep } from '../model-merger-gGkFnyaY.js';
-export { O as DefinitionDiffArrayIncludesField, L as DefinitionDiffKeyedArrayField, N as DefinitionDiffReplacementField, y as DefinitionEntityType, F as FeatureUtils, S as applyDefinitionDiff, I as applyModelMergerDiff, J as applyModelMergerResultInPlace, K as createAndApplyModelMergerResults, Q as createDefinitionDiff, P as createDefinitionDiffConfig, B as createFeatureSchema, v as createInitializedPluginSpec, E as createModelMergerResult, H as createModelMergerResults, w as createRefContextSlot, x as createRefContextSlotMap, G as doesModelMergerResultsHaveChanges, A as featureNameSchema, C as modelMergerDefinitionDiffConfig, z as withPlaceholderSlots } from '../model-merger-gGkFnyaY.js';
-import { importShared } from '../__federation_fn_import-C_QCk5FX.js';
-import { i as isEqual } from '../isEqual-DAXqKRba.js';
+import { c as createFieldMapSpec, a as createEntityType, d as definitionSchemaWithSlots, D as DefinitionReferenceMarker, R as REF_ANNOTATIONS_MARKER_SYMBOL, s as stripRefMarkers, m as mapValues, b as createDefinitionSchemaParserContext, g as get, e as set$1, f as definitionSchema, h as modelForeignRelationEntityType, i as modelLocalRelationEntityType, j as modelScalarFieldEntityType, k as modelEntityType, l as modelTransformerEntityType, n as modelEnumValueEntityType, o as modelEnumEntityType, p as featureEntityType, q as modelUniqueConstraintEntityType, r as runInPluginContext, t as createFeaturesSchema, M as ModelUtils, u as omit, v as cloneDeep } from '../model-merger-BwRNqcBu.js';
+export { S as DefinitionDiffArrayIncludesField, P as DefinitionDiffKeyedArrayField, Q as DefinitionDiffReplacementField, B as DefinitionEntityType, F as FeatureUtils, V as applyDefinitionDiff, L as applyModelMergerDiff, N as applyModelMergerResultInPlace, O as createAndApplyModelMergerResults, U as createDefinitionDiff, T as createDefinitionDiffConfig, G as createFeatureSchema, I as createModelMergerResult, K as createModelMergerResults, y as createPluginFieldMap, x as createPluginSpec, z as createRefContextSlot, A as createRefContextSlotMap, J as doesModelMergerResultsHaveChanges, E as featureNameSchema, w as getPluginContext, H as modelMergerDefinitionDiffConfig, C as withPlaceholderSlots } from '../model-merger-BwRNqcBu.js';
+import { importShared } from '../__federation_fn_import-DsXcpNlB.js';
+import { i as isEqual } from '../isEqual-BQtm2LNT.js';
 import { s as sortBy } from '../sortBy-BPH_zRB8.js';
 
-function createAdminCrudActionCompilerImplementation() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const actions = new Map();
-    return {
-        registerCompiler(action) {
-            if (actions.has(action.name)) {
-                throw new Error(`Admin CRUD action with name ${action.name} is already registered`);
-            }
-            actions.set(action.name, action);
-        },
-        getCompiler(name, builtInActions = []) {
-            const builtInAction = builtInActions.find((b) => b.name === name);
-            if (builtInAction) {
-                return builtInAction;
-            }
-            const action = actions.get(name);
-            if (!action) {
-                throw new Error(`Unable to find action with name ${name}`);
-            }
-            return action;
-        },
-    };
-}
-/**
- * Spec for adding config component for plugin
- */
-const adminCrudActionCompilerSpec = createPluginSpec('core/admin-crud-action-compiler', { defaultInitializer: createAdminCrudActionCompilerImplementation });
+const adminCrudActionCompilerSpec = createFieldMapSpec('core/admin-crud-action-compiler', (t) => ({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- plugins register varying action types at runtime
+    actions: t.namedArrayToMap(),
+}));
 
 function createAdminCrudColumnCompiler(input) {
     return input;
 }
-function createAdminCrudColumnCompilerImplementation() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const columns = new Map();
-    return {
-        registerCompiler(column) {
-            if (columns.has(column.name)) {
-                throw new Error(`Admin CRUD column with name ${column.name} is already registered`);
-            }
-            columns.set(column.name, column);
-        },
-        getCompiler(type, builtInColumns = []) {
-            const builtInColumn = builtInColumns.find((b) => b.name === type);
-            if (builtInColumn) {
-                return builtInColumn;
-            }
-            const column = columns.get(type);
-            if (!column) {
-                throw new Error(`Unable to find column with type ${type}`);
-            }
-            return column;
-        },
-        getColumnCompilers() {
-            return columns;
-        },
-    };
-}
 /**
- * Spec for adding column compilers
+ * Spec for registering admin CRUD column compilers
  */
-const adminCrudColumnCompilerSpec = createPluginSpec('core/admin-crud-column-compiler', { defaultInitializer: createAdminCrudColumnCompilerImplementation });
+const adminCrudColumnCompilerSpec = createFieldMapSpec('core/admin-crud-column-compiler', (t) => ({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- plugins register varying column types at runtime
+    columns: t.namedArrayToMap(),
+}));
 
-function createAdminCrudInputCompilerImplementation() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const inputs = new Map();
-    return {
-        registerCompiler(input) {
-            if (inputs.has(input.name)) {
-                throw new Error(`Admin CRUD input with name ${input.name} is already registered`);
-            }
-            inputs.set(input.name, input);
-        },
-        getCompiler(name, builtInInputs = []) {
-            const builtInInput = builtInInputs.find((b) => b.name === name);
-            if (builtInInput) {
-                return builtInInput;
-            }
-            const input = inputs.get(name);
-            if (!input) {
-                throw new Error(`Unable to find input with name ${name}`);
-            }
-            return input;
-        },
-    };
-}
 /**
- * Spec for adding config component for plugin
+ * Spec for registering admin CRUD input compilers
  */
-const adminCrudInputCompilerSpec = createPluginSpec('core/admin-crud-input-compiler', { defaultInitializer: createAdminCrudInputCompilerImplementation });
-
-function groupBy(arr, getKeyFromItem) {
-    const result = {};
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        const key = getKeyFromItem(item);
-        if (!Object.hasOwn(result, key)) {
-            result[key] = [];
-        }
-        result[key].push(item);
-    }
-    return result;
-}
-
-function keyBy(arr, getKeyFromItem) {
-    const result = {};
-    for (let i = 0; i < arr.length; i++) {
-        const item = arr[i];
-        const key = getKeyFromItem(item);
-        result[key] = item;
-    }
-    return result;
-}
-
-function uniq(arr) {
-    return Array.from(new Set(arr));
-}
+const adminCrudInputCompilerSpec = createFieldMapSpec('core/admin-crud-input-compiler', (t) => ({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- plugins register varying input types at runtime
+    inputs: t.namedArrayToMap(),
+}));
 
-function flow(...funcs) {
-    return function (...args) {
-        let result = funcs.length ? funcs[0].apply(this, args) : args[0];
-        for (let i = 1; i < funcs.length; i++) {
-            result = funcs[i].call(this, result);
-        }
-        return result;
+const {safeMerge} = await importShared('@baseplate-dev/utils');
+function createAppCompiler() {
+    const children = {};
+    let rootChildren = {};
+    return {
+        addChildrenToFeature(featureId, newChildren) {
+            children[featureId] = safeMerge(children[featureId] ?? {}, newChildren);
+        },
+        getChildrenForFeature(featureId) {
+            return children[featureId] ?? {};
+        },
+        addRootChildren(newChildren) {
+            rootChildren = safeMerge(rootChildren, newChildren);
+        },
+        getRootChildren() {
+            return rootChildren;
+        },
     };
 }
-
-function pickBy(obj, shouldPick) {
-    const result = {};
-    const keys = Object.keys(obj);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = obj[key];
-        if (shouldPick(value, key)) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-
-/**
- * Strip object of any values that are empty arrays, empty objects, null, or undefined
- */
-function stripEmptyGeneratorChildren(children) {
-    return pickBy(children, (value) => value !== undefined && !(Array.isArray(value) && value.length === 0));
-}
-/**
- * Strip object of any values that are undefined
- */
-function stripUndefinedValues(obj) {
-    return pickBy(obj, (value) => value !== undefined);
-}
-/**
- * Returns undefined if the value is an empty object (as defined by all values are undefined)/array/null, otherwise return value.
- */
-function undefinedIfEmpty(value) {
-    if (value === null)
-        return undefined;
-    if (Array.isArray(value) && value.length === 0) {
-        return undefined;
-    }
-    if (typeof value === 'object' &&
-        Object.keys(value).every((key) => value[key] === undefined)) {
-        return undefined;
-    }
-    return value;
-}
-/**
- * Returns undefined if the value is falsy, otherwise return value.
- */
-function undefinedIfFalsy(value) {
-    if (!value)
-        return undefined;
-    return value;
-}
-
-class PluginImplementationStore {
-    implementations;
-    constructor(implementations) {
-        this.implementations = implementations;
-    }
-    getPluginSpec(spec) {
-        const implementation = this.implementations[spec.name];
-        if (!implementation) {
-            throw new Error(`Unable to find implementation for spec ${spec.name}`);
-        }
-        return implementation;
-    }
-    getPluginSpecOptional(spec) {
-        return this.implementations[spec.name];
-    }
-}
-
-const {toposortOrdered} = await importShared('@baseplate-dev/utils');
-function extractPlatformModulesFromPlugins(plugins) {
-    return plugins.flatMap((plugin) => plugin.pluginModules.map((m) => ({
-        ...m,
-        id: `${plugin.key}/${m.key}`,
-        name: `${plugin.name}/${m.key}`,
-        pluginKey: plugin.key,
-        pluginName: plugin.name,
-    })));
-}
-function getOrderedPluginModuleInitializationSteps(pluginModules, initialSpecImplementations) {
-    const pluginModulesById = keyBy(pluginModules, (p) => p.id);
-    // create export map of plugin ID to export spec name
-    const pluginModuleIdByExport = mapValues(initialSpecImplementations, () => 'built-in');
-    for (const { name, module, id } of pluginModules) {
-        for (const m of Object.values(module.exports ?? {})) {
-            const exportName = m.name;
-            if (exportName in pluginModuleIdByExport) {
-                const existingPlugin = pluginModulesById[pluginModuleIdByExport[exportName]];
-                throw new Error(`Duplicate export from plugins found ${exportName} (${name} and ${existingPlugin.name})`);
-            }
-            pluginModuleIdByExport[exportName] = id;
-        }
-    }
-    // create list of plugin to plugin dependencies
-    const edges = pluginModules.flatMap(({ module, name, id }) => Object.values(module.dependencies ?? {})
-        .map((m) => {
-        const resolvedDep = pluginModuleIdByExport[m.name];
-        if (!resolvedDep) {
-            if (m.isOptional) {
-                return undefined;
-            }
-            throw new Error(`Cannot resolve plugin dependency for ${name} (${m.name})`);
-        }
-        if (resolvedDep === 'built-in') {
-            return undefined;
-        }
-        return [resolvedDep, id];
-    })
-        .filter((x) => x !== undefined));
-    const nodes = pluginModules.map((p) => p.id);
-    return toposortOrdered(nodes, edges);
-}
-function initializeOrderedPluginModules(orderedPluginModules, initialSpecImplementations) {
-    const specImplementations = { ...initialSpecImplementations };
-    for (const { name, module, pluginKey } of orderedPluginModules) {
-        const dependencies = module.dependencies
-            ? stripUndefinedValues(mapValues(module.dependencies, (dep) => {
-                const implementation = specImplementations[dep.name];
-                if (!implementation && !dep.isOptional) {
-                    throw new Error(`Plugin ${name} missing dependency ${dep.name}`);
-                }
-                return implementation;
-            }))
-            : {};
-        const context = { pluginKey };
-        const exports = module.initialize(dependencies, context);
-        Object.entries(module.exports ?? {}).map(([key, spec]) => {
-            const exportedImplementation = exports[key];
-            if (!exportedImplementation) {
-                throw new Error(`Plugin ${name} did not return required export ${key}`);
-            }
-            specImplementations[spec.name] = exportedImplementation;
-        });
-    }
-    return specImplementations;
-}
-/**
- * Initialize the plugins based on their interdependencies and creates a store of the plugin implementations
- */
-function initializePlugins(plugins, initialSpecImplementations) {
-    const pluginModules = extractPlatformModulesFromPlugins(plugins);
-    const pluginModulesById = keyBy(pluginModules, (p) => p.id);
-    const orderedModuleIds = getOrderedPluginModuleInitializationSteps(pluginModules, initialSpecImplementations);
-    const specImplementations = initializeOrderedPluginModules(orderedModuleIds.map((p) => pluginModulesById[p]), initialSpecImplementations);
-    return new PluginImplementationStore(specImplementations);
-}
-
-function createPlatformPluginExport(config) {
-    return config;
-}
-
-/**
- * Gets a plugin metadata object by its key.
- *
- * @param pluginStore The plugin store to use
- * @param key The key of the plugin to get
- * @returns The plugin metadata object or undefined if the plugin is not found
- */
-function getPluginMetadataByKey(pluginStore, key) {
-    return pluginStore.availablePlugins.find((p) => p.metadata.key === key)
-        ?.metadata;
+function pluginAppCompiler(options) {
+    return options;
 }
 /**
- * Gets a plugin metadata object by its key.
- *
- * @param pluginStore The plugin store to use
- * @param key The key of the plugin to get
- * @returns The plugin metadata object
- * @throws An error if the plugin is not found
+ * Spec for registering app compilers
  */
-function getPluginMetadataByKeyOrThrow(pluginStore, key) {
-    const metadata = getPluginMetadataByKey(pluginStore, key);
-    if (!metadata) {
-        throw new Error(`Could not find plugin with key ${key}`);
-    }
-    return metadata;
-}
-function getManagedPluginsForPlugin(pluginStore, pluginKey) {
-    const plugin = getPluginMetadataByKeyOrThrow(pluginStore, pluginKey);
-    return pluginStore.availablePlugins
-        .filter((p) => p.metadata.managedBy === plugin.fullyQualifiedName)
-        .map((p) => p.metadata);
-}
-
-const {z: z$u} = await importShared('zod');
-
-// matches semver
-const versionSchema = z$u.string().regex(/^(\d+\.\d+\.\d+)$/);
-const pluginSpecSupportSchema = z$u.object({
-    spec: z$u.string().min(1),
-    version: z$u.string().min(1),
-});
-const pluginSpecDependencySchema = z$u.object({
-    spec: z$u.string(),
-    version: z$u.string(),
+const appCompilerSpec = createFieldMapSpec('core/app-compiler', (t) => ({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- plugins register varying app definition types at runtime
+    compilers: t.array(),
+}), {
+    use: (values) => ({
+        getAppCompilers: (appType) => values.compilers.filter((c) => c.appType === appType),
+    }),
 });
+
 /**
- * Schema for the plugin's metadata (plugin.json)
+ * Spec for registering model transformer compilers
  */
-const pluginMetadataSchema = z$u.object({
-    /**
-     * The name of the plugin - must be lowercase and contain only letters, numbers, and hyphens
-     */
-    name: z$u
-        .string()
-        .min(1)
-        .regex(/^[a-z0-9-]+$/),
-    /**
-     * A list of directories with entrypoints in them. Defaults to ['.']
-     */
-    moduleDirectories: z$u.array(z$u.string()).optional(),
-    /**
-     * The display name of the plugin
-     */
-    displayName: z$u.string().min(1),
-    /**
-     * The icon to display for the plugin as a pointer to the icon in the plugin's static folder
-     */
-    icon: z$u.string().optional(),
-    /**
-     * A description of the plugin
-     */
-    description: z$u.string(),
-    /**
-     * The fully qualified name of the plugin that manages this plugin,
-     * e.g. "@baseplate-dev/plugin-auth:auth0" would be managed by the "@baseplate-dev/plugin-auth:auth" plugin.
-     *
-     * Managed plugins do not appear in the plugin list but are managed by the base plugin. If the base
-     * plugin is disabled, the managed plugins will also be disabled.
-     */
-    managedBy: z$u.string().optional(),
-    /**
-     * The version of the plugin using semver
-     */
-    version: versionSchema,
-    /**
-     * Configuration for the specs that the plugin exports/depends on
-     */
-    specs: z$u
-        .object({
-        /**
-         * The specs that the plugin exports
-         */
-        exports: z$u.array(pluginSpecSupportSchema).optional(),
-        /**
-         * The specs that the plugin depends on
-         */
-        dependencies: z$u.array(pluginSpecDependencySchema).optional(),
-    })
-        .optional(),
-    /**
-     * Whether the plugin should be hidden in the project builder UI
-     *
-     * (It can be used once in the definition but cannot be added)
-     */
-    hidden: z$u.boolean().optional(),
-});
-
-var NOTHING = Symbol.for("immer-nothing");
-var DRAFTABLE = Symbol.for("immer-draftable");
-var DRAFT_STATE = Symbol.for("immer-state");
-function die(error, ...args) {
-  throw new Error(
-    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
-  );
-}
-var getPrototypeOf = Object.getPrototypeOf;
-function isDraft(value) {
-  return !!value && !!value[DRAFT_STATE];
-}
-function isDraftable(value) {
-  if (!value)
-    return false;
-  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
-}
-var objectCtorString = Object.prototype.constructor.toString();
-function isPlainObject(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  const proto = getPrototypeOf(value);
-  if (proto === null) {
-    return true;
-  }
-  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  if (Ctor === Object)
-    return true;
-  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
-}
-function each(obj, iter) {
-  if (getArchtype(obj) === 0) {
-    Reflect.ownKeys(obj).forEach((key) => {
-      iter(key, obj[key], obj);
-    });
-  } else {
-    obj.forEach((entry, index) => iter(index, entry, obj));
-  }
-}
-function getArchtype(thing) {
-  const state = thing[DRAFT_STATE];
-  return state ? state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
-}
-function has(thing, prop) {
-  return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
-}
-function set(thing, propOrOldValue, value) {
-  const t = getArchtype(thing);
-  if (t === 2)
-    thing.set(propOrOldValue, value);
-  else if (t === 3) {
-    thing.add(value);
-  } else
-    thing[propOrOldValue] = value;
-}
-function is(x, y) {
-  if (x === y) {
-    return x !== 0 || 1 / x === 1 / y;
-  } else {
-    return x !== x && y !== y;
-  }
-}
-function isMap(target) {
-  return target instanceof Map;
-}
-function isSet(target) {
-  return target instanceof Set;
-}
-function latest(state) {
-  return state.copy_ || state.base_;
-}
-function shallowCopy(base, strict) {
-  if (isMap(base)) {
-    return new Map(base);
-  }
-  if (isSet(base)) {
-    return new Set(base);
-  }
-  if (Array.isArray(base))
-    return Array.prototype.slice.call(base);
-  const isPlain = isPlainObject(base);
-  if (strict === true || strict === "class_only" && !isPlain) {
-    const descriptors = Object.getOwnPropertyDescriptors(base);
-    delete descriptors[DRAFT_STATE];
-    let keys = Reflect.ownKeys(descriptors);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const desc = descriptors[key];
-      if (desc.writable === false) {
-        desc.writable = true;
-        desc.configurable = true;
-      }
-      if (desc.get || desc.set)
-        descriptors[key] = {
-          configurable: true,
-          writable: true,
-          // could live with !!desc.set as well here...
-          enumerable: desc.enumerable,
-          value: base[key]
-        };
-    }
-    return Object.create(getPrototypeOf(base), descriptors);
-  } else {
-    const proto = getPrototypeOf(base);
-    if (proto !== null && isPlain) {
-      return { ...base };
-    }
-    const obj = Object.create(proto);
-    return Object.assign(obj, base);
-  }
-}
-function freeze(obj, deep = false) {
-  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
-    return obj;
-  if (getArchtype(obj) > 1) {
-    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
-  }
-  Object.freeze(obj);
-  if (deep)
-    Object.entries(obj).forEach(([key, value]) => freeze(value, true));
-  return obj;
-}
-function dontMutateFrozenCollections() {
-  die(2);
-}
-function isFrozen(obj) {
-  return Object.isFrozen(obj);
-}
-var plugins = {};
-function getPlugin(pluginKey) {
-  const plugin = plugins[pluginKey];
-  if (!plugin) {
-    die(0, pluginKey);
-  }
-  return plugin;
-}
-var currentScope;
-function getCurrentScope() {
-  return currentScope;
-}
-function createScope(parent_, immer_) {
-  return {
-    drafts_: [],
-    parent_,
-    immer_,
-    // Whenever the modified draft contains a draft from another scope, we
-    // need to prevent auto-freezing so the unowned draft can be finalized.
-    canAutoFreeze_: true,
-    unfinalizedDrafts_: 0
-  };
-}
-function usePatchesInScope(scope, patchListener) {
-  if (patchListener) {
-    getPlugin("Patches");
-    scope.patches_ = [];
-    scope.inversePatches_ = [];
-    scope.patchListener_ = patchListener;
-  }
-}
-function revokeScope(scope) {
-  leaveScope(scope);
-  scope.drafts_.forEach(revokeDraft);
-  scope.drafts_ = null;
-}
-function leaveScope(scope) {
-  if (scope === currentScope) {
-    currentScope = scope.parent_;
-  }
-}
-function enterScope(immer2) {
-  return currentScope = createScope(currentScope, immer2);
-}
-function revokeDraft(draft) {
-  const state = draft[DRAFT_STATE];
-  if (state.type_ === 0 || state.type_ === 1)
-    state.revoke_();
-  else
-    state.revoked_ = true;
-}
-function processResult(result, scope) {
-  scope.unfinalizedDrafts_ = scope.drafts_.length;
-  const baseDraft = scope.drafts_[0];
-  const isReplaced = result !== void 0 && result !== baseDraft;
-  if (isReplaced) {
-    if (baseDraft[DRAFT_STATE].modified_) {
-      revokeScope(scope);
-      die(4);
-    }
-    if (isDraftable(result)) {
-      result = finalize(scope, result);
-      if (!scope.parent_)
-        maybeFreeze(scope, result);
-    }
-    if (scope.patches_) {
-      getPlugin("Patches").generateReplacementPatches_(
-        baseDraft[DRAFT_STATE].base_,
-        result,
-        scope.patches_,
-        scope.inversePatches_
-      );
-    }
-  } else {
-    result = finalize(scope, baseDraft, []);
-  }
-  revokeScope(scope);
-  if (scope.patches_) {
-    scope.patchListener_(scope.patches_, scope.inversePatches_);
-  }
-  return result !== NOTHING ? result : void 0;
-}
-function finalize(rootScope, value, path) {
-  if (isFrozen(value))
-    return value;
-  const state = value[DRAFT_STATE];
-  if (!state) {
-    each(
-      value,
-      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)
-    );
-    return value;
-  }
-  if (state.scope_ !== rootScope)
-    return value;
-  if (!state.modified_) {
-    maybeFreeze(rootScope, state.base_, true);
-    return state.base_;
-  }
-  if (!state.finalized_) {
-    state.finalized_ = true;
-    state.scope_.unfinalizedDrafts_--;
-    const result = state.copy_;
-    let resultEach = result;
-    let isSet2 = false;
-    if (state.type_ === 3) {
-      resultEach = new Set(result);
-      result.clear();
-      isSet2 = true;
-    }
-    each(
-      resultEach,
-      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)
-    );
-    maybeFreeze(rootScope, result, false);
-    if (path && rootScope.patches_) {
-      getPlugin("Patches").generatePatches_(
-        state,
-        path,
-        rootScope.patches_,
-        rootScope.inversePatches_
-      );
-    }
-  }
-  return state.copy_;
-}
-function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
-  if (isDraft(childValue)) {
-    const path = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys.
-    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
-    const res = finalize(rootScope, childValue, path);
-    set(targetObject, prop, res);
-    if (isDraft(res)) {
-      rootScope.canAutoFreeze_ = false;
-    } else
-      return;
-  } else if (targetIsSet) {
-    targetObject.add(childValue);
-  }
-  if (isDraftable(childValue) && !isFrozen(childValue)) {
-    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
-      return;
-    }
-    finalize(rootScope, childValue);
-    if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && Object.prototype.propertyIsEnumerable.call(targetObject, prop))
-      maybeFreeze(rootScope, childValue);
-  }
-}
-function maybeFreeze(scope, value, deep = false) {
-  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
-    freeze(value, deep);
-  }
-}
-function createProxyProxy(base, parent) {
-  const isArray = Array.isArray(base);
-  const state = {
-    type_: isArray ? 1 : 0,
-    // Track which produce call this is associated with.
-    scope_: parent ? parent.scope_ : getCurrentScope(),
-    // True for both shallow and deep changes.
-    modified_: false,
-    // Used during finalization.
-    finalized_: false,
-    // Track which properties have been assigned (true) or deleted (false).
-    assigned_: {},
-    // The parent draft state.
-    parent_: parent,
-    // The base state.
-    base_: base,
-    // The base proxy.
-    draft_: null,
-    // set below
-    // The base copy with any updated values.
-    copy_: null,
-    // Called by the `produce` function.
-    revoke_: null,
-    isManual_: false
-  };
-  let target = state;
-  let traps = objectTraps;
-  if (isArray) {
-    target = [state];
-    traps = arrayTraps;
-  }
-  const { revoke, proxy } = Proxy.revocable(target, traps);
-  state.draft_ = proxy;
-  state.revoke_ = revoke;
-  return proxy;
-}
-var objectTraps = {
-  get(state, prop) {
-    if (prop === DRAFT_STATE)
-      return state;
-    const source = latest(state);
-    if (!has(source, prop)) {
-      return readPropFromProto(state, source, prop);
-    }
-    const value = source[prop];
-    if (state.finalized_ || !isDraftable(value)) {
-      return value;
-    }
-    if (value === peek(state.base_, prop)) {
-      prepareCopy(state);
-      return state.copy_[prop] = createProxy(value, state);
-    }
-    return value;
-  },
-  has(state, prop) {
-    return prop in latest(state);
-  },
-  ownKeys(state) {
-    return Reflect.ownKeys(latest(state));
-  },
-  set(state, prop, value) {
-    const desc = getDescriptorFromProto(latest(state), prop);
-    if (desc?.set) {
-      desc.set.call(state.draft_, value);
-      return true;
-    }
-    if (!state.modified_) {
-      const current2 = peek(latest(state), prop);
-      const currentState = current2?.[DRAFT_STATE];
-      if (currentState && currentState.base_ === value) {
-        state.copy_[prop] = value;
-        state.assigned_[prop] = false;
-        return true;
-      }
-      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
-        return true;
-      prepareCopy(state);
-      markChanged(state);
-    }
-    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
-    (value !== void 0 || prop in state.copy_) || // special case: NaN
-    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
-      return true;
-    state.copy_[prop] = value;
-    state.assigned_[prop] = true;
-    return true;
-  },
-  deleteProperty(state, prop) {
-    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
-      state.assigned_[prop] = false;
-      prepareCopy(state);
-      markChanged(state);
-    } else {
-      delete state.assigned_[prop];
-    }
-    if (state.copy_) {
-      delete state.copy_[prop];
-    }
-    return true;
-  },
-  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
-  // the same guarantee in ES5 mode.
-  getOwnPropertyDescriptor(state, prop) {
-    const owner = latest(state);
-    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
-    if (!desc)
-      return desc;
-    return {
-      writable: true,
-      configurable: state.type_ !== 1 || prop !== "length",
-      enumerable: desc.enumerable,
-      value: owner[prop]
-    };
-  },
-  defineProperty() {
-    die(11);
-  },
-  getPrototypeOf(state) {
-    return getPrototypeOf(state.base_);
-  },
-  setPrototypeOf() {
-    die(12);
-  }
-};
-var arrayTraps = {};
-each(objectTraps, (key, fn) => {
-  arrayTraps[key] = function() {
-    arguments[0] = arguments[0][0];
-    return fn.apply(this, arguments);
-  };
-});
-arrayTraps.deleteProperty = function(state, prop) {
-  return arrayTraps.set.call(this, state, prop, void 0);
-};
-arrayTraps.set = function(state, prop, value) {
-  return objectTraps.set.call(this, state[0], prop, value, state[0]);
-};
-function peek(draft, prop) {
-  const state = draft[DRAFT_STATE];
-  const source = state ? latest(state) : draft;
-  return source[prop];
-}
-function readPropFromProto(state, source, prop) {
-  const desc = getDescriptorFromProto(source, prop);
-  return desc ? `value` in desc ? desc.value : (
-    // This is a very special case, if the prop is a getter defined by the
-    // prototype, we should invoke it with the draft as context!
-    desc.get?.call(state.draft_)
-  ) : void 0;
-}
-function getDescriptorFromProto(source, prop) {
-  if (!(prop in source))
-    return void 0;
-  let proto = getPrototypeOf(source);
-  while (proto) {
-    const desc = Object.getOwnPropertyDescriptor(proto, prop);
-    if (desc)
-      return desc;
-    proto = getPrototypeOf(proto);
-  }
-  return void 0;
-}
-function markChanged(state) {
-  if (!state.modified_) {
-    state.modified_ = true;
-    if (state.parent_) {
-      markChanged(state.parent_);
-    }
-  }
-}
-function prepareCopy(state) {
-  if (!state.copy_) {
-    state.copy_ = shallowCopy(
-      state.base_,
-      state.scope_.immer_.useStrictShallowCopy_
-    );
-  }
-}
-var Immer2 = class {
-  constructor(config) {
-    this.autoFreeze_ = true;
-    this.useStrictShallowCopy_ = false;
-    this.produce = (base, recipe, patchListener) => {
-      if (typeof base === "function" && typeof recipe !== "function") {
-        const defaultBase = recipe;
-        recipe = base;
-        const self = this;
-        return function curriedProduce(base2 = defaultBase, ...args) {
-          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
-        };
-      }
-      if (typeof recipe !== "function")
-        die(6);
-      if (patchListener !== void 0 && typeof patchListener !== "function")
-        die(7);
-      let result;
-      if (isDraftable(base)) {
-        const scope = enterScope(this);
-        const proxy = createProxy(base, void 0);
-        let hasError = true;
-        try {
-          result = recipe(proxy);
-          hasError = false;
-        } finally {
-          if (hasError)
-            revokeScope(scope);
-          else
-            leaveScope(scope);
-        }
-        usePatchesInScope(scope, patchListener);
-        return processResult(result, scope);
-      } else if (!base || typeof base !== "object") {
-        result = recipe(base);
-        if (result === void 0)
-          result = base;
-        if (result === NOTHING)
-          result = void 0;
-        if (this.autoFreeze_)
-          freeze(result, true);
-        if (patchListener) {
-          const p = [];
-          const ip = [];
-          getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
-          patchListener(p, ip);
-        }
-        return result;
-      } else
-        die(1, base);
-    };
-    this.produceWithPatches = (base, recipe) => {
-      if (typeof base === "function") {
-        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
-      }
-      let patches, inversePatches;
-      const result = this.produce(base, recipe, (p, ip) => {
-        patches = p;
-        inversePatches = ip;
-      });
-      return [result, patches, inversePatches];
-    };
-    if (typeof config?.autoFreeze === "boolean")
-      this.setAutoFreeze(config.autoFreeze);
-    if (typeof config?.useStrictShallowCopy === "boolean")
-      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
-  }
-  createDraft(base) {
-    if (!isDraftable(base))
-      die(8);
-    if (isDraft(base))
-      base = current(base);
-    const scope = enterScope(this);
-    const proxy = createProxy(base, void 0);
-    proxy[DRAFT_STATE].isManual_ = true;
-    leaveScope(scope);
-    return proxy;
-  }
-  finishDraft(draft, patchListener) {
-    const state = draft && draft[DRAFT_STATE];
-    if (!state || !state.isManual_)
-      die(9);
-    const { scope_: scope } = state;
-    usePatchesInScope(scope, patchListener);
-    return processResult(void 0, scope);
-  }
-  /**
-   * Pass true to automatically freeze all copies created by Immer.
-   *
-   * By default, auto-freezing is enabled.
-   */
-  setAutoFreeze(value) {
-    this.autoFreeze_ = value;
-  }
-  /**
-   * Pass true to enable strict shallow copy.
-   *
-   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
-   */
-  setUseStrictShallowCopy(value) {
-    this.useStrictShallowCopy_ = value;
-  }
-  applyPatches(base, patches) {
-    let i;
-    for (i = patches.length - 1; i >= 0; i--) {
-      const patch = patches[i];
-      if (patch.path.length === 0 && patch.op === "replace") {
-        base = patch.value;
-        break;
-      }
-    }
-    if (i > -1) {
-      patches = patches.slice(i + 1);
-    }
-    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
-    if (isDraft(base)) {
-      return applyPatchesImpl(base, patches);
-    }
-    return this.produce(
-      base,
-      (draft) => applyPatchesImpl(draft, patches)
-    );
-  }
-};
-function createProxy(value, parent) {
-  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
-  const scope = parent ? parent.scope_ : getCurrentScope();
-  scope.drafts_.push(draft);
-  return draft;
-}
-function current(value) {
-  if (!isDraft(value))
-    die(10, value);
-  return currentImpl(value);
-}
-function currentImpl(value) {
-  if (!isDraftable(value) || isFrozen(value))
-    return value;
-  const state = value[DRAFT_STATE];
-  let copy;
-  if (state) {
-    if (!state.modified_)
-      return state.base_;
-    state.finalized_ = true;
-    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
-  } else {
-    copy = shallowCopy(value, true);
-  }
-  each(copy, (key, childValue) => {
-    set(copy, key, currentImpl(childValue));
-  });
-  if (state) {
-    state.finalized_ = false;
-  }
-  return copy;
-}
-var immer = new Immer2();
-var produce = immer.produce;
-immer.produceWithPatches.bind(
-  immer
-);
-immer.setAutoFreeze.bind(immer);
-immer.setUseStrictShallowCopy.bind(immer);
-immer.applyPatches.bind(immer);
-immer.createDraft.bind(immer);
-immer.finishDraft.bind(immer);
-
-const pluginEntityType = createEntityType('plugin');
-
-function sortAndValidateMigrations(migrations) {
-    // make sure migrations are sorted by version and they are all unique
-    const sortedMigrations = [...migrations].sort((a, b) => a.version - b.version);
-    if (sortedMigrations.some((m) => m.version <= 0)) {
-        throw new Error(`Migration version must be a positive integer`);
-    }
-    for (let i = 0; i < sortedMigrations.length - 1; i++) {
-        if (sortedMigrations[i].version === sortedMigrations[i + 1].version) {
-            throw new Error(`Migration versions must be unique`);
-        }
-    }
-    return sortedMigrations;
-}
-function createPluginConfigImplementation() {
-    const schemas = new Map();
-    const migrationsMap = new Map();
-    return {
-        registerSchemaCreator(pluginKey, schemaCreator) {
-            if (schemas.has(pluginKey)) {
-                throw new Error(`Schema for plugin ${pluginKey} is already registered`);
-            }
-            schemas.set(pluginKey, schemaCreator);
-        },
-        registerMigrations(pluginKey, migrations) {
-            if (migrationsMap.has(pluginKey)) {
-                throw new Error(`Migrations for plugin ${pluginKey} are already registered`);
-            }
-            const sortedMigrations = sortAndValidateMigrations(migrations);
-            migrationsMap.set(pluginKey, sortedMigrations);
-        },
-        getSchemaCreator(pluginKey) {
-            return schemas.get(pluginKey);
-        },
-        getMigrations(pluginKey) {
-            return migrationsMap.get(pluginKey);
-        },
-        getLastMigrationVersion(pluginKey) {
-            const migrations = migrationsMap.get(pluginKey);
-            return migrations?.[migrations.length - 1]?.version;
-        },
-    };
-}
-/**
- * Spec for adding config for the plugin in the core plugin e.g.
- * {
- *  "plugins": [{
- *    "id": "...",
- *    "config": {
- *       ...PluginConfig schema
- *    }
- *  }]
- * }
- */
-const pluginConfigSpec = createPluginSpec('core/plugin-config', {
-    defaultInitializer: createPluginConfigImplementation,
-});
-
-function runPluginMigrations(projectDefinition, pluginImplementationStore) {
-    const pluginConfigService = pluginImplementationStore.getPluginSpec(pluginConfigSpec);
-    return produce(projectDefinition, (draft) => {
-        for (const pluginDefinition of draft.plugins ?? []) {
-            const pluginMigrations = pluginConfigService.getMigrations(pluginEntityType.keyFromId(pluginDefinition.id));
-            const currentSchemaVersion = pluginDefinition.configSchemaVersion ?? -1;
-            if (!pluginMigrations)
-                continue;
-            const lastPluginMigration = pluginMigrations.at(-1);
-            if (!lastPluginMigration)
-                continue;
-            for (const migration of pluginMigrations) {
-                if (migration.version > currentSchemaVersion) {
-                    try {
-                        const migrationResult = migration.migrate(pluginDefinition.config, draft);
-                        if (migrationResult.updatedConfig !== undefined) {
-                            pluginDefinition.config = migrationResult.updatedConfig;
-                        }
-                        if (migrationResult.updateProjectDefinition) {
-                            migrationResult.updateProjectDefinition(draft);
-                        }
-                    }
-                    catch (error) {
-                        throw new Error(`Error migrating plugin ${pluginDefinition.id} to version ${migration.version}: ${String(error)}`);
-                    }
-                }
-            }
-            pluginDefinition.configSchemaVersion = lastPluginMigration.version;
-        }
-    });
-}
-
-/**
- * Spec for adding config component for plugin
- */
-const authConfigSpec = createPluginSpec('core/auth-config', {});
-
-/**
- * Spec for adding user model config component for plugin
- */
-const authModelConfigSpec = createPluginSpec('core/auth-model-config', {});
-
-function createWebConfigImplementation() {
-    const components = new Map();
-    return {
-        registerWebConfigComponent(pluginKey, ConfigComponent) {
-            if (components.has(pluginKey)) {
-                throw new Error(`Web config component for plugin ${pluginKey} is already registered`);
-            }
-            components.set(pluginKey, ConfigComponent);
-        },
-        getWebConfigComponent(pluginKey) {
-            return components.get(pluginKey);
-        },
-    };
-}
-/**
- * Spec for adding config component for plugin
- */
-const webConfigSpec = createPluginSpec('core/web-config', {
-    platforms: 'web',
-    defaultInitializer: createWebConfigImplementation,
-});
-
-const {safeMerge} = await importShared('@baseplate-dev/utils');
-function createAppCompiler() {
-    const children = {};
-    let rootChildren = {};
-    return {
-        addChildrenToFeature(featureId, newChildren) {
-            children[featureId] = safeMerge(children[featureId] ?? {}, newChildren);
-        },
-        getChildrenForFeature(featureId) {
-            return children[featureId] ?? {};
-        },
-        addRootChildren(newChildren) {
-            rootChildren = safeMerge(rootChildren, newChildren);
-        },
-        getRootChildren() {
-            return rootChildren;
-        },
-    };
-}
-function createAppCompilerPlugin() {
-    const compilers = new Map();
-    return {
-        registerAppCompiler(compiler) {
-            const appCompilers = compilers.get(compiler.appType) ?? [];
-            if (!compilers.has(compiler.appType)) {
-                compilers.set(compiler.appType, appCompilers);
-            }
-            appCompilers.push(compiler);
-        },
-        getAppCompilers(appType) {
-            return compilers.get(appType) ?? [];
-        },
-    };
-}
-/**
- * Spec for modifying the app compiler
- */
-const appCompilerSpec = createPluginSpec('AppCompiler', {
-    defaultInitializer: createAppCompilerPlugin,
-});
-
-function createModelTransformerCompilerImplementation() {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const transformers = new Map();
-    return {
-        registerTransformerCompiler(transformer) {
-            if (transformers.has(transformer.name)) {
-                throw new Error(`Model transformer with name ${transformer.name} is already registered`);
-            }
-            transformers.set(transformer.name, transformer);
-        },
-        getModelTransformerCompiler(name, builtInTransformers = []) {
-            const builtInTransformer = builtInTransformers.find((b) => b.name === name);
-            if (builtInTransformer) {
-                return builtInTransformer;
-            }
-            const transformer = transformers.get(name);
-            if (!transformer) {
-                throw new Error(`Unable to find transformer with name ${name}`);
-            }
-            return transformer;
-        },
-    };
-}
-/**
- * Spec for adding config component for plugin
- */
-const modelTransformerCompilerSpec = createPluginSpec('core/model-transformer-compiler', { defaultInitializer: createModelTransformerCompilerImplementation });
+const modelTransformerCompilerSpec = createFieldMapSpec('core/model-transformer-compiler', (t) => ({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- plugins register varying transformer types at runtime
+    transformers: t.namedArrayToMap(),
+}));
 
 // obtained from Tailwind (https://github.com/tailwindlabs/tailwindcss/blob/master/src/public/colors.js)
 const PALETTE_SHADES = [
@@ -1756,595 +622,1270 @@ const THEME_COLORS = {
         category: 'utility',
     },
 };
-const THEME_COLOR_KEYS = Object.keys(THEME_COLORS);
+const THEME_COLOR_KEYS = Object.keys(THEME_COLORS);
+
+function cleanAndSplitPath(path) {
+    return path
+        .replace(/^\./, '')
+        .split('/')
+        .filter((segment) => segment !== '');
+}
+/**
+ * Computes the relative path from one path to another.
+ */
+function computeRelativePath(fromPath, toPath) {
+    const fromSegments = cleanAndSplitPath(fromPath);
+    const toSegments = cleanAndSplitPath(toPath);
+    // Remove the common segments from the beginning
+    while (fromSegments.length > 0 &&
+        toSegments.length > 0 &&
+        fromSegments[0] === toSegments[0]) {
+        fromSegments.shift();
+        toSegments.shift();
+    }
+    // Add the necessary number of '../' to go up the directory hierarchy
+    const numParentDirs = fromSegments.length;
+    const parentDirs = Array.from({ length: numParentDirs }).fill('..');
+    // Construct the relative path
+    const relativePath = [...parentDirs, ...toSegments].join('/');
+    return relativePath;
+}
+
+function byId$2(projectDefinition, id) {
+    const config = projectDefinition.apps.find((app) => app.id === id);
+    if (!config) {
+        throw new Error(`Unable to find app with ID ${id}`);
+    }
+    return config;
+}
+function getBackendApp(projectDefinition) {
+    const backendApps = projectDefinition.apps.filter((a) => a.type === 'backend');
+    if (backendApps.length > 1 || backendApps.length === 0) {
+        throw new Error(`Only one backend app is supported and must exist`);
+    }
+    const backendApp = backendApps[0];
+    return backendApp;
+}
+/**
+ * Given an app config, get the relative directory of the app
+ *
+ * @param appConfig The app config
+ * @param monorepoSettings Optional monorepo settings to determine apps folder location
+ * @returns The directory of the app
+ */
+function getAppDirectory(appConfig, monorepoSettings) {
+    const appsFolder = monorepoSettings?.appsFolder ?? 'apps';
+    return `${appsFolder}/${appConfig.name}`;
+}
+function getBackendRelativePath(appConfig, backendApp, monorepoSettings) {
+    const backendRelativePath = computeRelativePath(getAppDirectory(appConfig, monorepoSettings), getAppDirectory(backendApp, monorepoSettings));
+    return backendRelativePath;
+}
+const AppUtils = {
+    byId: byId$2,
+    getBackendApp,
+    getBackendRelativePath,
+    getAppDirectory,
+};
+
+function groupBy(arr, getKeyFromItem) {
+    const result = {};
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        const key = getKeyFromItem(item);
+        if (!Object.hasOwn(result, key)) {
+            result[key] = [];
+        }
+        result[key].push(item);
+    }
+    return result;
+}
+
+function keyBy(arr, getKeyFromItem) {
+    const result = {};
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        const key = getKeyFromItem(item);
+        result[key] = item;
+    }
+    return result;
+}
+
+function uniq(arr) {
+    return Array.from(new Set(arr));
+}
+
+function pickBy(obj, shouldPick) {
+    const result = {};
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        if (shouldPick(value, key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+function flow(...funcs) {
+    return function (...args) {
+        let result = funcs.length ? funcs[0].apply(this, args) : args[0];
+        for (let i = 1; i < funcs.length; i++) {
+            result = funcs[i].call(this, result);
+        }
+        return result;
+    };
+}
+
+const appEntityType = createEntityType('app');
+function createAppEntryType(name) {
+    return name;
+}
+
+const {CASE_VALIDATORS: CASE_VALIDATORS$3} = await importShared('@baseplate-dev/utils');
+
+const {z: z$v} = await importShared('zod');
+const baseAppValidators = {
+    id: z$v.string().default(appEntityType.generateNewId()),
+    name: CASE_VALIDATORS$3.KEBAB_CASE,
+    type: z$v.string(),
+};
+const baseAppSchema = z$v.object(baseAppValidators);
+
+const {z: z$u} = await importShared('zod');
+const createBackendAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, () => z$u.object({
+    ...baseAppValidators,
+    type: z$u.literal('backend'),
+    enableStripe: z$u.boolean().optional(),
+    enableSubscriptions: z$u.boolean().optional(),
+    enableAxios: z$u.boolean().optional(),
+}));
+const backendAppEntryType = createAppEntryType('backend');
+
+const authRoleEntityType = createEntityType('role');
+
+/**
+ * Creates a definition entity name resolver.
+ * @param entityNameResolver - The entity name resolver.
+ * @returns The definition entity name resolver.
+ */
+function createDefinitionEntityNameResolver(entityNameResolver) {
+    return entityNameResolver;
+}
+
+function collectRefAnnotationsRecursive(pathPrefix, value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (value instanceof DefinitionReferenceMarker) {
+        return {
+            entities: [],
+            references: [
+                { ...value.reference, path: [...pathPrefix, ...value.reference.path] },
+            ],
+            slots: [],
+        };
+    }
+    const collected = {
+        entities: [],
+        references: [],
+        slots: [],
+    };
+    if (Array.isArray(value)) {
+        for (const [i, element] of value.entries()) {
+            const childCollected = collectRefAnnotationsRecursive([...pathPrefix, i], element);
+            if (childCollected) {
+                collected.entities.push(...childCollected.entities);
+                collected.references.push(...childCollected.references);
+                collected.slots.push(...childCollected.slots);
+            }
+        }
+        return collected;
+    }
+    if (typeof value === 'object') {
+        if (REF_ANNOTATIONS_MARKER_SYMBOL in value) {
+            const annotations = value[REF_ANNOTATIONS_MARKER_SYMBOL];
+            collected.entities.push(...annotations.entities.map((entity) => ({
+                ...entity,
+                path: [...pathPrefix, ...entity.path],
+            })));
+            collected.references.push(...annotations.references.map((reference) => ({
+                ...reference,
+                path: [...pathPrefix, ...reference.path],
+            })));
+            collected.slots.push(...annotations.slots.map((slot) => ({
+                ...slot,
+                path: [...pathPrefix, ...slot.path],
+            })));
+        }
+        for (const [key, childValue] of Object.entries(value)) {
+            if (typeof key !== 'string')
+                continue;
+            const childCollected = collectRefAnnotationsRecursive([...pathPrefix, key], childValue);
+            if (childCollected) {
+                collected.entities.push(...childCollected.entities);
+                collected.references.push(...childCollected.references);
+                collected.slots.push(...childCollected.slots);
+            }
+        }
+        return collected;
+    }
+    return undefined;
+}
+function collectRefs(value) {
+    return (collectRefAnnotationsRecursive([], value) ?? {
+        entities: [],
+        references: [],
+        slots: [],
+    });
+}
+
+const {mapGroupBy} = await importShared('@baseplate-dev/utils');
+
+/**
+ * Calculates the length of the common prefix of two paths.
+ *
+ * @param a - The first path
+ * @param b - The second path
+ * @returns The length of the common prefix of the two paths
+ */
+function commonPrefixLength(a, b) {
+    let length = 0;
+    const maxLength = Math.min(a.length, b.length);
+    for (let i = 0; i < maxLength; i++) {
+        if (a[i] !== b[i])
+            break;
+        length++;
+    }
+    return length;
+}
+/**
+ * Finds the nearest ancestor slot for a given target path.
+ *
+ * @param candidateSlots - The candidate slots to search through.
+ * @param targetPath - The target path to find the nearest ancestor slot for.
+ * @returns The nearest ancestor slot, or undefined if no slot is found.
+ */
+function findNearestAncestorSlot(candidateSlots = [], targetPath) {
+    let bestMatch;
+    for (const candidateSlot of candidateSlots) {
+        const prefixLength = commonPrefixLength(candidateSlot.path, targetPath);
+        // A slot at path [] (root) is a valid ancestor of any path
+        // For non-root slots, require at least 1 common prefix element
+        const isValidAncestor = candidateSlot.path.length === 0 || prefixLength > 0;
+        if (isValidAncestor &&
+            (!bestMatch || prefixLength > bestMatch.prefixLength)) {
+            bestMatch = { prefixLength, slot: candidateSlot };
+        }
+    }
+    return bestMatch?.slot;
+}
+/**
+ * Resolves all slot references to actual paths.
+ *
+ * This function takes the collected refs (which have `parentSlot` references)
+ * and resolves them to `parentPath` values using the slotPaths map.
+ *
+ * For scoped slots (where the same slot can be registered multiple times),
+ * we find the registration whose path is the nearest ancestor of the entity/reference.
+ *
+ * @param collected - The collected refs with unresolved slots.
+ * @returns The resolved refs with parentPath instead of parentSlot.
+ * @throws If a required slot is not found in the slotPaths map.
+ */
+function resolveSlots(collected) {
+    const { entities, references, slots } = collected;
+    // Collect all slots by path
+    const slotsByType = mapGroupBy(slots, (slot) => slot.slot.id);
+    const resolvedSlotsByType = new Map();
+    function registerSlot(slot, resolvedPath) {
+        const slotId = slot.id;
+        const candidateSlots = slotsByType.get(slotId) ?? [];
+        const nearestAncestorSlot = findNearestAncestorSlot(candidateSlots, resolvedPath);
+        if (!nearestAncestorSlot) {
+            throw new Error(`Could not find slot "${slotId.description ?? 'unknown'}" ` +
+                `within path ${resolvedPath.join('.')}. Make sure the slot is registered for this path.`);
+        }
+        const existingSlots = resolvedSlotsByType.get(slotId) ?? [];
+        resolvedSlotsByType.set(slotId, [
+            ...existingSlots,
+            { resolvedPath, path: nearestAncestorSlot.path },
+        ]);
+    }
+    // Collect entity provides
+    for (const entity of entities) {
+        if (entity.provides) {
+            registerSlot(entity.provides, [...entity.path, ...entity.idPath]);
+        }
+    }
+    // Collect reference provides
+    for (const reference of references) {
+        if (reference.provides) {
+            registerSlot(reference.provides, reference.path);
+        }
+    }
+    return resolvedSlotsByType;
+}
 
-function cleanAndSplitPath(path) {
-    return path
-        .replace(/^\./, '')
-        .split('/')
-        .filter((segment) => segment !== '');
+/**
+ * Extracts definition refs from a parsed value using functional approach.
+ *
+ * Flow:
+ * 1. Collect all refs (entities, references, slots) recursively
+ * 2. Resolve all slot references to actual paths
+ * 3. Strip ref markers from the data
+ * 4. Validate no duplicate IDs
+ *
+ * @param value - The parsed value from Zod schema
+ * @returns The extracted refs with clean data
+ */
+function extractDefinitionRefs(value) {
+    // Step 1: Collect all refs without resolving slots
+    const collected = collectRefs(value);
+    // Step 2: Resolve all slots to paths
+    const resolvedSlots = resolveSlots(collected);
+    // Step 3: Strip markers from data
+    const cleanData = stripRefMarkers(value);
+    // Step 4: Resolve entity and reference parent paths
+    function resolveParentPath(parentSlot, path) {
+        const resolvedSlot = findNearestAncestorSlot(resolvedSlots.get(parentSlot.id), path);
+        if (!resolvedSlot) {
+            throw new Error(`Could not resolve parent path from ${path.join('.')} for slot ${parentSlot.id.description}`);
+        }
+        return resolvedSlot.resolvedPath;
+    }
+    const entitiesWithNameResolver = collected.entities.map((entity) => ({
+        id: entity.id,
+        idPath: entity.idPath,
+        nameResolver: entity.nameResolver,
+        type: entity.type,
+        path: entity.path,
+        parentPath: entity.parentSlot
+            ? resolveParentPath(entity.parentSlot, entity.path)
+            : undefined,
+    }));
+    const references = collected.references.map((reference) => ({
+        type: reference.type,
+        path: reference.path,
+        onDelete: reference.onDelete,
+        parentPath: reference.parentSlot
+            ? resolveParentPath(reference.parentSlot, reference.path)
+            : undefined,
+    }));
+    // Step 4: Validate no duplicate IDs
+    const idSet = new Set();
+    for (const entity of collected.entities) {
+        if (idSet.has(entity.id)) {
+            throw new Error(`Duplicate ID found: ${entity.id}`);
+        }
+        idSet.add(entity.id);
+    }
+    return {
+        data: cleanData,
+        references,
+        entitiesWithNameResolver,
+    };
 }
+
+const {toposort: toposort$1} = await importShared('@baseplate-dev/utils');
 /**
- * Computes the relative path from one path to another.
+ * Resolves entity names in a ZodRefPayload.
+ *
+ * @param payload - The ZodRefPayload to resolve.
+ * @param options - The options for resolving entity names.
+ *
+ * @template T - The type of the payload.
  */
-function computeRelativePath(fromPath, toPath) {
-    const fromSegments = cleanAndSplitPath(fromPath);
-    const toSegments = cleanAndSplitPath(toPath);
-    // Remove the common segments from the beginning
-    while (fromSegments.length > 0 &&
-        toSegments.length > 0 &&
-        fromSegments[0] === toSegments[0]) {
-        fromSegments.shift();
-        toSegments.shift();
+function resolveZodRefPayloadNames(payload, { skipReferenceNameResolution = false, allowInvalidReferences = false, } = {}) {
+    const { entitiesWithNameResolver, references, data } = payload;
+    const entitiesById = keyBy(entitiesWithNameResolver, (entity) => entity.id);
+    const resolvedEntitiesById = new Map();
+    // sort entities by dependency order
+    const orderedEntities = toposort$1(entitiesWithNameResolver.map((entity) => entity.id), entitiesWithNameResolver.flatMap((entity) => {
+        if (typeof entity.nameResolver !== 'object') {
+            return [];
+        }
+        const entityIds = entity.nameResolver.idsToResolve ?? {};
+        return Object.values(entityIds)
+            .flat()
+            .filter((id) => id in entitiesById)
+            .map((id) => [id, entity.id]);
+    }));
+    function resolveIdToName(id) {
+        if (skipReferenceNameResolution) {
+            return id;
+        }
+        const entity = resolvedEntitiesById.get(id);
+        if (!entity) {
+            if (allowInvalidReferences) {
+                return id;
+            }
+            throw new Error(`Could not resolve entity name for id: ${id}`);
+        }
+        return entity.name;
     }
-    // Add the necessary number of '../' to go up the directory hierarchy
-    const numParentDirs = fromSegments.length;
-    const parentDirs = Array.from({ length: numParentDirs }).fill('..');
-    // Construct the relative path
-    const relativePath = [...parentDirs, ...toSegments].join('/');
-    return relativePath;
+    for (const id of orderedEntities) {
+        const { nameResolver, ...rest } = entitiesById[id];
+        if (typeof nameResolver === 'string') {
+            resolvedEntitiesById.set(rest.id, {
+                ...rest,
+                name: nameResolver,
+            });
+        }
+        else {
+            const resolvedIds = mapValues(nameResolver.idsToResolve ?? {}, (idOrIds) => Array.isArray(idOrIds)
+                ? idOrIds.map((id) => resolveIdToName(id))
+                : resolveIdToName(idOrIds));
+            resolvedEntitiesById.set(rest.id, {
+                ...rest,
+                name: nameResolver.resolveName(resolvedIds),
+            });
+        }
+    }
+    return {
+        entities: [...resolvedEntitiesById.values()],
+        references,
+        data,
+    };
+}
+
+/**
+ * Parses a schema with references.
+ *
+ * @param schema - The schema to parse.
+ * @param input - The input to parse.
+ * @param options - The options for parsing the schema.
+ *
+ * @returns The parsed data.
+ */
+function parseSchemaWithTransformedReferences(schemaCreator, input, schemaCreatorOptions, options) {
+    const schemaContext = createDefinitionSchemaParserContext({
+        ...schemaCreatorOptions,
+        transformReferences: true,
+    });
+    const schema = schemaCreator(schemaContext);
+    const value = schema.parse(input);
+    const refPayload = extractDefinitionRefs(value);
+    return resolveZodRefPayloadNames(refPayload, options);
+}
+
+const {toposort} = await importShared('@baseplate-dev/utils');
+function referenceToNameParentId(name, parentId) {
+    return JSON.stringify({ name, parentId });
+}
+/**
+ * Deserialize a schema with references using the new transform-based approach.
+ * This function converts human-readable names back to entity IDs.
+ *
+ * @template T - The schema creator type
+ * @param schemaCreator - The schema creator function
+ * @param input - The input data with names instead of IDs
+ * @param options - Options for the schema creator (excluding transformReferences)
+ * @returns The resolved payload with IDs instead of names
+ */
+function deserializeSchemaWithTransformedReferences(schemaCreator, input, options) {
+    const payload = parseSchemaWithTransformedReferences(schemaCreator, input, options, {
+        skipReferenceNameResolution: true,
+    });
+    // Use the same resolution logic as the original function
+    return resolveReferencesToIds(payload);
+}
+/**
+ * Internal function to resolve entity names to IDs in the payload.
+ * This is shared logic between the old and new approaches.
+ *
+ * @param payload - The parsed payload with entities and references
+ * @returns The payload with references resolved to IDs
+ */
+function resolveReferencesToIds(payload) {
+    const { references, entities, data } = payload;
+    if (typeof data !== 'object' || data === null) {
+        throw new TypeError('Data is not an object');
+    }
+    // check we don't have more entities than IDs
+    const entitiesById = groupBy(entities, (entity) => entity.id);
+    const duplicateEntityIds = Object.values(entitiesById).filter((e) => e.length > 1);
+    if (duplicateEntityIds.length > 0) {
+        throw new Error(`Found multiple duplicate entity IDs: ${duplicateEntityIds
+            .map((ents) => `${ents[0].id} (${ents.map((e) => e.path.join('.')).join(',')})`)
+            .join(', ')}`);
+    }
+    const uniqueEntityIds = uniq(entities.map((e) => e.id));
+    if (uniqueEntityIds.length !== entities.length) {
+        throw new Error(`Found duplicate entity IDs`);
+    }
+    // collect reference entity types
+    const entityTypes = uniq(entities.map((e) => e.type));
+    const entityTypeNames = uniq(entityTypes.map((t) => t.name));
+    if (entityTypeNames.length !== entityTypes.length) {
+        throw new Error(`Found more entity types than entity type names implying duplicate entity type name`);
+    }
+    const entityTypeOrder = toposort(entityTypeNames, entityTypes
+        .filter((entityType) => !!entityType.parentType)
+        .map((entityType) => [
+        entityType.parentType?.name ?? '',
+        entityType.name,
+    ]));
+    const entitiesByType = groupBy(entities, (e) => e.type.name);
+    const referencesByType = groupBy(references, (r) => r.type.name);
+    for (const name of entityTypeOrder) {
+        const entities = entitiesByType[name] ?? [];
+        const references = referencesByType[name] ?? [];
+        // resolve references to their ID
+        const entitiesByParentIdName = keyBy(entities, (e) => {
+            const { parentPath } = e;
+            const parentId = parentPath
+                ? get(data, parentPath)
+                : undefined;
+            if (parentPath && typeof parentId !== 'string') {
+                throw new Error(`Could not resolve parent path: ${parentPath.join('.')}`);
+            }
+            return referenceToNameParentId(e.name, parentId);
+        });
+        for (const ref of references) {
+            const name = get(data, ref.path);
+            // parent ID should have already been resolved due to order of resolving references
+            const parentId = ref.parentPath && get(data, ref.parentPath);
+            const parentIdName = referenceToNameParentId(name, parentId);
+            const resolvedEntity = entitiesByParentIdName[parentIdName];
+            if (!resolvedEntity) {
+                throw new Error(`Unable to resolve reference: ${ref.path.join('.')} (${ref.type.name} ${parentIdName})`);
+            }
+            set$1(data, ref.path, resolvedEntity.id);
+        }
+    }
+    return payload;
 }
 
-function byId$2(projectDefinition, id) {
-    const config = projectDefinition.apps.find((app) => app.id === id);
-    if (!config) {
-        throw new Error(`Unable to find app with ID ${id}`);
+// sentinel ID to signify the reference has been flagged for deletion
+const DELETED_SENTINEL_ID = 'deleted-sentinel-id';
+/**
+ * Fixes any reference deletions by performing the appropriate action for the reference
+ */
+function fixRefDeletions(schemaCreator, value, schemaCreatorOptions) {
+    const issues = [];
+    // find all references that do not have a corresponding entity
+    let iterations;
+    let valueToEdit = value;
+    for (iterations = 0; iterations < 100; iterations++) {
+        const parseResult = parseSchemaWithTransformedReferences(schemaCreator, valueToEdit, schemaCreatorOptions, {
+            allowInvalidReferences: true,
+        });
+        const { references, entities } = parseResult;
+        valueToEdit = parseResult.data;
+        const entitiesById = new Map(entities.map((e) => [e.id, e]));
+        const referencesMissingEntity = references.filter((r) => {
+            const id = get(valueToEdit, r.path);
+            return id !== DELETED_SENTINEL_ID && !entitiesById.has(id);
+        });
+        if (referencesMissingEntity.length === 0) {
+            if (issues.length > 0) {
+                return {
+                    type: 'failure',
+                    issues,
+                };
+            }
+            return {
+                type: 'success',
+                value: valueToEdit,
+                refPayload: parseResult,
+            };
+        }
+        const objectsToDeleteInArray = [];
+        function tryDeleteParent(path) {
+            if (path.length === 0) {
+                return false;
+            }
+            const parentPath = path.slice(0, -1);
+            const parent = get(valueToEdit, parentPath);
+            if (!Array.isArray(parent)) {
+                return false;
+            }
+            objectsToDeleteInArray.push({
+                path: parentPath,
+                idx: path.at(-1),
+            });
+            return true;
+        }
+        // attempt to fix reference
+        for (const ref of referencesMissingEntity) {
+            const id = get(valueToEdit, ref.path);
+            switch (ref.onDelete) {
+                case 'SET_UNDEFINED': {
+                    // Check if reference is inside an array
+                    if (ref.path.length > 0) {
+                        const parentPath = ref.path.slice(0, -1);
+                        const parent = get(valueToEdit, parentPath);
+                        if (Array.isArray(parent)) {
+                            throw new TypeError(`SET_UNDEFINED cannot be used for references inside arrays at path ${ref.path.join('.')}. Use DELETE instead to remove the array element.`);
+                        }
+                    }
+                    set$1(valueToEdit, ref.path, undefined);
+                    break;
+                }
+                case 'RESTRICT': {
+                    issues.push({ ref, entityId: id });
+                    set$1(valueToEdit, ref.path, DELETED_SENTINEL_ID);
+                    break;
+                }
+                case 'DELETE': {
+                    if (!tryDeleteParent(ref.path)) {
+                        throw new Error(`Unable to find ref to cascade delete to`);
+                    }
+                    break;
+                }
+                case 'DELETE_PARENT': {
+                    if (!tryDeleteParent(ref.path.slice(0, -1))) {
+                        throw new Error(`Unable to find ref to cascade delete to`);
+                    }
+                    break;
+                }
+                default: {
+                    throw new Error(`Unknown onDelete action ${ref.onDelete}`);
+                }
+            }
+        }
+        const objectsToDeleteByPath = groupBy(objectsToDeleteInArray, (o) => o.path.join('.'));
+        // delete objects in reverse order to avoid index shifting
+        for (const [, objects] of Object.entries(objectsToDeleteByPath)) {
+            const sortedObjects = sortBy(objects, [(o) => -o.idx]);
+            for (const o of sortedObjects) {
+                const parent = get(valueToEdit, o.path);
+                if (!Array.isArray(parent)) {
+                    throw new TypeError(`Expected parent to be an array at path ${o.path.join('.')}`);
+                }
+                parent.splice(o.idx, 1);
+            }
+        }
     }
-    return config;
+    throw new Error(`Exceeded max iterations fixing deletions`);
 }
-function getBackendApp(projectDefinition) {
-    const backendApps = projectDefinition.apps.filter((a) => a.type === 'backend');
-    if (backendApps.length > 1 || backendApps.length === 0) {
-        throw new Error(`Only one backend app is supported and must exist`);
-    }
-    const backendApp = backendApps[0];
-    return backendApp;
+
+var NOTHING = Symbol.for("immer-nothing");
+var DRAFTABLE = Symbol.for("immer-draftable");
+var DRAFT_STATE = Symbol.for("immer-state");
+function die(error, ...args) {
+  throw new Error(
+    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
+  );
 }
-/**
- * Given an app config, get the relative directory of the app
- *
- * @param appConfig The app config
- * @param monorepoSettings Optional monorepo settings to determine apps folder location
- * @returns The directory of the app
- */
-function getAppDirectory(appConfig, monorepoSettings) {
-    const appsFolder = monorepoSettings?.appsFolder ?? 'apps';
-    return `${appsFolder}/${appConfig.name}`;
+var getPrototypeOf = Object.getPrototypeOf;
+function isDraft(value) {
+  return !!value && !!value[DRAFT_STATE];
 }
-function getBackendRelativePath(appConfig, backendApp, monorepoSettings) {
-    const backendRelativePath = computeRelativePath(getAppDirectory(appConfig, monorepoSettings), getAppDirectory(backendApp, monorepoSettings));
-    return backendRelativePath;
+function isDraftable(value) {
+  if (!value)
+    return false;
+  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
 }
-const AppUtils = {
-    byId: byId$2,
-    getBackendApp,
-    getBackendRelativePath,
-    getAppDirectory,
-};
-
-const appEntityType = createEntityType('app');
-function createAppEntryType(name) {
-    return name;
+var objectCtorString = Object.prototype.constructor.toString();
+function isPlainObject(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const proto = getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object)
+    return true;
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
 }
-
-const {CASE_VALIDATORS: CASE_VALIDATORS$3} = await importShared('@baseplate-dev/utils');
-
-const {z: z$t} = await importShared('zod');
-const baseAppValidators = {
-    id: z$t.string().default(appEntityType.generateNewId()),
-    name: CASE_VALIDATORS$3.KEBAB_CASE,
-    type: z$t.string(),
-};
-const baseAppSchema = z$t.object(baseAppValidators);
-
-const {z: z$s} = await importShared('zod');
-const createBackendAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, () => z$s.object({
-    ...baseAppValidators,
-    type: z$s.literal('backend'),
-    enableStripe: z$s.boolean().optional(),
-    enablePostmark: z$s.boolean().optional(),
-    enableSubscriptions: z$s.boolean().optional(),
-    enableAxios: z$s.boolean().optional(),
-}));
-const backendAppEntryType = createAppEntryType('backend');
-
-const authRoleEntityType = createEntityType('role');
-
-/**
- * Creates a definition entity name resolver.
- * @param entityNameResolver - The entity name resolver.
- * @returns The definition entity name resolver.
- */
-function createDefinitionEntityNameResolver(entityNameResolver) {
-    return entityNameResolver;
+function each(obj, iter) {
+  if (getArchtype(obj) === 0) {
+    Reflect.ownKeys(obj).forEach((key) => {
+      iter(key, obj[key], obj);
+    });
+  } else {
+    obj.forEach((entry, index) => iter(index, entry, obj));
+  }
 }
-
-function collectRefAnnotationsRecursive(pathPrefix, value) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (value instanceof DefinitionReferenceMarker) {
-        return {
-            entities: [],
-            references: [
-                { ...value.reference, path: [...pathPrefix, ...value.reference.path] },
-            ],
-            slots: [],
+function getArchtype(thing) {
+  const state = thing[DRAFT_STATE];
+  return state ? state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
+}
+function has(thing, prop) {
+  return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+}
+function set(thing, propOrOldValue, value) {
+  const t = getArchtype(thing);
+  if (t === 2)
+    thing.set(propOrOldValue, value);
+  else if (t === 3) {
+    thing.add(value);
+  } else
+    thing[propOrOldValue] = value;
+}
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+function isMap(target) {
+  return target instanceof Map;
+}
+function isSet(target) {
+  return target instanceof Set;
+}
+function latest(state) {
+  return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
+  }
+  if (isSet(base)) {
+    return new Set(base);
+  }
+  if (Array.isArray(base))
+    return Array.prototype.slice.call(base);
+  const isPlain = isPlainObject(base);
+  if (strict === true || strict === "class_only" && !isPlain) {
+    const descriptors = Object.getOwnPropertyDescriptors(base);
+    delete descriptors[DRAFT_STATE];
+    let keys = Reflect.ownKeys(descriptors);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const desc = descriptors[key];
+      if (desc.writable === false) {
+        desc.writable = true;
+        desc.configurable = true;
+      }
+      if (desc.get || desc.set)
+        descriptors[key] = {
+          configurable: true,
+          writable: true,
+          // could live with !!desc.set as well here...
+          enumerable: desc.enumerable,
+          value: base[key]
         };
     }
-    const collected = {
-        entities: [],
-        references: [],
-        slots: [],
-    };
-    if (Array.isArray(value)) {
-        for (const [i, element] of value.entries()) {
-            const childCollected = collectRefAnnotationsRecursive([...pathPrefix, i], element);
-            if (childCollected) {
-                collected.entities.push(...childCollected.entities);
-                collected.references.push(...childCollected.references);
-                collected.slots.push(...childCollected.slots);
-            }
-        }
-        return collected;
-    }
-    if (typeof value === 'object') {
-        if (REF_ANNOTATIONS_MARKER_SYMBOL in value) {
-            const annotations = value[REF_ANNOTATIONS_MARKER_SYMBOL];
-            collected.entities.push(...annotations.entities.map((entity) => ({
-                ...entity,
-                path: [...pathPrefix, ...entity.path],
-            })));
-            collected.references.push(...annotations.references.map((reference) => ({
-                ...reference,
-                path: [...pathPrefix, ...reference.path],
-            })));
-            collected.slots.push(...annotations.slots.map((slot) => ({
-                ...slot,
-                path: [...pathPrefix, ...slot.path],
-            })));
-        }
-        for (const [key, childValue] of Object.entries(value)) {
-            if (typeof key !== 'string')
-                continue;
-            const childCollected = collectRefAnnotationsRecursive([...pathPrefix, key], childValue);
-            if (childCollected) {
-                collected.entities.push(...childCollected.entities);
-                collected.references.push(...childCollected.references);
-                collected.slots.push(...childCollected.slots);
-            }
-        }
-        return collected;
+    return Object.create(getPrototypeOf(base), descriptors);
+  } else {
+    const proto = getPrototypeOf(base);
+    if (proto !== null && isPlain) {
+      return { ...base };
     }
-    return undefined;
+    const obj = Object.create(proto);
+    return Object.assign(obj, base);
+  }
 }
-function collectRefs(value) {
-    return (collectRefAnnotationsRecursive([], value) ?? {
-        entities: [],
-        references: [],
-        slots: [],
-    });
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
+  }
+  Object.freeze(obj);
+  if (deep)
+    Object.entries(obj).forEach(([key, value]) => freeze(value, true));
+  return obj;
 }
-
-const {mapGroupBy} = await importShared('@baseplate-dev/utils');
-
-/**
- * Calculates the length of the common prefix of two paths.
- *
- * @param a - The first path
- * @param b - The second path
- * @returns The length of the common prefix of the two paths
- */
-function commonPrefixLength(a, b) {
-    let length = 0;
-    const maxLength = Math.min(a.length, b.length);
-    for (let i = 0; i < maxLength; i++) {
-        if (a[i] !== b[i])
-            break;
-        length++;
-    }
-    return length;
+function dontMutateFrozenCollections() {
+  die(2);
 }
-/**
- * Finds the nearest ancestor slot for a given target path.
- *
- * @param candidateSlots - The candidate slots to search through.
- * @param targetPath - The target path to find the nearest ancestor slot for.
- * @returns The nearest ancestor slot, or undefined if no slot is found.
- */
-function findNearestAncestorSlot(candidateSlots = [], targetPath) {
-    let bestMatch;
-    for (const candidateSlot of candidateSlots) {
-        const prefixLength = commonPrefixLength(candidateSlot.path, targetPath);
-        // A slot at path [] (root) is a valid ancestor of any path
-        // For non-root slots, require at least 1 common prefix element
-        const isValidAncestor = candidateSlot.path.length === 0 || prefixLength > 0;
-        if (isValidAncestor &&
-            (!bestMatch || prefixLength > bestMatch.prefixLength)) {
-            bestMatch = { prefixLength, slot: candidateSlot };
-        }
-    }
-    return bestMatch?.slot;
+function isFrozen(obj) {
+  return Object.isFrozen(obj);
 }
-/**
- * Resolves all slot references to actual paths.
- *
- * This function takes the collected refs (which have `parentSlot` references)
- * and resolves them to `parentPath` values using the slotPaths map.
- *
- * For scoped slots (where the same slot can be registered multiple times),
- * we find the registration whose path is the nearest ancestor of the entity/reference.
- *
- * @param collected - The collected refs with unresolved slots.
- * @returns The resolved refs with parentPath instead of parentSlot.
- * @throws If a required slot is not found in the slotPaths map.
- */
-function resolveSlots(collected) {
-    const { entities, references, slots } = collected;
-    // Collect all slots by path
-    const slotsByType = mapGroupBy(slots, (slot) => slot.slot.id);
-    const resolvedSlotsByType = new Map();
-    function registerSlot(slot, resolvedPath) {
-        const slotId = slot.id;
-        const candidateSlots = slotsByType.get(slotId) ?? [];
-        const nearestAncestorSlot = findNearestAncestorSlot(candidateSlots, resolvedPath);
-        if (!nearestAncestorSlot) {
-            throw new Error(`Could not find slot "${slotId.description ?? 'unknown'}" ` +
-                `within path ${resolvedPath.join('.')}. Make sure the slot is registered for this path.`);
-        }
-        const existingSlots = resolvedSlotsByType.get(slotId) ?? [];
-        resolvedSlotsByType.set(slotId, [
-            ...existingSlots,
-            { resolvedPath, path: nearestAncestorSlot.path },
-        ]);
-    }
-    // Collect entity provides
-    for (const entity of entities) {
-        if (entity.provides) {
-            registerSlot(entity.provides, [...entity.path, ...entity.idPath]);
-        }
-    }
-    // Collect reference provides
-    for (const reference of references) {
-        if (reference.provides) {
-            registerSlot(reference.provides, reference.path);
-        }
-    }
-    return resolvedSlotsByType;
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
+  }
+  return plugin;
 }
-
-/**
- * Extracts definition refs from a parsed value using functional approach.
- *
- * Flow:
- * 1. Collect all refs (entities, references, slots) recursively
- * 2. Resolve all slot references to actual paths
- * 3. Strip ref markers from the data
- * 4. Validate no duplicate IDs
- *
- * @param value - The parsed value from Zod schema
- * @returns The extracted refs with clean data
- */
-function extractDefinitionRefs(value) {
-    // Step 1: Collect all refs without resolving slots
-    const collected = collectRefs(value);
-    // Step 2: Resolve all slots to paths
-    const resolvedSlots = resolveSlots(collected);
-    // Step 3: Strip markers from data
-    const cleanData = stripRefMarkers(value);
-    // Step 4: Resolve entity and reference parent paths
-    function resolveParentPath(parentSlot, path) {
-        const resolvedSlot = findNearestAncestorSlot(resolvedSlots.get(parentSlot.id), path);
-        if (!resolvedSlot) {
-            throw new Error(`Could not resolve parent path from ${path.join('.')} for slot ${parentSlot.id.description}`);
-        }
-        return resolvedSlot.resolvedPath;
+var currentScope;
+function getCurrentScope() {
+  return currentScope;
+}
+function createScope(parent_, immer_) {
+  return {
+    drafts_: [],
+    parent_,
+    immer_,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: true,
+    unfinalizedDrafts_: 0
+  };
+}
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    getPlugin("Patches");
+    scope.patches_ = [];
+    scope.inversePatches_ = [];
+    scope.patchListener_ = patchListener;
+  }
+}
+function revokeScope(scope) {
+  leaveScope(scope);
+  scope.drafts_.forEach(revokeDraft);
+  scope.drafts_ = null;
+}
+function leaveScope(scope) {
+  if (scope === currentScope) {
+    currentScope = scope.parent_;
+  }
+}
+function enterScope(immer2) {
+  return currentScope = createScope(currentScope, immer2);
+}
+function revokeDraft(draft) {
+  const state = draft[DRAFT_STATE];
+  if (state.type_ === 0 || state.type_ === 1)
+    state.revoke_();
+  else
+    state.revoked_ = true;
+}
+function processResult(result, scope) {
+  scope.unfinalizedDrafts_ = scope.drafts_.length;
+  const baseDraft = scope.drafts_[0];
+  const isReplaced = result !== void 0 && result !== baseDraft;
+  if (isReplaced) {
+    if (baseDraft[DRAFT_STATE].modified_) {
+      revokeScope(scope);
+      die(4);
+    }
+    if (isDraftable(result)) {
+      result = finalize(scope, result);
+      if (!scope.parent_)
+        maybeFreeze(scope, result);
     }
-    const entitiesWithNameResolver = collected.entities.map((entity) => ({
-        id: entity.id,
-        idPath: entity.idPath,
-        nameResolver: entity.nameResolver,
-        type: entity.type,
-        path: entity.path,
-        parentPath: entity.parentSlot
-            ? resolveParentPath(entity.parentSlot, entity.path)
-            : undefined,
-    }));
-    const references = collected.references.map((reference) => ({
-        type: reference.type,
-        path: reference.path,
-        onDelete: reference.onDelete,
-        parentPath: reference.parentSlot
-            ? resolveParentPath(reference.parentSlot, reference.path)
-            : undefined,
-    }));
-    // Step 4: Validate no duplicate IDs
-    const idSet = new Set();
-    for (const entity of collected.entities) {
-        if (idSet.has(entity.id)) {
-            throw new Error(`Duplicate ID found: ${entity.id}`);
-        }
-        idSet.add(entity.id);
+    if (scope.patches_) {
+      getPlugin("Patches").generateReplacementPatches_(
+        baseDraft[DRAFT_STATE].base_,
+        result,
+        scope.patches_,
+        scope.inversePatches_
+      );
     }
-    return {
-        data: cleanData,
-        references,
-        entitiesWithNameResolver,
-    };
+  } else {
+    result = finalize(scope, baseDraft, []);
+  }
+  revokeScope(scope);
+  if (scope.patches_) {
+    scope.patchListener_(scope.patches_, scope.inversePatches_);
+  }
+  return result !== NOTHING ? result : void 0;
 }
-
-const {toposort: toposort$1} = await importShared('@baseplate-dev/utils');
-/**
- * Resolves entity names in a ZodRefPayload.
- *
- * @param payload - The ZodRefPayload to resolve.
- * @param options - The options for resolving entity names.
- *
- * @template T - The type of the payload.
- */
-function resolveZodRefPayloadNames(payload, { skipReferenceNameResolution = false, allowInvalidReferences = false, } = {}) {
-    const { entitiesWithNameResolver, references, data } = payload;
-    const entitiesById = keyBy(entitiesWithNameResolver, (entity) => entity.id);
-    const resolvedEntitiesById = new Map();
-    // sort entities by dependency order
-    const orderedEntities = toposort$1(entitiesWithNameResolver.map((entity) => entity.id), entitiesWithNameResolver.flatMap((entity) => {
-        if (typeof entity.nameResolver !== 'object') {
-            return [];
-        }
-        const entityIds = entity.nameResolver.idsToResolve ?? {};
-        return Object.values(entityIds)
-            .flat()
-            .filter((id) => id in entitiesById)
-            .map((id) => [id, entity.id]);
-    }));
-    function resolveIdToName(id) {
-        if (skipReferenceNameResolution) {
-            return id;
-        }
-        const entity = resolvedEntitiesById.get(id);
-        if (!entity) {
-            if (allowInvalidReferences) {
-                return id;
-            }
-            throw new Error(`Could not resolve entity name for id: ${id}`);
-        }
-        return entity.name;
+function finalize(rootScope, value, path) {
+  if (isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  if (!state) {
+    each(
+      value,
+      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)
+    );
+    return value;
+  }
+  if (state.scope_ !== rootScope)
+    return value;
+  if (!state.modified_) {
+    maybeFreeze(rootScope, state.base_, true);
+    return state.base_;
+  }
+  if (!state.finalized_) {
+    state.finalized_ = true;
+    state.scope_.unfinalizedDrafts_--;
+    const result = state.copy_;
+    let resultEach = result;
+    let isSet2 = false;
+    if (state.type_ === 3) {
+      resultEach = new Set(result);
+      result.clear();
+      isSet2 = true;
     }
-    for (const id of orderedEntities) {
-        const { nameResolver, ...rest } = entitiesById[id];
-        if (typeof nameResolver === 'string') {
-            resolvedEntitiesById.set(rest.id, {
-                ...rest,
-                name: nameResolver,
-            });
-        }
-        else {
-            const resolvedIds = mapValues(nameResolver.idsToResolve ?? {}, (idOrIds) => Array.isArray(idOrIds)
-                ? idOrIds.map((id) => resolveIdToName(id))
-                : resolveIdToName(idOrIds));
-            resolvedEntitiesById.set(rest.id, {
-                ...rest,
-                name: nameResolver.resolveName(resolvedIds),
-            });
-        }
+    each(
+      resultEach,
+      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)
+    );
+    maybeFreeze(rootScope, result, false);
+    if (path && rootScope.patches_) {
+      getPlugin("Patches").generatePatches_(
+        state,
+        path,
+        rootScope.patches_,
+        rootScope.inversePatches_
+      );
     }
-    return {
-        entities: [...resolvedEntitiesById.values()],
-        references,
-        data,
-    };
+  }
+  return state.copy_;
 }
-
-/**
- * Parses a schema with references.
- *
- * @param schema - The schema to parse.
- * @param input - The input to parse.
- * @param options - The options for parsing the schema.
- *
- * @returns The parsed data.
- */
-function parseSchemaWithTransformedReferences(schemaCreator, input, schemaCreatorOptions, options) {
-    const schemaContext = createDefinitionSchemaParserContext({
-        ...schemaCreatorOptions,
-        transformReferences: true,
-    });
-    const schema = schemaCreator(schemaContext);
-    const value = schema.parse(input);
-    const refPayload = extractDefinitionRefs(value);
-    return resolveZodRefPayloadNames(refPayload, options);
+function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+  if (isDraft(childValue)) {
+    const path = rootPath && parentState && parentState.type_ !== 3 && // Set objects are atomic since they have no keys.
+    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
+    const res = finalize(rootScope, childValue, path);
+    set(targetObject, prop, res);
+    if (isDraft(res)) {
+      rootScope.canAutoFreeze_ = false;
+    } else
+      return;
+  } else if (targetIsSet) {
+    targetObject.add(childValue);
+  }
+  if (isDraftable(childValue) && !isFrozen(childValue)) {
+    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+      return;
+    }
+    finalize(rootScope, childValue);
+    if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && Object.prototype.propertyIsEnumerable.call(targetObject, prop))
+      maybeFreeze(rootScope, childValue);
+  }
 }
-
-const {toposort} = await importShared('@baseplate-dev/utils');
-function referenceToNameParentId(name, parentId) {
-    return JSON.stringify({ name, parentId });
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
 }
-/**
- * Deserialize a schema with references using the new transform-based approach.
- * This function converts human-readable names back to entity IDs.
- *
- * @template T - The schema creator type
- * @param schemaCreator - The schema creator function
- * @param input - The input data with names instead of IDs
- * @param options - Options for the schema creator (excluding transformReferences)
- * @returns The resolved payload with IDs instead of names
- */
-function deserializeSchemaWithTransformedReferences(schemaCreator, input, options) {
-    const payload = parseSchemaWithTransformedReferences(schemaCreator, input, options, {
-        skipReferenceNameResolution: true,
-    });
-    // Use the same resolution logic as the original function
-    return resolveReferencesToIds(payload);
+function createProxyProxy(base, parent) {
+  const isArray = Array.isArray(base);
+  const state = {
+    type_: isArray ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: parent ? parent.scope_ : getCurrentScope(),
+    // True for both shallow and deep changes.
+    modified_: false,
+    // Used during finalization.
+    finalized_: false,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: parent,
+    // The base state.
+    base_: base,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: false
+  };
+  let target = state;
+  let traps = objectTraps;
+  if (isArray) {
+    target = [state];
+    traps = arrayTraps;
+  }
+  const { revoke, proxy } = Proxy.revocable(target, traps);
+  state.draft_ = proxy;
+  state.revoke_ = revoke;
+  return proxy;
 }
-/**
- * Internal function to resolve entity names to IDs in the payload.
- * This is shared logic between the old and new approaches.
- *
- * @param payload - The parsed payload with entities and references
- * @returns The payload with references resolved to IDs
- */
-function resolveReferencesToIds(payload) {
-    const { references, entities, data } = payload;
-    if (typeof data !== 'object' || data === null) {
-        throw new TypeError('Data is not an object');
+var objectTraps = {
+  get(state, prop) {
+    if (prop === DRAFT_STATE)
+      return state;
+    const source = latest(state);
+    if (!has(source, prop)) {
+      return readPropFromProto(state, source, prop);
     }
-    // check we don't have more entities than IDs
-    const entitiesById = groupBy(entities, (entity) => entity.id);
-    const duplicateEntityIds = Object.values(entitiesById).filter((e) => e.length > 1);
-    if (duplicateEntityIds.length > 0) {
-        throw new Error(`Found multiple duplicate entity IDs: ${duplicateEntityIds
-            .map((ents) => `${ents[0].id} (${ents.map((e) => e.path.join('.')).join(',')})`)
-            .join(', ')}`);
+    const value = source[prop];
+    if (state.finalized_ || !isDraftable(value)) {
+      return value;
     }
-    const uniqueEntityIds = uniq(entities.map((e) => e.id));
-    if (uniqueEntityIds.length !== entities.length) {
-        throw new Error(`Found duplicate entity IDs`);
+    if (value === peek(state.base_, prop)) {
+      prepareCopy(state);
+      return state.copy_[prop] = createProxy(value, state);
     }
-    // collect reference entity types
-    const entityTypes = uniq(entities.map((e) => e.type));
-    const entityTypeNames = uniq(entityTypes.map((t) => t.name));
-    if (entityTypeNames.length !== entityTypes.length) {
-        throw new Error(`Found more entity types than entity type names implying duplicate entity type name`);
+    return value;
+  },
+  has(state, prop) {
+    return prop in latest(state);
+  },
+  ownKeys(state) {
+    return Reflect.ownKeys(latest(state));
+  },
+  set(state, prop, value) {
+    const desc = getDescriptorFromProto(latest(state), prop);
+    if (desc?.set) {
+      desc.set.call(state.draft_, value);
+      return true;
     }
-    const entityTypeOrder = toposort(entityTypeNames, entityTypes
-        .filter((entityType) => !!entityType.parentType)
-        .map((entityType) => [
-        entityType.parentType?.name ?? '',
-        entityType.name,
-    ]));
-    const entitiesByType = groupBy(entities, (e) => e.type.name);
-    const referencesByType = groupBy(references, (r) => r.type.name);
-    for (const name of entityTypeOrder) {
-        const entities = entitiesByType[name] ?? [];
-        const references = referencesByType[name] ?? [];
-        // resolve references to their ID
-        const entitiesByParentIdName = keyBy(entities, (e) => {
-            const { parentPath } = e;
-            const parentId = parentPath
-                ? get(data, parentPath)
-                : undefined;
-            if (parentPath && typeof parentId !== 'string') {
-                throw new Error(`Could not resolve parent path: ${parentPath.join('.')}`);
-            }
-            return referenceToNameParentId(e.name, parentId);
-        });
-        for (const ref of references) {
-            const name = get(data, ref.path);
-            // parent ID should have already been resolved due to order of resolving references
-            const parentId = ref.parentPath && get(data, ref.parentPath);
-            const parentIdName = referenceToNameParentId(name, parentId);
-            const resolvedEntity = entitiesByParentIdName[parentIdName];
-            if (!resolvedEntity) {
-                throw new Error(`Unable to resolve reference: ${ref.path.join('.')} (${ref.type.name} ${parentIdName})`);
-            }
-            set$1(data, ref.path, resolvedEntity.id);
-        }
+    if (!state.modified_) {
+      const current2 = peek(latest(state), prop);
+      const currentState = current2?.[DRAFT_STATE];
+      if (currentState && currentState.base_ === value) {
+        state.copy_[prop] = value;
+        state.assigned_[prop] = false;
+        return true;
+      }
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
+        return true;
+      prepareCopy(state);
+      markChanged(state);
     }
-    return payload;
+    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
+    (value !== void 0 || prop in state.copy_) || // special case: NaN
+    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
+      return true;
+    state.copy_[prop] = value;
+    state.assigned_[prop] = true;
+    return true;
+  },
+  deleteProperty(state, prop) {
+    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+      state.assigned_[prop] = false;
+      prepareCopy(state);
+      markChanged(state);
+    } else {
+      delete state.assigned_[prop];
+    }
+    if (state.copy_) {
+      delete state.copy_[prop];
+    }
+    return true;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(state, prop) {
+    const owner = latest(state);
+    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+    if (!desc)
+      return desc;
+    return {
+      writable: true,
+      configurable: state.type_ !== 1 || prop !== "length",
+      enumerable: desc.enumerable,
+      value: owner[prop]
+    };
+  },
+  defineProperty() {
+    die(11);
+  },
+  getPrototypeOf(state) {
+    return getPrototypeOf(state.base_);
+  },
+  setPrototypeOf() {
+    die(12);
+  }
+};
+var arrayTraps = {};
+each(objectTraps, (key, fn) => {
+  arrayTraps[key] = function() {
+    arguments[0] = arguments[0][0];
+    return fn.apply(this, arguments);
+  };
+});
+arrayTraps.deleteProperty = function(state, prop) {
+  return arrayTraps.set.call(this, state, prop, void 0);
+};
+arrayTraps.set = function(state, prop, value) {
+  return objectTraps.set.call(this, state[0], prop, value, state[0]);
+};
+function peek(draft, prop) {
+  const state = draft[DRAFT_STATE];
+  const source = state ? latest(state) : draft;
+  return source[prop];
 }
-
-// sentinel ID to signify the reference has been flagged for deletion
-const DELETED_SENTINEL_ID = 'deleted-sentinel-id';
-/**
- * Fixes any reference deletions by performing the appropriate action for the reference
- */
-function fixRefDeletions(schemaCreator, value, schemaCreatorOptions) {
-    const issues = [];
-    // find all references that do not have a corresponding entity
-    let iterations;
-    let valueToEdit = value;
-    for (iterations = 0; iterations < 100; iterations++) {
-        const parseResult = parseSchemaWithTransformedReferences(schemaCreator, valueToEdit, schemaCreatorOptions, {
-            allowInvalidReferences: true,
-        });
-        const { references, entities } = parseResult;
-        valueToEdit = parseResult.data;
-        const entitiesById = new Map(entities.map((e) => [e.id, e]));
-        const referencesMissingEntity = references.filter((r) => {
-            const id = get(valueToEdit, r.path);
-            return id !== DELETED_SENTINEL_ID && !entitiesById.has(id);
-        });
-        if (referencesMissingEntity.length === 0) {
-            if (issues.length > 0) {
-                return {
-                    type: 'failure',
-                    issues,
-                };
-            }
-            return {
-                type: 'success',
-                value: valueToEdit,
-                refPayload: parseResult,
-            };
-        }
-        const objectsToDeleteInArray = [];
-        function tryDeleteParent(path) {
-            if (path.length === 0) {
-                return false;
-            }
-            const parentPath = path.slice(0, -1);
-            const parent = get(valueToEdit, parentPath);
-            if (!Array.isArray(parent)) {
-                return false;
-            }
-            objectsToDeleteInArray.push({
-                path: parentPath,
-                idx: path.at(-1),
-            });
-            return true;
-        }
-        // attempt to fix reference
-        for (const ref of referencesMissingEntity) {
-            const id = get(valueToEdit, ref.path);
-            switch (ref.onDelete) {
-                case 'SET_UNDEFINED': {
-                    // Check if reference is inside an array
-                    if (ref.path.length > 0) {
-                        const parentPath = ref.path.slice(0, -1);
-                        const parent = get(valueToEdit, parentPath);
-                        if (Array.isArray(parent)) {
-                            throw new TypeError(`SET_UNDEFINED cannot be used for references inside arrays at path ${ref.path.join('.')}. Use DELETE instead to remove the array element.`);
-                        }
-                    }
-                    set$1(valueToEdit, ref.path, undefined);
-                    break;
-                }
-                case 'RESTRICT': {
-                    issues.push({ ref, entityId: id });
-                    set$1(valueToEdit, ref.path, DELETED_SENTINEL_ID);
-                    break;
-                }
-                case 'DELETE': {
-                    if (!tryDeleteParent(ref.path)) {
-                        throw new Error(`Unable to find ref to cascade delete to`);
-                    }
-                    break;
-                }
-                case 'DELETE_PARENT': {
-                    if (!tryDeleteParent(ref.path.slice(0, -1))) {
-                        throw new Error(`Unable to find ref to cascade delete to`);
-                    }
-                    break;
-                }
-                default: {
-                    throw new Error(`Unknown onDelete action ${ref.onDelete}`);
-                }
-            }
+function readPropFromProto(state, source, prop) {
+  const desc = getDescriptorFromProto(source, prop);
+  return desc ? `value` in desc ? desc.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    desc.get?.call(state.draft_)
+  ) : void 0;
+}
+function getDescriptorFromProto(source, prop) {
+  if (!(prop in source))
+    return void 0;
+  let proto = getPrototypeOf(source);
+  while (proto) {
+    const desc = Object.getOwnPropertyDescriptor(proto, prop);
+    if (desc)
+      return desc;
+    proto = getPrototypeOf(proto);
+  }
+  return void 0;
+}
+function markChanged(state) {
+  if (!state.modified_) {
+    state.modified_ = true;
+    if (state.parent_) {
+      markChanged(state.parent_);
+    }
+  }
+}
+function prepareCopy(state) {
+  if (!state.copy_) {
+    state.copy_ = shallowCopy(
+      state.base_,
+      state.scope_.immer_.useStrictShallowCopy_
+    );
+  }
+}
+var Immer2 = class {
+  constructor(config) {
+    this.autoFreeze_ = true;
+    this.useStrictShallowCopy_ = false;
+    this.produce = (base, recipe, patchListener) => {
+      if (typeof base === "function" && typeof recipe !== "function") {
+        const defaultBase = recipe;
+        recipe = base;
+        const self = this;
+        return function curriedProduce(base2 = defaultBase, ...args) {
+          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+        };
+      }
+      if (typeof recipe !== "function")
+        die(6);
+      if (patchListener !== void 0 && typeof patchListener !== "function")
+        die(7);
+      let result;
+      if (isDraftable(base)) {
+        const scope = enterScope(this);
+        const proxy = createProxy(base, void 0);
+        let hasError = true;
+        try {
+          result = recipe(proxy);
+          hasError = false;
+        } finally {
+          if (hasError)
+            revokeScope(scope);
+          else
+            leaveScope(scope);
         }
-        const objectsToDeleteByPath = groupBy(objectsToDeleteInArray, (o) => o.path.join('.'));
-        // delete objects in reverse order to avoid index shifting
-        for (const [, objects] of Object.entries(objectsToDeleteByPath)) {
-            const sortedObjects = sortBy(objects, [(o) => -o.idx]);
-            for (const o of sortedObjects) {
-                const parent = get(valueToEdit, o.path);
-                if (!Array.isArray(parent)) {
-                    throw new TypeError(`Expected parent to be an array at path ${o.path.join('.')}`);
-                }
-                parent.splice(o.idx, 1);
-            }
+        usePatchesInScope(scope, patchListener);
+        return processResult(result, scope);
+      } else if (!base || typeof base !== "object") {
+        result = recipe(base);
+        if (result === void 0)
+          result = base;
+        if (result === NOTHING)
+          result = void 0;
+        if (this.autoFreeze_)
+          freeze(result, true);
+        if (patchListener) {
+          const p = [];
+          const ip = [];
+          getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
+          patchListener(p, ip);
         }
+        return result;
+      } else
+        die(1, base);
+    };
+    this.produceWithPatches = (base, recipe) => {
+      if (typeof base === "function") {
+        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+      }
+      let patches, inversePatches;
+      const result = this.produce(base, recipe, (p, ip) => {
+        patches = p;
+        inversePatches = ip;
+      });
+      return [result, patches, inversePatches];
+    };
+    if (typeof config?.autoFreeze === "boolean")
+      this.setAutoFreeze(config.autoFreeze);
+    if (typeof config?.useStrictShallowCopy === "boolean")
+      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+  }
+  createDraft(base) {
+    if (!isDraftable(base))
+      die(8);
+    if (isDraft(base))
+      base = current(base);
+    const scope = enterScope(this);
+    const proxy = createProxy(base, void 0);
+    proxy[DRAFT_STATE].isManual_ = true;
+    leaveScope(scope);
+    return proxy;
+  }
+  finishDraft(draft, patchListener) {
+    const state = draft && draft[DRAFT_STATE];
+    if (!state || !state.isManual_)
+      die(9);
+    const { scope_: scope } = state;
+    usePatchesInScope(scope, patchListener);
+    return processResult(void 0, scope);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(value) {
+    this.autoFreeze_ = value;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(value) {
+    this.useStrictShallowCopy_ = value;
+  }
+  applyPatches(base, patches) {
+    let i;
+    for (i = patches.length - 1; i >= 0; i--) {
+      const patch = patches[i];
+      if (patch.path.length === 0 && patch.op === "replace") {
+        base = patch.value;
+        break;
+      }
     }
-    throw new Error(`Exceeded max iterations fixing deletions`);
+    if (i > -1) {
+      patches = patches.slice(i + 1);
+    }
+    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+    if (isDraft(base)) {
+      return applyPatchesImpl(base, patches);
+    }
+    return this.produce(
+      base,
+      (draft) => applyPatchesImpl(draft, patches)
+    );
+  }
+};
+function createProxy(value, parent) {
+  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+  const scope = parent ? parent.scope_ : getCurrentScope();
+  scope.drafts_.push(draft);
+  return draft;
+}
+function current(value) {
+  if (!isDraft(value))
+    die(10, value);
+  return currentImpl(value);
 }
+function currentImpl(value) {
+  if (!isDraftable(value) || isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  let copy;
+  if (state) {
+    if (!state.modified_)
+      return state.base_;
+    state.finalized_ = true;
+    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+  } else {
+    copy = shallowCopy(value, true);
+  }
+  each(copy, (key, childValue) => {
+    set(copy, key, currentImpl(childValue));
+  });
+  if (state) {
+    state.finalized_ = false;
+  }
+  return copy;
+}
+var immer = new Immer2();
+var produce = immer.produce;
+immer.produceWithPatches.bind(
+  immer
+);
+immer.setAutoFreeze.bind(immer);
+immer.setUseStrictShallowCopy.bind(immer);
+immer.applyPatches.bind(immer);
+immer.createDraft.bind(immer);
+immer.finishDraft.bind(immer);
 
 function serializeSchemaFromRefPayload(payload) {
     const { references, entities, data } = payload;
@@ -2381,103 +1922,103 @@ const SCALAR_FIELD_TYPES = [
     'enum',
 ];
 
-const {z: z$r} = await importShared('zod');
+const {z: z$t} = await importShared('zod');
 
 const VALIDATORS = {
-    PASCAL_CASE_STRING: z$r
+    PASCAL_CASE_STRING: z$t
         .string()
         .regex(/^[A-Z][a-zA-Z0-9]*$/, "Should be PascalCase, e.g. 'MyModel'"),
-    CAMEL_CASE_STRING: z$r
+    CAMEL_CASE_STRING: z$t
         .string()
         .regex(/^[a-z][a-zA-Z0-9]*$/, "Should be camelCase, e.g. 'myField'"),
-    CONSTANT_CASE_STRING: z$r
+    CONSTANT_CASE_STRING: z$t
         .string()
         .regex(/^[A-Z][A-Z0-9_]*$/, "Should be CONSTANT_CASE, e.g. 'MY_CONSTANT'"),
-    OPTIONAL_CONSTANT_CASE_STRING: z$r
+    OPTIONAL_CONSTANT_CASE_STRING: z$t
         .string()
         .regex(/^[A-Z][A-Z0-9_]*$/, "Should be CONSTANT_CASE, e.g. 'MY_CONSTANT'")
-        .or(z$r.literal(''))
+        .or(z$t.literal(''))
         .optional(),
 };
 
-const {z: z$q} = await importShared('zod');
-const createRoleArray = definitionSchema((ctx) => ctx.withDefault(z$q.array(ctx.withRef({
+const {z: z$s} = await importShared('zod');
+const createRoleArray = definitionSchema((ctx) => ctx.withDefault(z$s.array(ctx.withRef({
     type: authRoleEntityType,
     onDelete: 'DELETE',
 })), []));
 const createModelGraphqlSchema = definitionSchemaWithSlots({
     modelSlot: modelEntityType,
-}, (ctx, { modelSlot }) => z$q.object({
-    objectType: ctx.withDefault(z$q.object({
-        enabled: ctx.withDefault(z$q.boolean(), false),
-        fields: ctx.withDefault(z$q.array(ctx.withRef({
+}, (ctx, { modelSlot }) => z$s.object({
+    objectType: ctx.withDefault(z$s.object({
+        enabled: ctx.withDefault(z$s.boolean(), false),
+        fields: ctx.withDefault(z$s.array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         })), []),
-        localRelations: ctx.withDefault(z$q.array(ctx.withRef({
+        localRelations: ctx.withDefault(z$s.array(ctx.withRef({
             type: modelLocalRelationEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         })), []),
-        foreignRelations: ctx.withDefault(z$q.array(ctx.withRef({
+        foreignRelations: ctx.withDefault(z$s.array(ctx.withRef({
             type: modelForeignRelationEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         })), []),
     }), {}),
-    queries: ctx.withDefault(z$q.object({
-        get: ctx.withDefault(z$q.object({
-            enabled: ctx.withDefault(z$q.boolean(), false),
+    queries: ctx.withDefault(z$s.object({
+        get: ctx.withDefault(z$s.object({
+            enabled: ctx.withDefault(z$s.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        list: ctx.withDefault(z$q.object({
-            enabled: ctx.withDefault(z$q.boolean(), false),
+        list: ctx.withDefault(z$s.object({
+            enabled: ctx.withDefault(z$s.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
     }), {}),
-    mutations: ctx.withDefault(z$q.object({
-        create: ctx.withDefault(z$q.object({
-            enabled: ctx.withDefault(z$q.boolean(), false),
+    mutations: ctx.withDefault(z$s.object({
+        create: ctx.withDefault(z$s.object({
+            enabled: ctx.withDefault(z$s.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        update: ctx.withDefault(z$q.object({
-            enabled: ctx.withDefault(z$q.boolean(), false),
+        update: ctx.withDefault(z$s.object({
+            enabled: ctx.withDefault(z$s.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        delete: ctx.withDefault(z$q.object({
-            enabled: ctx.withDefault(z$q.boolean(), false),
+        delete: ctx.withDefault(z$s.object({
+            enabled: ctx.withDefault(z$s.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
     }), {}),
 }));
 
-const {z: z$p} = await importShared('zod');
+const {z: z$r} = await importShared('zod');
 
 const baseTransformerFields = {
-    id: z$p.string(),
-    type: z$p.string().min(1),
+    id: z$r.string(),
+    type: z$r.string().min(1),
 };
-const baseTransformerSchema = z$p.looseObject(baseTransformerFields);
+const baseTransformerSchema = z$r.looseObject(baseTransformerFields);
 function createModelTransformerType(payload) {
     return payload;
 }
 
-const {z: z$o} = await importShared('zod');
-const createEmbeddedRelationTransformerSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.refContext({ embeddedModelSlot: modelEntityType }, ({ embeddedModelSlot }) => ctx.withEnt(z$o.object({
+const {z: z$q} = await importShared('zod');
+const createEmbeddedRelationTransformerSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.refContext({ embeddedModelSlot: modelEntityType }, ({ embeddedModelSlot }) => ctx.withEnt(z$q.object({
     ...baseTransformerFields,
     foreignRelationRef: ctx.withRef({
         type: modelForeignRelationEntityType,
         onDelete: 'DELETE_PARENT',
         parentSlot: modelSlot,
     }),
-    type: z$o.literal('embeddedRelation'),
-    embeddedFieldNames: z$o.array(ctx.withRef({
+    type: z$q.literal('embeddedRelation'),
+    embeddedFieldNames: z$q.array(ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentSlot: embeddedModelSlot,
     })),
-    embeddedTransformerNames: z$o
+    embeddedTransformerNames: z$q
         .array(ctx.withRef({
         type: modelTransformerEntityType,
         onDelete: 'RESTRICT',
@@ -2505,86 +2046,59 @@ const BUILT_IN_TRANSFORMERS = [
     }),
 ];
 
-function createModelTransformerImplementation() {
-    const transformers = {};
-    for (const transformer of BUILT_IN_TRANSFORMERS) {
-        transformers[transformer.name] =
-            transformer;
-    }
-    return {
-        registerModelTransformer(transformer) {
-            if (transformer.name in transformers) {
-                throw new Error(`Model transformer with name ${transformer.name} is already registered`);
-            }
-            transformers[transformer.name] =
-                transformer;
-        },
-        getModelTransformers() {
-            return transformers;
-        },
-        getModelTransformer(name) {
-            if (!(name in transformers)) {
-                throw new Error(`Unable to find transformer with name ${name}`);
-            }
-            return transformers[name];
-        },
-    };
-}
 /**
- * Spec for adding config component for plugin
+ * Spec for registering additional model transformer types
  */
-const modelTransformerSpec = createPluginSpec('core/model-transformer', {
-    defaultInitializer: createModelTransformerImplementation,
-});
+const modelTransformerSpec = createFieldMapSpec('core/model-transformer', (t) => ({
+    transformers: t.namedArrayToMap(BUILT_IN_TRANSFORMERS),
+}));
 
-const z$n = await importShared('zod');
+const z$p = await importShared('zod');
 const createTransformerSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => {
-    const transformers = ctx.plugins
-        .getPluginSpec(modelTransformerSpec)
-        .getModelTransformers();
-    return z$n.discriminatedUnion('type', Object.values(transformers).map((transformer) => transformer.createSchema(ctx, slots)));
+    const { transformers } = ctx.plugins.use(modelTransformerSpec);
+    return z$p.discriminatedUnion('type', [...transformers.values()].map((transformer) => transformer.createSchema(ctx, slots)));
 });
 
-const {z: z$m} = await importShared('zod');
-const createEnumValueSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => ctx.withEnt(z$m.object({
-    id: z$m.string(),
-    name: z$m.string().min(1),
-    friendlyName: z$m.string().min(1),
+const {z: z$o} = await importShared('zod');
+const createEnumValueSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => ctx.withEnt(z$o.object({
+    id: z$o.string(),
+    name: z$o.string().min(1),
+    friendlyName: z$o.string().min(1),
 }), {
     type: modelEnumValueEntityType,
     parentSlot: enumSlot,
 }));
-const createEnumBaseSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => z$m.object({
-    id: z$m.string(),
-    name: z$m.string().min(1),
+const createEnumBaseSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => z$o.object({
+    id: z$o.string(),
+    name: z$o.string().min(1),
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    values: z$m.array(createEnumValueSchema(ctx, { enumSlot })),
-    isExposed: z$m.boolean(),
+    values: z$o.array(createEnumValueSchema(ctx, { enumSlot })),
+    isExposed: z$o.boolean(),
 }));
 const createEnumSchema = definitionSchema((ctx) => ctx.refContext({ enumSlot: modelEnumEntityType }, ({ enumSlot }) => ctx.withEnt(createEnumBaseSchema(ctx, { enumSlot }), {
     type: modelEnumEntityType,
     provides: enumSlot,
 })));
 
-const {z: z$l} = await importShared('zod');
+const {z: z$n} = await importShared('zod');
 const createModelScalarFieldSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx
-    .withEnt(z$l.object({
-    id: z$l.string(),
+    .withEnt(z$n.object({
+    id: z$n.string(),
     name: VALIDATORS.CAMEL_CASE_STRING,
-    type: z$l.enum(SCALAR_FIELD_TYPES),
-    isOptional: z$l.boolean().default(false),
-    options: ctx.refContext({ enumSlot: modelEnumEntityType }, ({ enumSlot }) => z$l
+    type: z$n.enum(SCALAR_FIELD_TYPES),
+    isOptional: z$n.boolean().default(false),
+    options: ctx.refContext({ enumSlot: modelEnumEntityType }, ({ enumSlot }) => z$n
         .object({
         // string options
-        default: z$l.string().default(''),
+        default: z$n.string().default(''),
         // uuid options
-        genUuid: z$l.boolean().optional(),
+        genUuid: z$n.boolean().optional(),
         // date options
-        updatedAt: z$l.boolean().optional(),
-        defaultToNow: z$l.boolean().optional(),
+        updatedAt: z$n.boolean().optional(),
+        defaultToNow: z$n.boolean().optional(),
         // enum options
         enumRef: ctx
             .withRef({
@@ -2644,13 +2158,13 @@ const REFERENTIAL_ACTIONS = [
     'SetNull',
     'SetDefault',
 ];
-const createModelRelationFieldSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.refContext({ foreignModelSlot: modelEntityType }, ({ foreignModelSlot }) => ctx.withEnt(ctx.withEnt(z$l.object({
-    id: z$l.string(),
-    foreignId: z$l
+const createModelRelationFieldSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.refContext({ foreignModelSlot: modelEntityType }, ({ foreignModelSlot }) => ctx.withEnt(ctx.withEnt(z$n.object({
+    id: z$n.string(),
+    foreignId: z$n
         .string()
         .default(() => modelForeignRelationEntityType.generateNewId()),
     name: VALIDATORS.CAMEL_CASE_STRING,
-    references: z$l.array(z$l.object({
+    references: z$n.array(z$n.object({
         localRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
@@ -2668,8 +2182,8 @@ const createModelRelationFieldSchema = definitionSchemaWithSlots({ modelSlot: mo
         provides: foreignModelSlot,
     }),
     foreignRelationName: VALIDATORS.CAMEL_CASE_STRING,
-    onDelete: z$l.enum(REFERENTIAL_ACTIONS).default('Cascade'),
-    onUpdate: z$l.enum(REFERENTIAL_ACTIONS).default('Restrict'),
+    onDelete: z$n.enum(REFERENTIAL_ACTIONS).default('Cascade'),
+    onUpdate: z$n.enum(REFERENTIAL_ACTIONS).default('Restrict'),
 }), {
     type: modelLocalRelationEntityType,
     parentSlot: modelSlot,
@@ -2679,9 +2193,9 @@ const createModelRelationFieldSchema = definitionSchemaWithSlots({ modelSlot: mo
     getNameResolver: (entity) => entity.foreignRelationName,
     parentSlot: foreignModelSlot,
 })));
-const createModelUniqueConstraintSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.withEnt(z$l.object({
-    id: z$l.string(),
-    fields: z$l.array(z$l.object({
+const createModelUniqueConstraintSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.withEnt(z$n.object({
+    id: z$n.string(),
+    fields: z$n.array(z$n.object({
         fieldRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
@@ -2698,18 +2212,18 @@ const createModelUniqueConstraintSchema = definitionSchemaWithSlots({ modelSlot:
         });
     },
 }));
-const createModelServiceSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => z$l.object({
-    create: z$l
+const createModelServiceSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => z$n.object({
+    create: z$n
         .object({
-        enabled: z$l.boolean().default(false),
-        fields: z$l
+        enabled: z$n.boolean().default(false),
+        fields: z$n
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         }))
             .optional(),
-        transformerNames: z$l
+        transformerNames: z$n
             .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
@@ -2718,17 +2232,17 @@ const createModelServiceSchema = definitionSchemaWithSlots({ modelSlot: modelEnt
             .optional(),
     })
         .default({ enabled: false }),
-    update: z$l
+    update: z$n
         .object({
-        enabled: z$l.boolean().default(false),
-        fields: z$l
+        enabled: z$n.boolean().default(false),
+        fields: z$n
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         }))
             .optional(),
-        transformerNames: z$l
+        transformerNames: z$n
             .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
@@ -2737,37 +2251,37 @@ const createModelServiceSchema = definitionSchemaWithSlots({ modelSlot: modelEnt
             .optional(),
     })
         .default({ enabled: false }),
-    delete: z$l
+    delete: z$n
         .object({
-        enabled: z$l.boolean().default(false),
+        enabled: z$n.boolean().default(false),
     })
         .default({
         enabled: false,
     }),
-    transformers: z$l
+    transformers: z$n
         .array(createTransformerSchema(ctx, { modelSlot }))
         .default([]),
 }));
-const createModelBaseSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => z$l.object({
-    id: z$l.string(),
+const createModelBaseSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => z$n.object({
+    id: z$n.string(),
     name: VALIDATORS.PASCAL_CASE_STRING,
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    model: z$l.object({
-        fields: z$l.array(createModelScalarFieldSchema(ctx, slots)),
-        relations: z$l
+    model: z$n.object({
+        fields: z$n.array(createModelScalarFieldSchema(ctx, slots)),
+        relations: z$n
             .array(createModelRelationFieldSchema(ctx, slots))
             .optional(),
-        primaryKeyFieldRefs: z$l
+        primaryKeyFieldRefs: z$n
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
             parentSlot: slots.modelSlot,
         }))
             .min(1),
-        uniqueConstraints: z$l
+        uniqueConstraints: z$n
             .array(createModelUniqueConstraintSchema(ctx, slots))
             .optional(),
     }),
@@ -2791,26 +2305,26 @@ const adminCrudSectionColumnEntityType = createEntityType('admin-crud-section-co
     parentType: adminSectionEntityType,
 });
 
-const {z: z$k} = await importShared('zod');
-const createBaseAdminSectionValidators = definitionSchema((ctx) => z$k.object({
-    id: z$k.string().default(adminSectionEntityType.generateNewId()),
-    name: z$k.string().min(1),
+const {z: z$m} = await importShared('zod');
+const createBaseAdminSectionValidators = definitionSchema((ctx) => z$m.object({
+    id: z$m.string().default(adminSectionEntityType.generateNewId()),
+    name: z$m.string().min(1),
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    icon: z$k.string().optional(),
-    type: z$k.string().min(1),
+    icon: z$m.string().optional(),
+    type: z$m.string().min(1),
 }));
 
-const {z: z$j} = await importShared('zod');
-const baseAdminCrudActionSchema = z$j.looseObject({
-    id: z$j
+const {z: z$l} = await importShared('zod');
+const baseAdminCrudActionSchema = z$l.looseObject({
+    id: z$l
         .string()
         .min(1)
         .default(() => adminCrudActionEntityType.generateNewId()),
-    type: z$j.string().min(1),
-    position: z$j.enum(['inline', 'dropdown']).default('dropdown'),
+    type: z$l.string().min(1),
+    position: z$l.enum(['inline', 'dropdown']).default('dropdown'),
 });
 function createAdminCrudActionType(payload) {
     return payload;
@@ -2819,16 +2333,16 @@ const adminCrudActionEntityType = createEntityType('admin-crud-action', {
     parentType: adminSectionEntityType,
 });
 
-const {z: z$i} = await importShared('zod');
+const {z: z$k} = await importShared('zod');
 const createAdminCrudEditActionSchema = definitionSchema(() => baseAdminCrudActionSchema.extend({
-    type: z$i.literal('edit'),
+    type: z$k.literal('edit'),
 }));
 const adminCrudEditActionType = createAdminCrudActionType({
     name: 'edit',
     createSchema: createAdminCrudEditActionSchema,
 });
 const createAdminCrudDeleteActionSchema = definitionSchema(() => baseAdminCrudActionSchema.extend({
-    type: z$i.literal('delete'),
+    type: z$k.literal('delete'),
 }));
 const adminCrudDeleteActionType = createAdminCrudActionType({
     name: 'delete',
@@ -2839,38 +2353,15 @@ const BUILT_IN_ADMIN_CRUD_ACTIONS = [
     adminCrudDeleteActionType,
 ];
 
-function createAdminCrudActionImplementation() {
-    const adminCrudActions = new Map(BUILT_IN_ADMIN_CRUD_ACTIONS.map((action) => [action.name, action]));
-    return {
-        registerAdminCrudAction(action) {
-            if (adminCrudActions.has(action.name)) {
-                throw new Error(`Admin CRUD action with name ${action.name} is already registered`);
-            }
-            adminCrudActions.set(action.name, action);
-        },
-        getAdminCrudActions() {
-            return adminCrudActions;
-        },
-        getAdminCrudAction(name) {
-            const action = adminCrudActions.get(name);
-            if (!action) {
-                throw new Error(`Unable to find action with name ${name}`);
-            }
-            return action;
-        },
-    };
-}
 /**
- * Spec for adding admin CRUD actions
+ * Spec for registering additional admin CRUD table actions
  */
-const adminCrudActionSpec = createPluginSpec('core/admin-crud-action', {
-    defaultInitializer: createAdminCrudActionImplementation,
-});
+const adminCrudActionSpec = createFieldMapSpec('core/admin-crud-action', (t) => ({
+    actions: t.namedArrayToMap(BUILT_IN_ADMIN_CRUD_ACTIONS),
+}));
 
 const createAdminCrudActionSchema = definitionSchema((ctx) => {
-    const adminCrudActions = ctx.plugins
-        .getPluginSpec(adminCrudActionSpec)
-        .getAdminCrudActions();
+    const adminCrudActions = ctx.plugins.use(adminCrudActionSpec).actions;
     return baseAdminCrudActionSchema.transform((data) => {
         const actionDef = adminCrudActions.get(data.type);
         if (!actionDef)
@@ -2879,14 +2370,14 @@ const createAdminCrudActionSchema = definitionSchema((ctx) => {
     });
 });
 
-const {z: z$h} = await importShared('zod');
-const baseAdminCrudColumnSchema = z$h.looseObject({
-    id: z$h
+const {z: z$j} = await importShared('zod');
+const baseAdminCrudColumnSchema = z$j.looseObject({
+    id: z$j
         .string()
         .min(1)
         .default(() => adminCrudColumnEntityType.generateNewId()),
-    type: z$h.string().min(1),
-    label: z$h.string().min(1),
+    type: z$j.string().min(1),
+    label: z$j.string().min(1),
 });
 function createAdminCrudColumnType(payload) {
     return payload;
@@ -2895,10 +2386,10 @@ const adminCrudColumnEntityType = createEntityType('admin-crud-column', {
     parentType: adminSectionEntityType,
 });
 
-const {z: z$g} = await importShared('zod');
+const {z: z$i} = await importShared('zod');
 // Text Column
 const createAdminCrudTextColumnSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => baseAdminCrudColumnSchema.extend({
-    type: z$g.literal('text'),
+    type: z$i.literal('text'),
     modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
@@ -2911,14 +2402,14 @@ const adminCrudTextColumnType = createAdminCrudColumnType({
 });
 // Foreign Column
 const createAdminCrudForeignColumnSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => baseAdminCrudColumnSchema.extend({
-    type: z$g.literal('foreign'),
+    type: z$i.literal('foreign'),
     localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
         parentSlot: modelSlot,
     }),
-    labelExpression: z$g.string().min(1),
-    valueExpression: z$g.string().min(1),
+    labelExpression: z$i.string().min(1),
+    valueExpression: z$i.string().min(1),
 }));
 const adminCrudForeignColumnType = createAdminCrudColumnType({
     name: 'foreign',
@@ -2928,39 +2419,16 @@ const BUILT_IN_ADMIN_CRUD_COLUMNS = [
     adminCrudTextColumnType,
     adminCrudForeignColumnType,
 ];
-
-function createAdminCrudColumnImplementation() {
-    const adminCrudColumns = new Map(BUILT_IN_ADMIN_CRUD_COLUMNS.map((column) => [column.name, column]));
-    return {
-        registerAdminCrudColumn(column) {
-            if (adminCrudColumns.has(column.name)) {
-                throw new Error(`Admin CRUD column with name ${column.name} is already registered`);
-            }
-            adminCrudColumns.set(column.name, column);
-        },
-        getAdminCrudColumns() {
-            return adminCrudColumns;
-        },
-        getAdminCrudColumn(name) {
-            const column = adminCrudColumns.get(name);
-            if (!column) {
-                throw new Error(`Unable to find column with name ${name}`);
-            }
-            return column;
-        },
-    };
-}
+
 /**
- * Spec for adding admin CRUD columns
+ * Spec for registering additional admin CRUD table columns
  */
-const adminCrudColumnSpec = createPluginSpec('core/admin-crud-column', {
-    defaultInitializer: createAdminCrudColumnImplementation,
-});
+const adminCrudColumnSpec = createFieldMapSpec('core/admin-crud-column', (t) => ({
+    columns: t.namedArrayToMap(BUILT_IN_ADMIN_CRUD_COLUMNS),
+}));
 
 const createAdminCrudColumnSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => {
-    const adminCrudColumns = ctx.plugins
-        .getPluginSpec(adminCrudColumnSpec)
-        .getAdminCrudColumns();
+    const adminCrudColumns = ctx.plugins.use(adminCrudColumnSpec).columns;
     return baseAdminCrudColumnSchema.transform((data) => {
         const columnDef = adminCrudColumns.get(data.type);
         if (!columnDef)
@@ -2969,14 +2437,14 @@ const createAdminCrudColumnSchema = definitionSchemaWithSlots({ modelSlot: model
     });
 });
 
-const {z: z$f} = await importShared('zod');
-const baseAdminCrudInputSchema = z$f.looseObject({
-    id: z$f
+const {z: z$h} = await importShared('zod');
+const baseAdminCrudInputSchema = z$h.looseObject({
+    id: z$h
         .string()
         .min(1)
         .default(() => adminCrudInputEntityType.generateNewId()),
-    type: z$f.string().min(1),
-    label: z$f.string().min(1),
+    type: z$h.string().min(1),
+    label: z$h.string().min(1),
 });
 function createAdminCrudInputType(payload) {
     return payload;
@@ -2988,41 +2456,41 @@ const adminCrudInputEntityType = createEntityType('admin-crud-input', {
     parentType: adminSectionEntityType,
 });
 
-const {z: z$e} = await importShared('zod');
+const {z: z$g} = await importShared('zod');
 const createAdminCrudTextInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$e.literal('text'),
-    label: z$e.string().min(1),
+    type: z$g.literal('text'),
+    label: z$g.string().min(1),
     modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentSlot: modelSlot,
     }),
-    validation: z$e.string().optional(),
+    validation: z$g.string().optional(),
 }));
 const adminCrudTextInputType = createAdminCrudInputType({
     name: 'text',
     createSchema: createAdminCrudTextInputSchema,
 });
 const createAdminCrudForeignInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$e.literal('foreign'),
-    label: z$e.string().min(1),
+    type: z$g.literal('foreign'),
+    label: z$g.string().min(1),
     localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
         parentSlot: modelSlot,
     }),
-    labelExpression: z$e.string().min(1),
-    valueExpression: z$e.string().min(1),
-    defaultLabel: z$e.string().optional(),
-    nullLabel: z$e.string().optional(),
+    labelExpression: z$g.string().min(1),
+    valueExpression: z$g.string().min(1),
+    defaultLabel: z$g.string().optional(),
+    nullLabel: z$g.string().optional(),
 }));
 const adminCrudForeignInputType = createAdminCrudInputType({
     name: 'foreign',
     createSchema: createAdminCrudForeignInputSchema,
 });
 const createAdminCrudEnumInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$e.literal('enum'),
-    label: z$e.string().min(1),
+    type: z$g.literal('enum'),
+    label: z$g.string().min(1),
     modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
@@ -3034,8 +2502,8 @@ const adminCrudEnumInputType = createAdminCrudInputType({
     createSchema: createAdminCrudEnumInputSchema,
 });
 const createAdminCrudEmbeddedInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$e.literal('embedded'),
-    label: z$e.string().min(1),
+    type: z$g.literal('embedded'),
+    label: z$g.string().min(1),
     modelRelationRef: ctx.withRef({
         type: modelForeignRelationEntityType,
         onDelete: 'RESTRICT',
@@ -3052,8 +2520,8 @@ const adminCrudEmbeddedInputType = createAdminCrudInputType({
     createSchema: createAdminCrudEmbeddedInputSchema,
 });
 const createAdminCrudEmbeddedLocalInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$e.literal('embeddedLocal'),
-    label: z$e.string().min(1),
+    type: z$g.literal('embeddedLocal'),
+    label: z$g.string().min(1),
     localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
@@ -3070,200 +2538,520 @@ const adminCrudEmbeddedLocalInputType = createAdminCrudInputType({
     createSchema: createAdminCrudEmbeddedLocalInputSchema,
 });
 const createAdminCrudPasswordInputSchema = definitionSchema(() => baseAdminCrudInputSchema.extend({
-    type: z$e.literal('password'),
-    label: z$e.string().min(1),
+    type: z$g.literal('password'),
+    label: z$g.string().min(1),
 }));
 const adminCrudPasswordInputType = createAdminCrudInputType({
     name: 'password',
     createSchema: createAdminCrudPasswordInputSchema,
 });
-const BUILT_IN_ADMIN_CRUD_INPUTS = [
-    adminCrudTextInputType,
-    adminCrudForeignInputType,
-    adminCrudEnumInputType,
-    adminCrudEmbeddedInputType,
-    adminCrudEmbeddedLocalInputType,
-    adminCrudPasswordInputType,
-];
+const BUILT_IN_ADMIN_CRUD_INPUTS = [
+    adminCrudTextInputType,
+    adminCrudForeignInputType,
+    adminCrudEnumInputType,
+    adminCrudEmbeddedInputType,
+    adminCrudEmbeddedLocalInputType,
+    adminCrudPasswordInputType,
+];
+
+/**
+ * Spec for registering additional admin CRUD form inputs
+ */
+const adminCrudInputSpec = createFieldMapSpec('core/admin-crud-input', (t) => ({
+    inputs: t.namedArrayToMap(BUILT_IN_ADMIN_CRUD_INPUTS),
+}));
+
+const createAdminCrudInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, slots) => {
+    const adminCrudInputs = ctx.plugins.use(adminCrudInputSpec).inputs;
+    return baseAdminCrudInputSchema.transform((data) => {
+        const inputDef = adminCrudInputs.get(data.type);
+        if (!inputDef)
+            return data;
+        return inputDef.createSchema(ctx, slots).parse(data);
+    });
+});
+
+const {z: z$f} = await importShared('zod');
+// Embedded Crud
+const createAdminCrudEmbeddedObjectSchemaInternal = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => z$f.object({
+    id: z$f.string().min(1),
+    name: z$f.string().min(1),
+    modelRef: ctx.withRef({
+        type: modelEntityType,
+        onDelete: 'RESTRICT',
+        provides: modelSlot,
+    }),
+    includeIdField: z$f.boolean().optional(),
+    type: z$f.literal('object'),
+    form: z$f.object({
+        fields: z$f.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
+    }),
+}));
+const createAdminCrudEmbeddedListSchemaInternal = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => z$f.object({
+    id: z$f.string().min(1),
+    name: z$f.string().min(1),
+    modelRef: ctx.withRef({
+        type: modelEntityType,
+        onDelete: 'RESTRICT',
+        provides: modelSlot,
+    }),
+    includeIdField: z$f.boolean().optional(),
+    type: z$f.literal('list'),
+    table: z$f.object({
+        columns: z$f.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
+    }),
+    form: z$f.object({
+        fields: z$f.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
+    }),
+}));
+const createAdminCrudEmbeddedFormSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => ctx.withEnt(z$f.discriminatedUnion('type', [
+    createAdminCrudEmbeddedObjectSchemaInternal(ctx, {
+        modelSlot,
+        adminSectionSlot,
+    }),
+    createAdminCrudEmbeddedListSchemaInternal(ctx, {
+        modelSlot,
+        adminSectionSlot,
+    }),
+]), {
+    type: adminCrudEmbeddedFormEntityType,
+    parentSlot: adminSectionSlot,
+})));
+// Admin Section
+const createAdminCrudSectionSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => createBaseAdminSectionValidators(ctx).and(z$f.object({
+    type: z$f.literal('crud'),
+    modelRef: ctx.withRef({
+        type: modelEntityType,
+        onDelete: 'RESTRICT',
+        provides: modelSlot,
+    }),
+    /* The field that will be used to display the name of the entity in the form */
+    nameFieldRef: ctx.withRef({
+        type: modelScalarFieldEntityType,
+        onDelete: 'RESTRICT',
+        parentSlot: modelSlot,
+    }),
+    disableCreate: ctx.withDefault(z$f.boolean(), false),
+    table: z$f.object({
+        columns: z$f.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
+        actions: ctx.withDefault(z$f.array(createAdminCrudActionSchema(ctx)), [
+            { type: 'edit', position: 'inline' },
+            { type: 'delete', position: 'dropdown' },
+        ]),
+    }),
+    form: z$f.object({
+        fields: z$f.array(createAdminCrudInputSchema(ctx, {
+            modelSlot,
+            adminSectionSlot,
+        })),
+    }),
+    embeddedForms: z$f
+        .array(createAdminCrudEmbeddedFormSchema(ctx, { adminSectionSlot }))
+        .optional(),
+}))));
+
+const {z: z$e} = await importShared('zod');
+const createWebAdminSectionSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => ctx.refContext({ adminSectionSlot: adminSectionEntityType }, ({ adminSectionSlot }) => ctx.withEnt(createAdminCrudSectionSchema(ctx, { adminSectionSlot }), {
+    type: adminSectionEntityType,
+    parentSlot: appSlot,
+    provides: adminSectionSlot,
+})));
+const createAdminAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => ctx.withDefault(z$e.object({
+    enabled: z$e.boolean(),
+    pathPrefix: z$e.string().default('/admin'),
+    allowedRoles: ctx.withDefault(z$e.array(ctx.withRef({
+        type: authRoleEntityType,
+        onDelete: 'DELETE',
+    })), []),
+    sections: ctx.withDefault(z$e.array(createWebAdminSectionSchema(ctx, { appSlot })), []),
+}), { enabled: false, pathPrefix: '/admin' }));
+
+const {z: z$d} = await importShared('zod');
+const createWebAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => z$d.object({
+    ...baseAppValidators,
+    type: z$d.literal('web'),
+    includeAuth: ctx.withDefault(z$d.boolean(), false),
+    title: z$d.string().default(''),
+    description: z$d.string().default(''),
+    includeUploadComponents: ctx.withDefault(z$d.boolean(), false),
+    enableSubscriptions: ctx.withDefault(z$d.boolean(), false),
+    adminApp: createAdminAppSchema(ctx, { appSlot }),
+}));
+const webAppEntryType = createAppEntryType('web');
+
+const libraryEntityType = createEntityType('library');
+
+const {CASE_VALIDATORS: CASE_VALIDATORS$2} = await importShared('@baseplate-dev/utils');
+
+const {z: z$c} = await importShared('zod');
+const baseLibraryValidators = {
+    id: z$c.string().default(libraryEntityType.generateNewId()),
+    name: CASE_VALIDATORS$2.KEBAB_CASE,
+    type: z$c.string(),
+};
+const baseLibrarySchema = z$c.object(baseLibraryValidators);
+
+/**
+ * Strip object of any values that are empty arrays, empty objects, null, or undefined
+ */
+function stripEmptyGeneratorChildren(children) {
+    return pickBy(children, (value) => value !== undefined && !(Array.isArray(value) && value.length === 0));
+}
+/**
+ * Strip object of any values that are undefined
+ */
+function stripUndefinedValues(obj) {
+    return pickBy(obj, (value) => value !== undefined);
+}
+/**
+ * Returns undefined if the value is an empty object (as defined by all values are undefined)/array/null, otherwise return value.
+ */
+function undefinedIfEmpty(value) {
+    if (value === null)
+        return undefined;
+    if (Array.isArray(value) && value.length === 0) {
+        return undefined;
+    }
+    if (typeof value === 'object' &&
+        Object.keys(value).every((key) => value[key] === undefined)) {
+        return undefined;
+    }
+    return value;
+}
+/**
+ * Returns undefined if the value is falsy, otherwise return value.
+ */
+function undefinedIfFalsy(value) {
+    if (!value)
+        return undefined;
+    return value;
+}
+
+/**
+ * Store for managing plugin spec instances with lazy initialization.
+ *
+ * Each spec is initialized once on first access, and both its init and use
+ * interfaces are cached for subsequent access.
+ */
+class PluginSpecStore {
+    instances;
+    useInstances = new Map();
+    constructor(instances = new Map()) {
+        this.instances = instances;
+    }
+    /**
+     * Gets the use interface for a spec.
+     *
+     * Use this after initialization to access registered items.
+     * The use interface provides read-only methods for consumption.
+     *
+     * @param spec - The plugin spec to get the use interface for
+     * @returns The use interface for the spec
+     */
+    use(spec) {
+        let specInstance = this.instances.get(spec.name);
+        if (!specInstance) {
+            specInstance = spec.initializer();
+            this.instances.set(spec.name, specInstance);
+        }
+        let useInstance = this.useInstances.get(spec.name);
+        if (!useInstance) {
+            useInstance = specInstance.use();
+            this.useInstances.set(spec.name, useInstance);
+        }
+        return useInstance;
+    }
+}
+
+const {assertNoDuplicates} = await importShared('@baseplate-dev/utils');
+/**
+ * Initialize ordered plugin modules.
+ * Each module's initialize function is called within a plugin context.
+ */
+function initializeOrderedModules(orderedModules) {
+    const instances = new Map();
+    function use(spec) {
+        if (!instances.has(spec.name)) {
+            const instance = spec.initializer();
+            instances.set(spec.name, instance);
+        }
+        return instances.get(spec.name);
+    }
+    for (const { module, key: moduleKey, pluginKey } of orderedModules) {
+        // Resolve dependencies by getting their setup interfaces
+        const dependencies = module.dependencies
+            ? stripUndefinedValues(mapValues(module.dependencies, (spec) => use(spec).init))
+            : {};
+        // Run initialize within plugin context for source tracking
+        runInPluginContext({ moduleKey, pluginKey }, () => {
+            module.initialize(dependencies, { moduleKey, pluginKey });
+        });
+    }
+    return instances;
+}
+/**
+ * Initialize the plugins based on their interdependencies.
+ * Returns a store that can be used to access spec implementations.
+ */
+function initializePlugins(pluginModules) {
+    assertNoDuplicates(pluginModules, 'plugin modules', (m) => m.key);
+    const instances = initializeOrderedModules(pluginModules);
+    return new PluginSpecStore(instances);
+}
+
+/**
+ * Creates a plugin module export.
+ *
+ * @example
+ * ```typescript
+ * export default createPluginModule({
+ *   name: 'node',
+ *   dependencies: {
+ *     config: pluginConfigSpec,
+ *   },
+ *   initialize: ({ config }, ctx) => {
+ *     config.registerSchemaCreator(ctx.pluginKey, createSchema);
+ *   },
+ * });
+ * ```
+ */
+function createPluginModule(config) {
+    return config;
+}
+
+/**
+ * Gets a plugin metadata object by its key.
+ *
+ * @param pluginStore The plugin store to use
+ * @param key The key of the plugin to get
+ * @returns The plugin metadata object or undefined if the plugin is not found
+ */
+function getPluginMetadataByKey(pluginStore, key) {
+    return pluginStore.availablePlugins.find((p) => p.metadata.key === key)
+        ?.metadata;
+}
+/**
+ * Gets a plugin metadata object by its key.
+ *
+ * @param pluginStore The plugin store to use
+ * @param key The key of the plugin to get
+ * @returns The plugin metadata object
+ * @throws An error if the plugin is not found
+ */
+function getPluginMetadataByKeyOrThrow(pluginStore, key) {
+    const metadata = getPluginMetadataByKey(pluginStore, key);
+    if (!metadata) {
+        throw new Error(`Could not find plugin with key ${key}`);
+    }
+    return metadata;
+}
+function getManagedPluginsForPlugin(pluginStore, pluginKey) {
+    const plugin = getPluginMetadataByKeyOrThrow(pluginStore, pluginKey);
+    return pluginStore.availablePlugins
+        .filter((p) => p.metadata.managedBy === plugin.fullyQualifiedName)
+        .map((p) => p.metadata);
+}
+
+const {z: z$b} = await importShared('zod');
+
+// matches semver
+const versionSchema = z$b.string().regex(/^(\d+\.\d+\.\d+)$/);
+const pluginSpecSupportSchema = z$b.object({
+    spec: z$b.string().min(1),
+    version: z$b.string().min(1),
+});
+const pluginSpecDependencySchema = z$b.object({
+    spec: z$b.string(),
+    version: z$b.string(),
+});
+/**
+ * Schema for the plugin's metadata (plugin.json)
+ */
+const pluginMetadataSchema = z$b.object({
+    /**
+     * The name of the plugin - must be lowercase and contain only letters, numbers, and hyphens
+     */
+    name: z$b
+        .string()
+        .min(1)
+        .regex(/^[a-z0-9-]+$/),
+    /**
+     * A list of directories with entrypoints in them. Defaults to ['.']
+     */
+    moduleDirectories: z$b.array(z$b.string()).optional(),
+    /**
+     * The display name of the plugin
+     */
+    displayName: z$b.string().min(1),
+    /**
+     * The icon to display for the plugin as a pointer to the icon in the plugin's static folder
+     */
+    icon: z$b.string().optional(),
+    /**
+     * A description of the plugin
+     */
+    description: z$b.string(),
+    /**
+     * The fully qualified name of the plugin that manages this plugin,
+     * e.g. "@baseplate-dev/plugin-auth:auth0" would be managed by the "@baseplate-dev/plugin-auth:auth" plugin.
+     *
+     * Managed plugins do not appear in the plugin list but are managed by the base plugin. If the base
+     * plugin is disabled, the managed plugins will also be disabled.
+     */
+    managedBy: z$b.string().optional(),
+    /**
+     * The version of the plugin using semver
+     */
+    version: versionSchema,
+    /**
+     * Configuration for the specs that the plugin exports/depends on
+     */
+    specs: z$b
+        .object({
+        /**
+         * The specs that the plugin exports
+         */
+        exports: z$b.array(pluginSpecSupportSchema).optional(),
+        /**
+         * The specs that the plugin depends on
+         */
+        dependencies: z$b.array(pluginSpecDependencySchema).optional(),
+    })
+        .optional(),
+    /**
+     * Whether the plugin should be hidden in the project builder UI
+     *
+     * (It can be used once in the definition but cannot be added)
+     */
+    hidden: z$b.boolean().optional(),
+});
 
-function createAdminCrudInputImplementation() {
-    const adminCrudInputs = new Map(BUILT_IN_ADMIN_CRUD_INPUTS.map((input) => [input.name, input]));
-    return {
-        registerAdminCrudInput(input) {
-            if (adminCrudInputs.has(input.name)) {
-                throw new Error(`Admin CRUD input with name ${input.name} is already registered`);
-            }
-            adminCrudInputs.set(input.name, input);
-        },
-        getAdminCrudInputs() {
-            return adminCrudInputs;
-        },
-        getAdminCrudInput(name) {
-            const input = adminCrudInputs.get(name);
-            if (!input) {
-                throw new Error(`Unable to find input with name ${name}`);
-            }
-            return input;
-        },
-    };
+const pluginEntityType = createEntityType('plugin');
+
+const {mapValuesOfMap} = await importShared('@baseplate-dev/utils');
+function sortAndValidateMigrations(migrations, pluginKey) {
+    // make sure migrations are sorted by version and they are all unique
+    const sortedMigrations = [...migrations].sort((a, b) => a.version - b.version);
+    if (sortedMigrations.some((m) => m.version <= 0)) {
+        throw new Error(`All migrations for plugin ${pluginKey} must have a positive version`);
+    }
+    for (let i = 0; i < sortedMigrations.length - 1; i++) {
+        if (sortedMigrations[i].version === sortedMigrations[i + 1].version) {
+            throw new Error(`All migrations for plugin ${pluginKey} must have a unique version`);
+        }
+    }
+    return sortedMigrations;
 }
 /**
- * Spec for adding admin crud input
+ * Spec for adding config for the plugin in the core plugin e.g.
+ * {
+ *  "plugins": [{
+ *    "id": "...",
+ *    "config": {
+ *       ...PluginConfig schema
+ *    }
+ *  }]
+ * }
  */
-const adminCrudInputSpec = createPluginSpec('core/admin-crud-input', {
-    defaultInitializer: createAdminCrudInputImplementation,
+const pluginConfigSpec = createFieldMapSpec('core/plugin-config', (t) => ({
+    schemas: t.map(),
+    migrations: t.map(),
+}), {
+    use: (values) => {
+        const validatedMigrations = mapValuesOfMap(values.migrations, (migrations, pluginKey) => sortAndValidateMigrations(migrations, pluginKey));
+        return {
+            getSchemaCreator: (pluginKey) => values.schemas.get(pluginKey),
+            getMigrations: (pluginKey) => validatedMigrations.get(pluginKey),
+            getLastMigrationVersion: (pluginKey) => {
+                const migrations = values.migrations.get(pluginKey);
+                return migrations?.[migrations.length - 1]?.version;
+            },
+        };
+    },
 });
 
-const createAdminCrudInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, slots) => {
-    const adminCrudInputs = ctx.plugins
-        .getPluginSpec(adminCrudInputSpec)
-        .getAdminCrudInputs();
-    return baseAdminCrudInputSchema.transform((data) => {
-        const inputDef = adminCrudInputs.get(data.type);
-        if (!inputDef)
-            return data;
-        return inputDef.createSchema(ctx, slots).parse(data);
+function runPluginMigrations(projectDefinition, pluginSpecStore) {
+    const pluginConfigService = pluginSpecStore.use(pluginConfigSpec);
+    return produce(projectDefinition, (draft) => {
+        for (const pluginDefinition of draft.plugins ?? []) {
+            const pluginMigrations = pluginConfigService.getMigrations(pluginEntityType.keyFromId(pluginDefinition.id));
+            const currentSchemaVersion = pluginDefinition.configSchemaVersion ?? -1;
+            if (!pluginMigrations)
+                continue;
+            const lastPluginMigration = pluginMigrations.at(-1);
+            if (!lastPluginMigration)
+                continue;
+            for (const migration of pluginMigrations) {
+                if (migration.version > currentSchemaVersion) {
+                    try {
+                        const migrationResult = migration.migrate(pluginDefinition.config, draft);
+                        if (migrationResult.updatedConfig !== undefined) {
+                            pluginDefinition.config = migrationResult.updatedConfig;
+                        }
+                        if (migrationResult.updateProjectDefinition) {
+                            migrationResult.updateProjectDefinition(draft);
+                        }
+                    }
+                    catch (error) {
+                        throw new Error(`Error migrating plugin ${pluginDefinition.id} to version ${migration.version}: ${String(error)}`);
+                    }
+                }
+            }
+            pluginDefinition.configSchemaVersion = lastPluginMigration.version;
+        }
     });
-});
+}
 
-const {z: z$d} = await importShared('zod');
-// Embedded Crud
-const createAdminCrudEmbeddedObjectSchemaInternal = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => z$d.object({
-    id: z$d.string().min(1),
-    name: z$d.string().min(1),
-    modelRef: ctx.withRef({
-        type: modelEntityType,
-        onDelete: 'RESTRICT',
-        provides: modelSlot,
-    }),
-    includeIdField: z$d.boolean().optional(),
-    type: z$d.literal('object'),
-    form: z$d.object({
-        fields: z$d.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
-    }),
-}));
-const createAdminCrudEmbeddedListSchemaInternal = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => z$d.object({
-    id: z$d.string().min(1),
-    name: z$d.string().min(1),
-    modelRef: ctx.withRef({
-        type: modelEntityType,
-        onDelete: 'RESTRICT',
-        provides: modelSlot,
-    }),
-    includeIdField: z$d.boolean().optional(),
-    type: z$d.literal('list'),
-    table: z$d.object({
-        columns: z$d.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
-    }),
-    form: z$d.object({
-        fields: z$d.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
-    }),
-}));
-const createAdminCrudEmbeddedFormSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => ctx.withEnt(z$d.discriminatedUnion('type', [
-    createAdminCrudEmbeddedObjectSchemaInternal(ctx, {
-        modelSlot,
-        adminSectionSlot,
-    }),
-    createAdminCrudEmbeddedListSchemaInternal(ctx, {
-        modelSlot,
-        adminSectionSlot,
-    }),
-]), {
-    type: adminCrudEmbeddedFormEntityType,
-    parentSlot: adminSectionSlot,
-})));
-// Admin Section
-const createAdminCrudSectionSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => createBaseAdminSectionValidators(ctx).and(z$d.object({
-    type: z$d.literal('crud'),
-    modelRef: ctx.withRef({
-        type: modelEntityType,
-        onDelete: 'RESTRICT',
-        provides: modelSlot,
-    }),
-    /* The field that will be used to display the name of the entity in the form */
-    nameFieldRef: ctx.withRef({
-        type: modelScalarFieldEntityType,
-        onDelete: 'RESTRICT',
-        parentSlot: modelSlot,
-    }),
-    disableCreate: ctx.withDefault(z$d.boolean(), false),
-    table: z$d.object({
-        columns: z$d.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
-        actions: ctx.withDefault(z$d.array(createAdminCrudActionSchema(ctx)), [
-            { type: 'edit', position: 'inline' },
-            { type: 'delete', position: 'dropdown' },
-        ]),
-    }),
-    form: z$d.object({
-        fields: z$d.array(createAdminCrudInputSchema(ctx, {
-            modelSlot,
-            adminSectionSlot,
-        })),
+/**
+ * Spec for allowing plugins to declare standard auth configurations
+ */
+const authConfigSpec = createFieldMapSpec('core/auth-config', (t) => ({
+    getAuthConfig: t.scalar(),
+}), {
+    use: (values) => ({
+        getAuthConfig: (definition) => values.getAuthConfig?.(definition),
+        getAuthConfigOrThrow: (definition) => {
+            const config = values.getAuthConfig?.(definition);
+            if (!config) {
+                throw new Error('Auth config not found');
+            }
+            return config;
+        },
     }),
-    embeddedForms: z$d
-        .array(createAdminCrudEmbeddedFormSchema(ctx, { adminSectionSlot }))
-        .optional(),
-}))));
+});
 
-const {z: z$c} = await importShared('zod');
-const createWebAdminSectionSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => ctx.refContext({ adminSectionSlot: adminSectionEntityType }, ({ adminSectionSlot }) => ctx.withEnt(createAdminCrudSectionSchema(ctx, { adminSectionSlot }), {
-    type: adminSectionEntityType,
-    parentSlot: appSlot,
-    provides: adminSectionSlot,
-})));
-const createAdminAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => ctx.withDefault(z$c.object({
-    enabled: z$c.boolean(),
-    pathPrefix: z$c.string().default('/admin'),
-    allowedRoles: ctx.withDefault(z$c.array(ctx.withRef({
-        type: authRoleEntityType,
-        onDelete: 'DELETE',
-    })), []),
-    sections: ctx.withDefault(z$c.array(createWebAdminSectionSchema(ctx, { appSlot })), []),
-}), { enabled: false, pathPrefix: '/admin' }));
+const authModelsSpec = createFieldMapSpec('core/auth-models', (t) => ({
+    getAuthModels: t.scalar(),
+}), {
+    use: (values) => ({
+        getAuthModels: (definition) => values.getAuthModels?.(definition),
+        getAuthModelsOrThrow: (definition) => {
+            const authModels = values.getAuthModels?.(definition);
+            if (!authModels) {
+                throw new Error('Auth models not found');
+            }
+            return authModels;
+        },
+    }),
+});
 
-const {z: z$b} = await importShared('zod');
-const createWebAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => z$b.object({
-    ...baseAppValidators,
-    type: z$b.literal('web'),
-    includeAuth: ctx.withDefault(z$b.boolean(), false),
-    title: z$b.string().default(''),
-    description: z$b.string().default(''),
-    includeUploadComponents: ctx.withDefault(z$b.boolean(), false),
-    enableSubscriptions: ctx.withDefault(z$b.boolean(), false),
-    adminApp: createAdminAppSchema(ctx, { appSlot }),
+/**
+ * Spec for adding config component for plugin
+ *
+ * Keyed by plugin key, value is the config component.
+ */
+const webConfigSpec = createFieldMapSpec('core/web-config', (t) => ({
+    components: t.map(),
 }));
-const webAppEntryType = createAppEntryType('web');
-
-const packageEntityType = createEntityType('package');
-function createPackageEntryType(name) {
-    return name;
-}
-
-const {CASE_VALIDATORS: CASE_VALIDATORS$2} = await importShared('@baseplate-dev/utils');
 
 const {z: z$a} = await importShared('zod');
-const basePackageValidators = {
-    id: z$a.string().default(packageEntityType.generateNewId()),
-    name: CASE_VALIDATORS$2.KEBAB_CASE,
-    type: z$a.string(),
-};
-const basePackageSchema = z$a.object(basePackageValidators);
-
-const {z: z$9} = await importShared('zod');
-const createNodeLibraryPackageSchema = definitionSchemaWithSlots({ packageSlot: packageEntityType }, () => z$9.object({
-    ...basePackageValidators,
-    type: z$9.literal('node-library'),
-}));
-const nodeLibraryPackageEntryType = createPackageEntryType('node-library');
-
-const {z: z$8} = await importShared('zod');
-const basePluginDefinitionSchema = z$8.object({
-    id: z$8.string(),
-    packageName: z$8.string(),
-    name: z$8.string(),
-    version: z$8.string(),
-    config: z$8.unknown(),
-    configSchemaVersion: z$8.number().optional(),
+const basePluginDefinitionSchema = z$a.object({
+    id: z$a.string(),
+    packageName: z$a.string(),
+    name: z$a.string(),
+    version: z$a.string(),
+    config: z$a.unknown(),
+    configSchemaVersion: z$a.number().optional(),
 });
 const createPluginWithConfigSchema = definitionSchema((ctx) => ctx
     .withEnt(basePluginDefinitionSchema, {
@@ -3272,7 +3060,7 @@ const createPluginWithConfigSchema = definitionSchema((ctx) => ctx
     .transform((data) => {
     const pluginKey = pluginEntityType.keyFromId(data.id);
     const createConfigSchema = ctx.plugins
-        .getPluginSpec(pluginConfigSpec)
+        .use(pluginConfigSpec)
         .getSchemaCreator(pluginKey);
     if (!createConfigSchema)
         return data;
@@ -3281,7 +3069,45 @@ const createPluginWithConfigSchema = definitionSchema((ctx) => ctx
         config: createConfigSchema(ctx).parse(data.config),
     };
 }));
-const createPluginsSchema = definitionSchema((ctx) => z$8.array(createPluginWithConfigSchema(ctx)));
+const createPluginsSchema = definitionSchema((ctx) => z$a.array(createPluginWithConfigSchema(ctx)));
+
+const z$9 = await importShared('zod');
+const createNodeLibrarySchema = definitionSchemaWithSlots({ librarySlot: libraryEntityType }, () => z$9.object({
+    ...baseLibraryValidators,
+    type: z$9.literal('node-library'),
+}));
+const nodeLibraryDefinitionSchemaEntry = {
+    name: 'node-library',
+    definitionSchema: createNodeLibrarySchema,
+};
+/**
+ * Creates a typed library web config
+ */
+function createLibraryWebConfig(config) {
+    return config;
+}
+/**
+ * Package type spec for registering package schemas, compilers, and web configs.
+ */
+const libraryTypeSpec = createFieldMapSpec('core/library-type', (t) => ({
+    schemaCreators: t.namedArrayToMap([
+        nodeLibraryDefinitionSchemaEntry,
+    ]),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    compilerCreators: t.namedArrayToMap(),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    webConfigs: t.namedArrayToMap(),
+}));
+
+const z$8 = await importShared('zod');
+const createLibrarySchema = definitionSchema((ctx) => ctx.refContext({ librarySlot: libraryEntityType }, ({ librarySlot }) => {
+    const packageTypes = ctx.plugins.use(libraryTypeSpec);
+    const schemas = [...packageTypes.schemaCreators.values()].map((entry) => entry.definitionSchema(ctx, { librarySlot }));
+    return ctx.withEnt(z$8.discriminatedUnion('type', schemas), {
+        type: libraryEntityType,
+        provides: librarySlot,
+    });
+}));
 
 const {CASE_VALIDATORS: CASE_VALIDATORS$1} = await importShared('@baseplate-dev/utils');
 
@@ -3364,7 +3190,7 @@ const {z: z$5} = await importShared('zod');
 /**
  * Monorepo settings schema
  *
- * Configures the folder structure for monorepo packages.
+ * Configures the folder structure for monorepo apps and libraries.
  */
 const monorepoSettingsSchema = z$5.object({
     /**
@@ -3384,21 +3210,21 @@ const monorepoSettingsSchema = z$5.object({
     })
         .default('apps'),
     /**
-     * The folder where library packages are located in the monorepo.
+     * The folder where libraries are located in the monorepo.
      *
      * Must be in kebab-case format (lowercase letters and dashes only).
-     * Packages will be placed in {packagesFolder}/{package-name}, e.g. "packages/shared-utils".
+     * Libraries will be placed in {librariesFolder}/{library-name}, e.g. "libs/shared-utils".
      *
-     * @default "packages"
-     * @example "packages" → packages/shared-utils, packages/common
+     * @default "libs"
      * @example "libs" → libs/shared-utils, libs/common
+     * @example "packages" → packages/shared-utils, packages/common
      */
-    packagesFolder: CASE_VALIDATORS.KEBAB_CASE.min(1)
+    librariesFolder: CASE_VALIDATORS.KEBAB_CASE.min(1)
         .max(50)
         .regex(/^[a-z0-9-]+$/, {
-        message: 'Packages folder must contain only lowercase letters, numbers, and dashes (no slashes)',
+        message: 'Libraries folder must contain only lowercase letters, numbers, and dashes (no slashes)',
     })
-        .default('packages'),
+        .default('libs'),
 });
 
 const {z: z$4} = await importShared('zod');
@@ -3590,17 +3416,10 @@ const createAppSchema = definitionSchema((ctx) => ctx.refContext({ appSlot: appE
     type: appEntityType,
     provides: appSlot,
 })));
-const createPackageSchema = definitionSchema((ctx) => ctx.refContext({ packageSlot: packageEntityType }, ({ packageSlot }) => ctx.withEnt(z$1.discriminatedUnion('type', [
-    createNodeLibraryPackageSchema(ctx, { packageSlot }),
-    // Future: add more package types here
-]), {
-    type: packageEntityType,
-    provides: packageSlot,
-})));
 const createProjectDefinitionSchema = definitionSchema((ctx) => z$1.object({
     cliVersion: z$1.string().nullish(),
     apps: z$1.array(createAppSchema(ctx)).default([]),
-    packages: z$1.array(createPackageSchema(ctx)).default([]),
+    libraries: z$1.array(createLibrarySchema(ctx)).default([]),
     features: createFeaturesSchema(ctx),
     models: z$1.array(createModelSchema(ctx)).default([]),
     enums: z$1.array(createEnumSchema(ctx)).optional(),
@@ -3712,49 +3531,51 @@ const ModelFieldUtils = {
     relationByIdOrThrow,
 };
 
-function getTransformer(transformer, pluginStore) {
-    const transformers = pluginStore.getPluginSpec(modelTransformerSpec);
-    return transformers.getModelTransformer(transformer.type);
-}
-function getTransformName(definitionContainer, transformer, pluginStore) {
-    const transformers = pluginStore.getPluginSpec(modelTransformerSpec);
-    return transformers
-        .getModelTransformer(transformer.type)
-        .getName(definitionContainer, transformer);
+function getTransformerName(definitionContainer, transformer, pluginStore) {
+    const { transformers } = pluginStore.use(modelTransformerSpec);
+    const transformerType = transformers.get(transformer.type);
+    if (!transformerType) {
+        throw new Error(`Unable to find transformer with name ${transformer.type}`);
+    }
+    return transformerType.getName(definitionContainer, transformer);
 }
-const ModelTransformerUtils = { getTransformer, getTransformName };
+const ModelTransformerUtils = { getTransformerName };
 
 function byId(projectDefinition, id) {
-    const config = projectDefinition.packages.find((pkg) => pkg.id === id);
+    const config = projectDefinition.libraries.find((lib) => lib.id === id);
     if (!config) {
-        throw new Error(`Unable to find package with ID ${id}`);
+        throw new Error(`Unable to find library with ID ${id}`);
     }
     return config;
 }
+function byUniqueTypeOrThrow(projectDefinition, type) {
+    const config = projectDefinition.libraries.filter((lib) => lib.type === type);
+    if (config.length === 0) {
+        throw new Error(`Unable to find library with type ${type}`);
+    }
+    if (config.length > 1) {
+        throw new Error(`Multiple libraries with type ${type} found and only one is expected (${config.map((lib) => lib.name).join(', ')})`);
+    }
+    return config[0];
+}
 /**
- * Given a package config, get the relative directory of the package
+ * Given a library config, get the relative directory of the library
  *
- * @param packageConfig The package config
- * @param monorepoSettings Optional monorepo settings to determine packages folder location
- * @returns The directory of the package
+ * @param libraryConfig The library config
+ * @param monorepoSettings Optional monorepo settings to determine libraries folder location
+ * @returns The directory of the library
  */
-function getPackageDirectory(packageConfig, monorepoSettings) {
-    const packagesFolder = monorepoSettings?.packagesFolder ?? 'packages';
-    return `${packagesFolder}/${packageConfig.name}`;
+function getLibraryDirectory(libraryConfig, monorepoSettings) {
+    const librariesFolder = monorepoSettings?.librariesFolder ?? 'libs';
+    return `${librariesFolder}/${libraryConfig.name}`;
 }
-const PackageUtils = {
+const LibraryUtils = {
     byId,
-    getPackageDirectory,
+    byUniqueTypeOrThrow,
+    getLibraryDirectory,
 };
 
 const {z} = await importShared('zod');
-const COMMON_SPEC_IMPLEMENTATIONS = [
-    pluginConfigSpec,
-    modelTransformerSpec,
-    adminCrudInputSpec,
-    adminCrudActionSpec,
-    adminCrudColumnSpec,
-];
 /**
  * Creates a plugin implementation store from the project definition and plugin store,
  * initializing the set of plugins enabled in the project definition.
@@ -3763,8 +3584,8 @@ const COMMON_SPEC_IMPLEMENTATIONS = [
  * @param projectDefinition The project definition to use
  * @returns The plugin implementation store
  */
-function createPluginImplementationStore(pluginStore, projectDefinition) {
-    const { availablePlugins, builtinSpecImplementations = [] } = pluginStore;
+function createPluginSpecStore(pluginStore, projectDefinition) {
+    const { availablePlugins, coreModules } = pluginStore;
     const pluginData = z
         .object({
         plugins: z.array(basePluginDefinitionSchema).optional(),
@@ -3772,35 +3593,18 @@ function createPluginImplementationStore(pluginStore, projectDefinition) {
         .parse(projectDefinition);
     const { plugins = [] } = pluginData;
     // initialize plugins
-    const initialImplementations = [
-        ...COMMON_SPEC_IMPLEMENTATIONS,
-        ...builtinSpecImplementations,
-    ];
-    const specImplementations = {};
-    for (const spec of initialImplementations) {
-        if ('type' in spec) {
-            if (typeof spec.defaultInitializer !== 'function') {
-                throw new TypeError(`Spec ${spec.type} does not have a defaultInitializer function!`);
-            }
-            specImplementations[spec.name] = spec.defaultInitializer();
-        }
-        else {
-            specImplementations[spec.spec.name] = spec.implementation;
-        }
-    }
-    const pluginsWithModules = plugins.map((p) => {
+    const modulesWithKey = plugins.flatMap((p) => {
         const plugin = availablePlugins.find(({ metadata }) => metadata.name === p.name && metadata.packageName === p.packageName);
-        const pluginName = `${p.packageName}/${p.name}`;
         if (!plugin) {
-            throw new Error(`Unable to find plugin ${pluginName}!`);
+            throw new Error(`Unable to find plugin ${p.packageName}/${p.name}!`);
         }
-        return {
-            key: plugin.metadata.key,
-            name: pluginName,
-            pluginModules: plugin.modules,
-        };
+        return plugin.modules.map((m) => ({
+            key: `${plugin.metadata.key}/${m.directory}/${m.module.name}`,
+            pluginKey: plugin.metadata.key,
+            module: m.module,
+        }));
     });
-    return initializePlugins(pluginsWithModules, specImplementations);
+    return initializePlugins([...modulesWithKey, ...coreModules]);
 }
 /**
  * Creates a plugin implementation store with the given plugins added to the project definition.
@@ -3826,7 +3630,7 @@ function createPluginImplementationStoreWithNewPlugins(pluginStore, plugins, pro
             })),
         ],
     };
-    return createPluginImplementationStore(pluginStore, newProjectDefinition);
+    return createPluginSpecStore(pluginStore, newProjectDefinition);
 }
 /**
  * Creates a project definition schema with the given context.
@@ -3837,9 +3641,9 @@ function createPluginImplementationStoreWithNewPlugins(pluginStore, plugins, pro
  */
 function createProjectDefinitionSchemaWithContext(projectDefinition, context) {
     const { pluginStore } = context;
-    const pluginImplementationStore = createPluginImplementationStore(pluginStore, projectDefinition);
+    const pluginSpecStore = createPluginSpecStore(pluginStore, projectDefinition);
     const definitionContext = createDefinitionSchemaParserContext({
-        plugins: pluginImplementationStore,
+        plugins: pluginSpecStore,
     });
     return createProjectDefinitionSchema(definitionContext);
 }
@@ -3856,9 +3660,9 @@ function parseProjectDefinitionWithContext(projectDefinition, context) {
  */
 function parseProjectDefinitionWithReferences(projectDefinition, context) {
     const { pluginStore } = context;
-    const pluginImplementationStore = createPluginImplementationStore(pluginStore, projectDefinition);
-    const definition = parseSchemaWithTransformedReferences(createProjectDefinitionSchema, projectDefinition, { plugins: pluginImplementationStore });
-    return { definition, pluginStore: pluginImplementationStore };
+    const pluginSpecStore = createPluginSpecStore(pluginStore, projectDefinition);
+    const definition = parseSchemaWithTransformedReferences(createProjectDefinitionSchema, projectDefinition, { plugins: pluginSpecStore });
+    return { definition, pluginStore: pluginSpecStore };
 }
 
 function byKey(projectDefinition, key) {
@@ -3888,8 +3692,8 @@ function setPluginConfig(projectDefinition, plugin, pluginConfig, definitionCont
     if (isNewPlugin) {
         // When adding a new plugin, we need to create an implementation store
         // that includes this plugin so its migrations are properly registered
-        const pluginImplementationStore = createPluginImplementationStoreWithNewPlugins(definitionContainer.parserContext.pluginStore, [plugin], definitionContainer.definition);
-        const pluginConfigService = pluginImplementationStore.getPluginSpec(pluginConfigSpec);
+        const pluginSpecStore = createPluginImplementationStoreWithNewPlugins(definitionContainer.parserContext.pluginStore, [plugin], definitionContainer.definition);
+        const pluginConfigService = pluginSpecStore.use(pluginConfigSpec);
         const lastMigrationVersion = pluginConfigService.getLastMigrationVersion(plugin.key);
         projectDefinition.plugins = [
             ...plugins,
@@ -4024,7 +3828,7 @@ class ProjectDefinitionContainer {
      * @returns A new ProjectDefinitionContainer
      */
     static fromSerializedConfig(config, context) {
-        const plugins = createPluginImplementationStore(context.pluginStore, config);
+        const plugins = createPluginSpecStore(context.pluginStore, config);
         return new ProjectDefinitionContainer(deserializeSchemaWithTransformedReferences(createProjectDefinitionSchema, config, { plugins }), context, plugins);
     }
 }
@@ -9348,6 +9152,50 @@ const migration021MigrateBullmqToPlugin = createSchemaMigration({
     },
 });
 
+/**
+ * Migration to rename packages to libraries
+ *
+ * This migration:
+ * 1. Renames the top-level `packages` field to `libraries`
+ * 2. Updates package IDs from `package:*` to `library:*`
+ * 3. Renames `settings.monorepo.packagesFolder` to `settings.monorepo.librariesFolder`
+ *    and changes the default from 'packages' to 'libs'
+ */
+const migration022RenamePackagesToLibraries = createSchemaMigration({
+    version: 22,
+    name: 'renamePackagesToLibraries',
+    description: 'Rename packages to libraries and packagesFolder to librariesFolder',
+    migrate: (config) => {
+        const { packages, settings, ...rest } = config;
+        // Rename packages to libraries and update IDs
+        const libraries = packages?.map((pkg) => ({
+            ...pkg,
+            id: pkg.id.replace(/^package:/, 'library:'),
+        }));
+        // Update monorepo settings if present
+        let newSettings = settings;
+        if (settings?.monorepo) {
+            const { packagesFolder, ...restMonorepo } = settings.monorepo;
+            newSettings = {
+                ...settings,
+                monorepo: {
+                    ...restMonorepo,
+                    // If packagesFolder was explicitly set to 'packages' (old default) or not set,
+                    // use 'libs' (new default). Otherwise preserve the custom value.
+                    librariesFolder: packagesFolder === undefined || packagesFolder === 'packages'
+                        ? 'libs'
+                        : packagesFolder,
+                },
+            };
+        }
+        return {
+            ...rest,
+            libraries,
+            settings: newSettings,
+        };
+    },
+});
+
 const SCHEMA_MIGRATIONS = [
     migration005PrimaryUniqueRefs,
     migration006IndividualServiceControllers,
@@ -9366,6 +9214,7 @@ const SCHEMA_MIGRATIONS = [
     migration019ColumnTypeBased,
     migration020MoveRedisToInfrastructure,
     migration021MigrateBullmqToPlugin,
+    migration022RenamePackagesToLibraries,
 ];
 function isMigrateableProjectDefinition(projectDefinition) {
     return (typeof projectDefinition === 'object' &&
@@ -9415,7 +9264,7 @@ function createTestProjectDefinition(input = {}) {
         features: [],
         cliVersion: '1.0.0',
         apps: [],
-        packages: [],
+        libraries: [],
         models: [],
         isInitialized: true,
         schemaVersion: getLatestMigrationVersion(),
@@ -9431,9 +9280,12 @@ function createTestProjectDefinitionInput(input = {}) {
 function createTestProjectDefinitionContainer(input = {}) {
     const pluginStore = {
         availablePlugins: [],
+        coreModules: [],
     };
-    const pluginImplementationStore = createPluginImplementationStore(pluginStore, { plugins: [] });
-    const resolvedRefPayload = deserializeSchemaWithTransformedReferences(createProjectDefinitionSchema, createTestProjectDefinitionInput(input), { plugins: pluginImplementationStore });
+    const pluginSpecStore = createPluginSpecStore(pluginStore, {
+        plugins: [],
+    });
+    const resolvedRefPayload = deserializeSchemaWithTransformedReferences(createProjectDefinitionSchema, createTestProjectDefinitionInput(input), { plugins: pluginSpecStore });
     return new ProjectDefinitionContainer(resolvedRefPayload, {
         pluginStore,
         cliVersion: '0.1.0',
@@ -9443,11 +9295,96 @@ function createTestProjectDefinitionContainer(input = {}) {
             directory: '/test-project',
             isInternalExample: false,
         },
-    }, pluginImplementationStore);
+    }, pluginSpecStore);
 }
 
 const AVAILABLE_FLAGS = ['TEMPLATE_EXTRACTOR'];
 
+/**
+ * Abstract base class for package type compilers
+ *
+ * Each package type (backend, web, library, etc.) extends this class
+ * to define how it should be compiled into a PackageEntry with generator bundles.
+ *
+ * Each child class defines its own constructor requirements based on what
+ * information it needs (e.g., app config, definition container).
+ */
+class PackageCompiler {
+    definitionContainer;
+    constructor(definitionContainer) {
+        this.definitionContainer = definitionContainer;
+    }
+    /**
+     * Get the tasks for a package used in turbo configuration
+     *
+     * @returns Object with build, dev, and watch tasks
+     */
+    getTasks() {
+        return {
+            build: [],
+            dev: [],
+            watch: [],
+        };
+    }
+}
+// ============================================================================
+// Package Directory Helpers
+// ============================================================================
+const DEFAULT_APPS_FOLDER = 'apps';
+const DEFAULT_LIBRARIES_FOLDER = 'libs';
+/**
+ * Build a scoped package name using the package scope or project name as scope
+ *
+ * @example
+ * ```typescript
+ * buildPackageName({ name: 'blog', packageScope: 'acme' }, 'utils')
+ * // Returns: '@acme/utils'
+ *
+ * buildPackageName({ name: 'blog', packageScope: '' }, 'utils')
+ * // Returns: '@blog/utils'
+ * ```
+ */
+function buildPackageName(generalSettings, packageName) {
+    const scope = generalSettings.packageScope || generalSettings.name;
+    return `@${scope}/${packageName}`;
+}
+/**
+ * Get the package directory for an app or library package based off
+ * the monorepo settings and package name
+ */
+function getPackageDirectory(monorepoSettings, packageName, packageType) {
+    const folder = packageType === 'app'
+        ? (monorepoSettings?.appsFolder ?? DEFAULT_APPS_FOLDER)
+        : (monorepoSettings?.librariesFolder ?? DEFAULT_LIBRARIES_FOLDER);
+    return `${folder}/${packageName}`;
+}
+// ============================================================================
+// Library Compiler Base Class
+// ============================================================================
+/**
+ * Abstract base class for library package compilers
+ *
+ * Library packages differ from app packages in that they:
+ * - Don't use the plugin system (no AppEntryBuilder)
+ * - Use the librariesFolder instead of appsFolder
+ * - Have simpler compilation without app-specific features
+ */
+class LibraryCompiler extends PackageCompiler {
+    packageConfig;
+    constructor(definitionContainer, packageConfig) {
+        super(definitionContainer);
+        this.packageConfig = packageConfig;
+    }
+    getPackageName() {
+        const generalSettings = this.definitionContainer.definition.settings.general;
+        return buildPackageName(generalSettings, this.packageConfig.name);
+    }
+    getPackageDirectory() {
+        const monorepoSettings = this.definitionContainer.definition.settings.monorepo;
+        return getPackageDirectory(monorepoSettings, this.packageConfig.name, 'library');
+    }
+}
+
 /**
  * Convert a color name to a hex color. Can be one of the following:
  * - A fixed color name (e.g. 'white', 'black').
@@ -10503,5 +10440,5 @@ function generateDefaultTheme() {
     };
 }
 
-export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_ACTIONS, BUILT_IN_ADMIN_CRUD_COLUMNS, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, PackageUtils, PluginImplementationStore, PluginUtils, ProjectDefinitionContainer, REFERENTIAL_ACTIONS, SCALAR_FIELD_TYPES, SCHEMA_MIGRATIONS, SchemaMigrationError, THEME_COLORS, THEME_COLOR_KEYS, VALIDATORS, adminCrudActionCompilerSpec, adminCrudActionEntityType, adminCrudActionSpec, adminCrudColumnCompilerSpec, adminCrudColumnEntityType, adminCrudColumnSpec, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedInputType, adminCrudEmbeddedLocalInputType, adminCrudInputCompilerSpec, adminCrudInputEntityType, adminCrudInputSpec, adminCrudSectionColumnEntityType, adminSectionEntityType, appCompilerSpec, appEntityType, authConfigSpec, authModelConfigSpec, authRoleEntityType, backendAppEntryType, baseAdminCrudActionSchema, baseAdminCrudColumnSchema, baseAdminCrudInputSchema, baseAppSchema, baseAppValidators, basePackageSchema, basePackageValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudActionCompilerImplementation, createAdminCrudActionImplementation, createAdminCrudActionSchema, createAdminCrudActionType, createAdminCrudColumnCompiler, createAdminCrudColumnCompilerImplementation, createAdminCrudColumnImplementation, createAdminCrudColumnSchema, createAdminCrudColumnType, createAdminCrudDeleteActionSchema, createAdminCrudEditActionSchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEnumInputSchema, createAdminCrudForeignColumnSchema, createAdminCrudForeignInputSchema, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputSchema, createAdminCrudInputType, createAdminCrudPasswordInputSchema, createAdminCrudSectionSchema, createAdminCrudTextColumnSchema, createAdminCrudTextInputSchema, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createAppSchema, createBackendAppSchema, createBaseAdminSectionValidators, createDefinitionEntityNameResolver, createDefinitionSchemaParserContext, createEmbeddedRelationTransformerSchema, createEntityType, createEnumBaseSchema, createEnumSchema, createEnumValueSchema, createFeaturesSchema, createModelBaseSchema, createModelGraphqlSchema, createModelRelationFieldSchema, createModelScalarFieldSchema, createModelSchema, createModelServiceSchema, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createModelUniqueConstraintSchema, createNodeLibraryPackageSchema, createPackageEntryType, createPackageSchema, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginImplementationStoreWithNewPlugins, createPluginSpec, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAdminSectionSchema, createWebAppSchema, createWebConfigImplementation, definitionSchema, definitionSchemaWithSlots, deserializeSchemaWithTransformedReferences, extractDefinitionRefs, featureEntityType, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, getManagedPluginsForPlugin, getPluginMetadataByKey, getPluginMetadataByKeyOrThrow, infrastructureSettingsSchema, initializePlugins, isMigrateableProjectDefinition, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, monorepoSettingsSchema, nodeLibraryPackageEntryType, oklchColor, packageEntityType, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, pluginConfigSpec, pluginEntityType, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, themeColorSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webConfigSpec };
-//# sourceMappingURL=project-builder-lib-CcNtL_U6.js.map
+export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_ACTIONS, BUILT_IN_ADMIN_CRUD_COLUMNS, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, DEFAULT_APPS_FOLDER, DEFAULT_LIBRARIES_FOLDER, EnumUtils, FIXED_COLOR_MAPPINGS, LibraryCompiler, LibraryUtils, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, PackageCompiler, PluginSpecStore, PluginUtils, ProjectDefinitionContainer, REFERENTIAL_ACTIONS, SCALAR_FIELD_TYPES, SCHEMA_MIGRATIONS, SchemaMigrationError, THEME_COLORS, THEME_COLOR_KEYS, VALIDATORS, adminCrudActionCompilerSpec, adminCrudActionEntityType, adminCrudActionSpec, adminCrudColumnCompilerSpec, adminCrudColumnEntityType, adminCrudColumnSpec, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedInputType, adminCrudEmbeddedLocalInputType, adminCrudInputCompilerSpec, adminCrudInputEntityType, adminCrudInputSpec, adminCrudSectionColumnEntityType, adminSectionEntityType, appCompilerSpec, appEntityType, authConfigSpec, authModelsSpec, authRoleEntityType, backendAppEntryType, baseAdminCrudActionSchema, baseAdminCrudColumnSchema, baseAdminCrudInputSchema, baseAppSchema, baseAppValidators, baseLibrarySchema, baseLibraryValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, buildPackageName, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudActionSchema, createAdminCrudActionType, createAdminCrudColumnCompiler, createAdminCrudColumnSchema, createAdminCrudColumnType, createAdminCrudDeleteActionSchema, createAdminCrudEditActionSchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEnumInputSchema, createAdminCrudForeignColumnSchema, createAdminCrudForeignInputSchema, createAdminCrudInputSchema, createAdminCrudInputType, createAdminCrudPasswordInputSchema, createAdminCrudSectionSchema, createAdminCrudTextColumnSchema, createAdminCrudTextInputSchema, createAppCompiler, createAppEntryType, createAppSchema, createBackendAppSchema, createBaseAdminSectionValidators, createDefinitionEntityNameResolver, createDefinitionSchemaParserContext, createEmbeddedRelationTransformerSchema, createEntityType, createEnumBaseSchema, createEnumSchema, createEnumValueSchema, createFeaturesSchema, createFieldMapSpec, createLibraryWebConfig, createModelBaseSchema, createModelGraphqlSchema, createModelRelationFieldSchema, createModelScalarFieldSchema, createModelSchema, createModelServiceSchema, createModelTransformerType, createModelUniqueConstraintSchema, createPluginImplementationStoreWithNewPlugins, createPluginModule, createPluginSpecStore, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAdminSectionSchema, createWebAppSchema, definitionSchema, definitionSchemaWithSlots, deserializeSchemaWithTransformedReferences, extractDefinitionRefs, featureEntityType, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, getManagedPluginsForPlugin, getPackageDirectory, getPluginMetadataByKey, getPluginMetadataByKeyOrThrow, infrastructureSettingsSchema, initializePlugins, isMigrateableProjectDefinition, libraryEntityType, libraryTypeSpec, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, monorepoSettingsSchema, nodeLibraryDefinitionSchemaEntry, oklchColor, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, pluginAppCompiler, pluginConfigSpec, pluginEntityType, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, runInPluginContext, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, themeColorSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webConfigSpec };
+//# sourceMappingURL=project-builder-lib-CmgMfkI5.js.map