@baseplate-dev/plugin-auth 3.0.1 → 3.0.3

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

@@ -1,6 +1,6 @@
-import { c as createPluginSpec, m as mapValues, a as createEntityType, d as definitionSchema, D as DefinitionReferenceMarker, g as get, R as REF_ANNOTATIONS_MARKER_SYMBOL, b as createDefinitionSchemaParserContext, s as set$1, e as modelForeignRelationEntityType, f as modelLocalRelationEntityType, h as modelScalarFieldEntityType, i as modelEntityType, j as modelTransformerEntityType, k as modelEnumValueEntityType, l as featureEntityType, n as modelEnumEntityType, o as modelUniqueConstraintEntityType, p as createFeaturesSchema, M as ModelUtils, q as omit, r as cloneDeep } from '../model-merger-CI1pu411.js';
-export { I as DefinitionDiffArrayIncludesField, G as DefinitionDiffKeyedArrayField, H as DefinitionDiffReplacementField, u as DefinitionEntityType, F as FeatureUtils, L as applyDefinitionDiff, B as applyModelMergerDiff, C as applyModelMergerResultInPlace, E as createAndApplyModelMergerResults, K as createDefinitionDiff, J as createDefinitionDiffConfig, w as createFeatureSchema, t as createInitializedPluginSpec, y as createModelMergerResult, A as createModelMergerResults, z as doesModelMergerResultsHaveChanges, v as featureNameSchema, x as modelMergerDefinitionDiffConfig } from '../model-merger-CI1pu411.js';
-import { importShared } from '../__federation_fn_import-BVpKhyMw.js';
+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-kOQ_dmiE.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-kOQ_dmiE.js';
+import { importShared } from '../__federation_fn_import-CVjKjdRb.js';
 import { i as isEqual } from '../isEqual-DAXqKRba.js';
 import { s as sortBy } from '../sortBy-BPH_zRB8.js';
 
@@ -312,45 +312,45 @@ function getManagedPluginsForPlugin(pluginStore, pluginKey) {
         .map((p) => p.metadata);
 }
 
-const {z: z$r} = await importShared('zod');
+const {z: z$s} = await importShared('zod');
 
 // matches semver
-const versionSchema = z$r.string().regex(/^(\d+\.\d+\.\d+)$/);
-const pluginSpecSupportSchema = z$r.object({
-    spec: z$r.string().min(1),
-    version: z$r.string().min(1),
+const versionSchema = z$s.string().regex(/^(\d+\.\d+\.\d+)$/);
+const pluginSpecSupportSchema = z$s.object({
+    spec: z$s.string().min(1),
+    version: z$s.string().min(1),
 });
-const pluginSpecDependencySchema = z$r.object({
-    spec: z$r.string(),
-    version: z$r.string(),
+const pluginSpecDependencySchema = z$s.object({
+    spec: z$s.string(),
+    version: z$s.string(),
 });
 /**
  * Schema for the plugin's metadata (plugin.json)
  */
-const pluginMetadataSchema = z$r.object({
+const pluginMetadataSchema = z$s.object({
     /**
      * The name of the plugin - must be lowercase and contain only letters, numbers, and hyphens
      */
-    name: z$r
+    name: z$s
         .string()
         .min(1)
         .regex(/^[a-z0-9-]+$/),
     /**
      * A list of directories with entrypoints in them. Defaults to ['.']
      */
-    moduleDirectories: z$r.array(z$r.string()).optional(),
+    moduleDirectories: z$s.array(z$s.string()).optional(),
     /**
      * The display name of the plugin
      */
-    displayName: z$r.string().min(1),
+    displayName: z$s.string().min(1),
     /**
      * The icon to display for the plugin as a pointer to the icon in the plugin's static folder
      */
-    icon: z$r.string().optional(),
+    icon: z$s.string().optional(),
     /**
      * A description of the plugin
      */
-    description: z$r.string(),
+    description: z$s.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.
@@ -358,7 +358,7 @@ const pluginMetadataSchema = z$r.object({
      * 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$r.string().optional(),
+    managedBy: z$s.string().optional(),
     /**
      * The version of the plugin using semver
      */
@@ -366,16 +366,16 @@ const pluginMetadataSchema = z$r.object({
     /**
      * Configuration for the specs that the plugin exports/depends on
      */
-    specs: z$r
+    specs: z$s
         .object({
         /**
          * The specs that the plugin exports
          */
-        exports: z$r.array(pluginSpecSupportSchema).optional(),
+        exports: z$s.array(pluginSpecSupportSchema).optional(),
         /**
          * The specs that the plugin depends on
          */
-        dependencies: z$r.array(pluginSpecDependencySchema).optional(),
+        dependencies: z$s.array(pluginSpecDependencySchema).optional(),
     })
         .optional(),
     /**
@@ -383,7 +383,7 @@ const pluginMetadataSchema = z$r.object({
      *
      * (It can be used once in the definition but cannot be added)
      */
-    hidden: z$r.boolean().optional(),
+    hidden: z$s.boolean().optional(),
 });
 
 var NOTHING = Symbol.for("immer-nothing");
@@ -1829,320 +1829,237 @@ function createAppEntryType(name) {
 
 const {CASE_VALIDATORS: CASE_VALIDATORS$2} = await importShared('@baseplate-dev/utils');
 
-const {z: z$q} = await importShared('zod');
+const {z: z$r} = await importShared('zod');
 const baseAppValidators = {
-    id: z$q.string().default(appEntityType.generateNewId()),
+    id: z$r.string().default(appEntityType.generateNewId()),
     name: CASE_VALIDATORS$2.KEBAB_CASE,
-    type: z$q.string(),
+    type: z$r.string(),
 };
-const baseAppSchema = z$q.object(baseAppValidators);
+const baseAppSchema = z$r.object(baseAppValidators);
 
-const {z: z$p} = await importShared('zod');
-const createBackendAppSchema = definitionSchema(() => z$p.object({
+const {z: z$q} = await importShared('zod');
+const createBackendAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, () => z$q.object({
     ...baseAppValidators,
-    type: z$p.literal('backend'),
-    enableStripe: z$p.boolean().optional(),
-    enableBullQueue: z$p.boolean().optional(),
-    enablePostmark: z$p.boolean().optional(),
-    enableSubscriptions: z$p.boolean().optional(),
-    enableAxios: z$p.boolean().optional(),
+    type: z$q.literal('backend'),
+    enableStripe: z$q.boolean().optional(),
+    enablePostmark: z$q.boolean().optional(),
+    enableSubscriptions: z$q.boolean().optional(),
+    enableAxios: z$q.boolean().optional(),
 }));
 const backendAppEntryType = createAppEntryType('backend');
 
 const authRoleEntityType = createEntityType('role');
 
 /**
- * Strips the DefinitionReferenceMarker from the value recursively.
- * @param value - The value to strip the DefinitionReferenceMarker from.
- * @returns The value without the DefinitionReferenceMarker.
+ * Creates a definition entity name resolver.
+ * @param entityNameResolver - The entity name resolver.
+ * @returns The definition entity name resolver.
  */
-function stripRefMarkers(value) {
+function createDefinitionEntityNameResolver(entityNameResolver) {
+    return entityNameResolver;
+}
+
+function collectRefAnnotationsRecursive(pathPrefix, value) {
+    if (value === undefined || value === null)
+        return undefined;
     if (value instanceof DefinitionReferenceMarker) {
-        return value.value;
+        return {
+            entities: [],
+            references: [
+                { ...value.reference, path: [...pathPrefix, ...value.reference.path] },
+            ],
+            slots: [],
+        };
     }
+    const collected = {
+        entities: [],
+        references: [],
+        slots: [],
+    };
     if (Array.isArray(value)) {
-        return value.map(stripRefMarkers);
+        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' && value !== null) {
-        return Object.fromEntries(Object.entries(value).map(([key, childValue]) => [
-            key,
-            stripRefMarkers(childValue),
-        ]));
+    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 value;
+    return undefined;
+}
+function collectRefs(value) {
+    return (collectRefAnnotationsRecursive([], value) ?? {
+        entities: [],
+        references: [],
+        slots: [],
+    });
 }
 
+const {mapGroupBy} = await importShared('@baseplate-dev/utils');
+
 /**
- * Creates a definition entity name resolver.
- * @param entityNameResolver - The entity name resolver.
- * @returns The definition entity name resolver.
+ * 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 createDefinitionEntityNameResolver(entityNameResolver) {
-    return entityNameResolver;
+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;
 }
 /**
- * DefinitionRefBuilder is responsible for constructing reference paths, and registering
- * references and entities as defined in a Zod schema.
+ * Finds the nearest ancestor slot for a given target path.
  *
- * The builder uses a prefix (usually the current parsing path) and context (a
- * shared map for resolving relative references) to build complete reference paths.
- *
- * @template TInput - The type of the input data being parsed.
+ * @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.
  */
-class DefinitionRefBuilder {
-    references;
-    entitiesWithNameResolver;
-    pathPrefix;
-    context;
-    pathMap;
-    data;
-    /**
-     * Creates a new builder instance.
-     * @param pathPrefix - The starting path for all references.
-     * @param context - Shared context including a path map and deserialize flag.
-     * @param data - The data being parsed.
-     */
-    constructor(pathPrefix, context, data) {
-        this.references = [];
-        this.entitiesWithNameResolver = [];
-        this.pathPrefix = pathPrefix;
-        this.context = context;
-        this.pathMap = new Map();
-        this.data = data;
-    }
-    /**
-     * Converts a dot-separated string path into an array of keys.
-     * @param path - A string (e.g. "a.b.0.c") representing the path.
-     * @returns An array of keys (numbers for numeric strings, otherwise strings).
-     */
-    _constructPathWithoutPrefix(path) {
-        if (!path)
-            return [];
-        const pathComponents = path
-            .split('.')
-            .map((key) => (/^[0-9]+$/.test(key) ? Number.parseInt(key, 10) : key));
-        return pathComponents;
-    }
-    /**
-     * Prepends the builder's path prefix to the provided path.
-     * @param path - The dot-separated path string.
-     * @returns The complete reference path as an array.
-     */
-    _constructPath(path) {
-        if (!path)
-            return this.pathPrefix;
-        return [...this.pathPrefix, ...this._constructPathWithoutPrefix(path)];
-    }
-    /**
-     * Constructs a reference path that may be defined directly as a string or indirectly
-     * via a context object. If a context object is provided, the function looks up the
-     * actual path from the builder's context.
-     *
-     * @param path - Either a dot-separated string path or an object with a context key.
-     * @param expectedEntityType - The entity type expected for this context.
-     * @returns The resolved reference path.
-     * @throws If the context cannot be found or its type does not match.
-     */
-    _constructPathWithContext(path, expectedEntityType) {
-        if (typeof path === 'string') {
-            return this._constructPath(path);
-        }
-        // Lookup the context for the given key.
-        const pathContext = this.context.pathMap.get(path.context);
-        if (!pathContext) {
-            throw new Error(`Could not find context for ${path.context} from ${this.pathPrefix.join('.')}`);
-        }
-        if (pathContext.type !== expectedEntityType) {
-            throw new Error(`Attempted to retrieve context for ${path.context} from ${this.pathPrefix.join('.')} expecting ${expectedEntityType.name}, but found ${pathContext.type.name}`);
+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 pathContext.path;
     }
-    /**
-     * Registers a reference based on the provided input definition.
-     *
-     * Flow:
-     * 1. Validate that the parent path is provided if required (and vice versa).
-     * 2. Compute the reference path; if the path is empty, use the entire data.
-     * 3. If the referenced value is null or undefined, skip adding the reference.
-     * 4. Otherwise, add the reference and, if requested, register its context.
-     *
-     * @param reference - The reference definition.
-     * @throws If parent path usage is incorrect.
-     */
-    addReference(reference) {
-        if (!reference.type.parentType && reference.parentPath) {
-            throw new Error(`Parent path does nothing since reference does not have parent`);
-        }
-        if (reference.type.parentType && !reference.parentPath) {
-            throw new Error(`Parent path required if reference type has parent type`);
-        }
-        // Compute the path without prefix once.
-        const refPathWithoutPrefix = this._constructPathWithoutPrefix(reference.path);
-        // If the path is empty, use the entire data; otherwise, retrieve the value.
-        const refValue = refPathWithoutPrefix.length === 0
-            ? this.data
-            : get(this.data, refPathWithoutPrefix);
-        if (refValue === undefined || refValue === null)
-            return;
-        const fullPath = this._constructPath(reference.path);
-        this.references.push({
-            type: reference.type,
-            path: fullPath,
-            parentPath: reference.parentPath &&
-                reference.type.parentType &&
-                this._constructPathWithContext(reference.parentPath, reference.type.parentType),
-            onDelete: reference.onDelete,
-        });
-        // Optionally, add this path to the shared context.
-        if (reference.addContext) {
-            this._addPathToContext(fullPath, reference.type, reference.addContext);
+    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 },
+        ]);
     }
-    /**
-     * Registers an entity based on the provided definition.
-     *
-     * Flow:
-     * 1. Validate that not both a name and a name reference path are provided.
-     * 2. Compute the full entity path.
-     * 3. Resolve the entity ID:
-     *    - Use the provided idPath if available; otherwise, default to appending 'id'
-     *      to the entity path.
-     *    - If no id is found, generate a new one.
-     * 4. Resolve the entity name:
-     *    - Use the provided resolveName if available; otherwise, default to using the
-     *      name path.
-     * 5. Register the entity in either the direct entities list or the name-ref list.
-     * 6. Optionally, add the entity’s id path to the shared context.
-     *
-     * @param entity - The entity definition.
-     * @throws If both name and nameRefPath are provided or if no name is resolved.
-     */
-    addEntity(entity) {
-        // Build the full path for the entity.
-        const path = this._constructPath(entity.path);
-        // Resolve the id path: if provided use it; otherwise, assume the id is at "entity.path.id"
-        const idPath = entity.idPath
-            ? this._constructPathWithoutPrefix(entity.idPath)
-            : [...this._constructPathWithoutPrefix(entity.path), 'id'];
-        const id = get(this.data, idPath);
-        if (!id) {
-            throw new Error(`No id found for entity ${entity.type.name}`);
-        }
-        if (!entity.type.isId(id)) {
-            throw new Error(`Invalid id: ${id} for entity ${entity.type.name}`);
-        }
-        // Resolve the name: if getNameResolver is provided, use it to build the name resolver; otherwise,
-        // use the default name resolver.
-        const getNameResolver = entity.getNameResolver ??
-            ((value) => get(value, 'name'));
-        const nameResolver = getNameResolver(stripRefMarkers(this.data));
-        if (!nameResolver) {
-            throw new Error(`No name resolver found for entity ${entity.type.name} at ${path.join('.')}`);
+    // Collect entity provides
+    for (const entity of entities) {
+        if (entity.provides) {
+            registerSlot(entity.provides, [...entity.path, ...entity.idPath]);
         }
-        // Base entity definition shared between regular entities and those with a name reference.
-        const entityBase = {
-            id,
-            type: entity.type,
-            path,
-            idPath: [...this.pathPrefix, ...idPath],
-            parentPath: entity.parentPath &&
-                entity.type.parentType &&
-                this._constructPathWithContext(entity.parentPath, entity.type.parentType),
-        };
-        this.entitiesWithNameResolver.push({
-            ...entityBase,
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- needed to allow more specific generic typed to be put in here
-            nameResolver: typeof nameResolver === 'string'
-                ? { resolveName: () => nameResolver }
-                : nameResolver,
-        });
-        // Optionally add the id path to the context.
-        if (entity.addContext) {
-            this._addPathToContext([...this.pathPrefix, ...idPath], entity.type, entity.addContext);
-        }
-    }
-    /**
-     * Registers a given path into the builder's context map.
-     * @param path - The full reference path.
-     * @param type - The entity type associated with the path.
-     * @param context - A unique key to identify this context.
-     * @throws If the context key is already registered.
-     */
-    _addPathToContext(path, type, context) {
-        // For now, allow overriding contexts to maintain compatibility
-        this.pathMap.set(context, { path, type });
-        // Also register in the shared context for other builders to access
-        this.context.pathMap.set(context, { path, type });
     }
-    /**
-     * Convenience method that builds a full path from a dot-separated string and
-     * adds it to the context.
-     * @param path - The dot-separated string path.
-     * @param type - The entity type.
-     * @param context - The context key.
-     */
-    addPathToContext(path, type, context) {
-        this._addPathToContext(this._constructPath(path), type, context);
+    // Collect reference provides
+    for (const reference of references) {
+        if (reference.provides) {
+            registerSlot(reference.provides, reference.path);
+        }
     }
+    return resolvedSlotsByType;
 }
 
-function extractDefinitionRefsRecursive(value, context, path) {
-    const builder = new DefinitionRefBuilder(path, context.context, value);
-    if (value instanceof DefinitionReferenceMarker) {
-        builder.addReference(value.reference);
-        context.references.push(...builder.references);
-        context.entitiesWithNameResolver.push(...builder.entitiesWithNameResolver);
-        return value.value;
-    }
-    if (typeof value === 'object' &&
-        value !== null &&
-        REF_ANNOTATIONS_MARKER_SYMBOL in value) {
-        const annotations = value[REF_ANNOTATIONS_MARKER_SYMBOL];
-        for (const entity of annotations.entities) {
-            builder.addEntity(entity);
-        }
-        for (const reference of annotations.references) {
-            builder.addReference(reference);
-        }
-        for (const pathInfo of annotations.contextPaths) {
-            builder.addPathToContext(pathInfo.path, pathInfo.type, pathInfo.context);
+/**
+ * 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}`);
         }
-        context.references.push(...builder.references);
-        context.entitiesWithNameResolver.push(...builder.entitiesWithNameResolver);
-        // Remove the marker symbol and process the clean object
-        const { [REF_ANNOTATIONS_MARKER_SYMBOL]: _, ...cleanValue } = value;
-        // Process the clean object recursively
-        return Object.fromEntries(Object.entries(cleanValue).map(([key, childValue]) => [
-            key,
-            extractDefinitionRefsRecursive(childValue, context, [...path, key]),
-        ]));
-    }
-    // Run recursively for arrays first (arrays are also objects)
-    if (Array.isArray(value)) {
-        return value.map((element, i) => extractDefinitionRefsRecursive(element, context, [...path, i]));
-    }
-    // Run recursively for regular objects
-    if (typeof value === 'object' && value !== null) {
-        return Object.fromEntries(Object.entries(value).map(([key, childValue]) => [
-            key,
-            extractDefinitionRefsRecursive(childValue, context, [...path, key]),
-        ]));
+        return resolvedSlot.resolvedPath;
     }
-    // Return primitive values as-is
-    return value;
-}
-function extractDefinitionRefs(value) {
-    const refContext = {
-        context: {
-            pathMap: new Map(),
-        },
-        references: [],
-        entitiesWithNameResolver: [],
-    };
-    const cleanData = extractDefinitionRefsRecursive(value, refContext, []);
-    // Simple sanity check to make sure we don't have duplicate IDs
+    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 refContext.entitiesWithNameResolver) {
+    for (const entity of collected.entities) {
         if (idSet.has(entity.id)) {
             throw new Error(`Duplicate ID found: ${entity.id}`);
         }
@@ -2150,8 +2067,8 @@ function extractDefinitionRefs(value) {
     }
     return {
         data: cleanData,
-        references: refContext.references,
-        entitiesWithNameResolver: refContext.entitiesWithNameResolver,
+        references,
+        entitiesWithNameResolver,
     };
 }
 
@@ -2170,6 +2087,9 @@ function resolveZodRefPayloadNames(payload, { skipReferenceNameResolution = fals
     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()
@@ -2191,13 +2111,21 @@ function resolveZodRefPayloadNames(payload, { skipReferenceNameResolution = fals
     }
     for (const id of orderedEntities) {
         const { nameResolver, ...rest } = entitiesById[id];
-        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),
-        });
+        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()],
@@ -2221,10 +2149,8 @@ function parseSchemaWithTransformedReferences(schemaCreator, input, schemaCreato
         transformReferences: true,
     });
     const schema = schemaCreator(schemaContext);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- using the type T which can be any zod schema
     const value = schema.parse(input);
     const refPayload = extractDefinitionRefs(value);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- using the type T which can be any zod schema
     return resolveZodRefPayloadNames(refPayload, options);
 }
 
@@ -2258,6 +2184,9 @@ function deserializeSchemaWithTransformedReferences(schemaCreator, input, option
  */
 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);
@@ -2419,6 +2348,9 @@ function fixRefDeletions(schemaCreator, value, schemaCreatorOptions) {
 
 function serializeSchemaFromRefPayload(payload) {
     const { references, entities, data } = payload;
+    if (typeof data !== 'object' || data === null) {
+        throw new TypeError('Data is not an object');
+    }
     const entitiesById = new Map(entities.map((e) => [e.id, e]));
     return produce((draftData) => {
         for (const reference of references) {
@@ -2433,7 +2365,6 @@ function serializeSchemaFromRefPayload(payload) {
 }
 function serializeSchema(schemaCreator, value, schemaCreatorOptions) {
     const payload = parseSchemaWithTransformedReferences(schemaCreator, value, schemaCreatorOptions);
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- typed as def.InferOutput<T>
     return serializeSchemaFromRefPayload(payload);
 }
 
@@ -2450,121 +2381,122 @@ const SCALAR_FIELD_TYPES = [
     'enum',
 ];
 
-const {z: z$o} = await importShared('zod');
+const {z: z$p} = await importShared('zod');
 
 const VALIDATORS = {
-    PASCAL_CASE_STRING: z$o
+    PASCAL_CASE_STRING: z$p
         .string()
         .regex(/^[A-Z][a-zA-Z0-9]*$/, "Should be PascalCase, e.g. 'MyModel'"),
-    CAMEL_CASE_STRING: z$o
+    CAMEL_CASE_STRING: z$p
         .string()
         .regex(/^[a-z][a-zA-Z0-9]*$/, "Should be camelCase, e.g. 'myField'"),
-    CONSTANT_CASE_STRING: z$o
+    CONSTANT_CASE_STRING: z$p
         .string()
         .regex(/^[A-Z][A-Z0-9_]*$/, "Should be CONSTANT_CASE, e.g. 'MY_CONSTANT'"),
-    OPTIONAL_CONSTANT_CASE_STRING: z$o
+    OPTIONAL_CONSTANT_CASE_STRING: z$p
         .string()
         .regex(/^[A-Z][A-Z0-9_]*$/, "Should be CONSTANT_CASE, e.g. 'MY_CONSTANT'")
-        .or(z$o.literal(''))
+        .or(z$p.literal(''))
         .optional(),
 };
 
-const {z: z$n} = await importShared('zod');
-const createRoleArray = definitionSchema((ctx) => ctx.withDefault(z$n.array(ctx.withRef({
+const {z: z$o} = await importShared('zod');
+const createRoleArray = definitionSchema((ctx) => ctx.withDefault(z$o.array(ctx.withRef({
     type: authRoleEntityType,
     onDelete: 'DELETE',
 })), []));
-const createModelGraphqlSchema = definitionSchema((ctx) => z$n.object({
-    objectType: ctx.withDefault(z$n.object({
-        enabled: ctx.withDefault(z$n.boolean(), false),
-        fields: ctx.withDefault(z$n.array(ctx.withRef({
+const createModelGraphqlSchema = definitionSchemaWithSlots({
+    modelSlot: modelEntityType,
+}, (ctx, { modelSlot }) => z$o.object({
+    objectType: ctx.withDefault(z$o.object({
+        enabled: ctx.withDefault(z$o.boolean(), false),
+        fields: ctx.withDefault(z$o.array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
-            parentPath: { context: 'model' },
+            parentSlot: modelSlot,
         })), []),
-        localRelations: ctx.withDefault(z$n.array(ctx.withRef({
+        localRelations: ctx.withDefault(z$o.array(ctx.withRef({
             type: modelLocalRelationEntityType,
             onDelete: 'DELETE',
-            parentPath: { context: 'model' },
+            parentSlot: modelSlot,
         })), []),
-        foreignRelations: ctx.withDefault(z$n.array(ctx.withRef({
+        foreignRelations: ctx.withDefault(z$o.array(ctx.withRef({
             type: modelForeignRelationEntityType,
             onDelete: 'DELETE',
-            parentPath: { context: 'model' },
+            parentSlot: modelSlot,
         })), []),
     }), {}),
-    queries: ctx.withDefault(z$n.object({
-        get: ctx.withDefault(z$n.object({
-            enabled: ctx.withDefault(z$n.boolean(), false),
+    queries: ctx.withDefault(z$o.object({
+        get: ctx.withDefault(z$o.object({
+            enabled: ctx.withDefault(z$o.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        list: ctx.withDefault(z$n.object({
-            enabled: ctx.withDefault(z$n.boolean(), false),
+        list: ctx.withDefault(z$o.object({
+            enabled: ctx.withDefault(z$o.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
     }), {}),
-    mutations: ctx.withDefault(z$n.object({
-        create: ctx.withDefault(z$n.object({
-            enabled: ctx.withDefault(z$n.boolean(), false),
+    mutations: ctx.withDefault(z$o.object({
+        create: ctx.withDefault(z$o.object({
+            enabled: ctx.withDefault(z$o.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        update: ctx.withDefault(z$n.object({
-            enabled: ctx.withDefault(z$n.boolean(), false),
+        update: ctx.withDefault(z$o.object({
+            enabled: ctx.withDefault(z$o.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        delete: ctx.withDefault(z$n.object({
-            enabled: ctx.withDefault(z$n.boolean(), false),
+        delete: ctx.withDefault(z$o.object({
+            enabled: ctx.withDefault(z$o.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
     }), {}),
 }));
 
-const {z: z$m} = await importShared('zod');
+const {z: z$n} = await importShared('zod');
 
 const baseTransformerFields = {
-    id: z$m.string(),
-    type: z$m.string().min(1),
+    id: z$n.string(),
+    type: z$n.string().min(1),
 };
-const baseTransformerSchema = z$m.object(baseTransformerFields);
+const baseTransformerSchema = z$n.looseObject(baseTransformerFields);
 function createModelTransformerType(payload) {
     return payload;
 }
 
-const {z: z$l} = await importShared('zod');
-const createEmbeddedRelationTransformerSchema = definitionSchema((ctx) => ctx.withRefBuilder(ctx.withEnt(z$l.object({
+const {z: z$m} = await importShared('zod');
+const createEmbeddedRelationTransformerSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.refContext({ embeddedModelSlot: modelEntityType }, ({ embeddedModelSlot }) => ctx.withEnt(z$m.object({
     ...baseTransformerFields,
     foreignRelationRef: ctx.withRef({
         type: modelForeignRelationEntityType,
         onDelete: 'DELETE_PARENT',
-        parentPath: { context: 'model' },
+        parentSlot: modelSlot,
     }),
-    type: z$l.literal('embeddedRelation'),
-    embeddedFieldNames: z$l.array(ctx.withRef({
+    type: z$m.literal('embeddedRelation'),
+    embeddedFieldNames: z$m.array(ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
-        parentPath: { context: 'embeddedModel' },
+        parentSlot: embeddedModelSlot,
     })),
-    embeddedTransformerNames: z$l
+    embeddedTransformerNames: z$m
         .array(ctx.withRef({
         type: modelTransformerEntityType,
         onDelete: 'RESTRICT',
-        parentPath: { context: 'embeddedModel' },
+        parentSlot: embeddedModelSlot,
     }))
         .optional(),
     modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
+        provides: embeddedModelSlot,
     }),
 }), {
     type: modelTransformerEntityType,
-    parentPath: { context: 'model' },
+    parentSlot: modelSlot,
     getNameResolver: (entity) => createDefinitionEntityNameResolver({
         idsToResolve: { foreignRelation: entity.foreignRelationRef },
         resolveName: (entityNames) => entityNames.foreignRelation,
     }),
-}), (builder) => {
-    builder.addPathToContext('modelRef', modelEntityType, 'embeddedModel');
-}));
+})));
 const BUILT_IN_TRANSFORMERS = [
     createModelTransformerType({
         name: 'embeddedRelation',
@@ -2581,7 +2513,7 @@ function createModelTransformerImplementation() {
     }
     return {
         registerModelTransformer(transformer) {
-            if (transformers[transformer.name]) {
+            if (transformer.name in transformers) {
                 throw new Error(`Model transformer with name ${transformer.name} is already registered`);
             }
             transformers[transformer.name] =
@@ -2591,11 +2523,10 @@ function createModelTransformerImplementation() {
             return transformers;
         },
         getModelTransformer(name) {
-            const transformer = transformers[name];
-            if (!transformer) {
+            if (!(name in transformers)) {
                 throw new Error(`Unable to find transformer with name ${name}`);
             }
-            return transformer;
+            return transformers[name];
         },
     };
 }
@@ -2606,51 +2537,46 @@ const modelTransformerSpec = createPluginSpec('core/model-transformer', {
     defaultInitializer: createModelTransformerImplementation,
 });
 
-const createTransformerSchema = definitionSchema((ctx) => baseTransformerSchema.passthrough().transform((data, parseCtx) => {
-    const { type } = data;
-    const transformer = ctx.plugins
+const z$l = await importShared('zod');
+const createTransformerSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => {
+    const transformers = ctx.plugins
         .getPluginSpec(modelTransformerSpec)
-        .getModelTransformer(type);
-    return transformer
-        .createSchema(ctx)
-        .and(baseTransformerSchema)
-        .parse(data, {
-        path: parseCtx.path,
-    });
-}));
+        .getModelTransformers();
+    return z$l.discriminatedUnion('type', Object.values(transformers).map((transformer) => transformer.createSchema(ctx, slots)));
+});
 
 const {z: z$k} = await importShared('zod');
-const createEnumValueSchema = definitionSchema((ctx) => ctx.withEnt(z$k.object({
+const createEnumValueSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => ctx.withEnt(z$k.object({
     id: z$k.string(),
     name: z$k.string().min(1),
     friendlyName: z$k.string().min(1),
 }), {
     type: modelEnumValueEntityType,
-    parentPath: { context: 'enum' },
+    parentSlot: enumSlot,
 }));
-const createEnumBaseSchema = definitionSchema((ctx) => z$k.object({
+const createEnumBaseSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => z$k.object({
     id: z$k.string(),
     name: z$k.string().min(1),
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    values: z$k.array(createEnumValueSchema(ctx)),
+    values: z$k.array(createEnumValueSchema(ctx, { enumSlot })),
     isExposed: z$k.boolean(),
 }));
-const createEnumSchema = definitionSchema((ctx) => ctx.withEnt(createEnumBaseSchema(ctx), {
+const createEnumSchema = definitionSchema((ctx) => ctx.refContext({ enumSlot: modelEnumEntityType }, ({ enumSlot }) => ctx.withEnt(createEnumBaseSchema(ctx, { enumSlot }), {
     type: modelEnumEntityType,
-    addContext: 'enum',
-}));
+    provides: enumSlot,
+})));
 
 const {z: z$j} = await importShared('zod');
-const createModelScalarFieldSchema = definitionSchema((ctx) => ctx
+const createModelScalarFieldSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx
     .withEnt(z$j.object({
     id: z$j.string(),
     name: VALIDATORS.CAMEL_CASE_STRING,
     type: z$j.enum(SCALAR_FIELD_TYPES),
     isOptional: z$j.boolean().default(false),
-    options: ctx.withRefBuilder(z$j
+    options: ctx.refContext({ enumSlot: modelEnumEntityType }, ({ enumSlot }) => z$j
         .object({
         // string options
         default: z$j.string().default(''),
@@ -2664,25 +2590,25 @@ const createModelScalarFieldSchema = definitionSchema((ctx) => ctx
             .withRef({
             type: modelEnumEntityType,
             onDelete: 'RESTRICT',
+            provides: enumSlot,
+        })
+            .optional(),
+        defaultEnumValueRef: ctx
+            .withRef({
+            type: modelEnumValueEntityType,
+            onDelete: 'RESTRICT',
+            parentSlot: enumSlot,
         })
             .optional(),
-        defaultEnumValueRef: z$j.string().optional(),
     })
         .transform((val) => ({
         ...val,
         ...(val.enumRef ? {} : { defaultEnumValueRef: undefined }),
     }))
-        .default({ default: '' }), (builder) => {
-        builder.addReference({
-            type: modelEnumValueEntityType,
-            onDelete: 'RESTRICT',
-            path: 'defaultEnumValueRef',
-            parentPath: 'enumRef',
-        });
-    }),
+        .prefault({})),
 }), {
     type: modelScalarFieldEntityType,
-    parentPath: { context: 'model' },
+    parentSlot: modelSlot,
 })
     .superRefine((arg, ctx) => {
     // check default values
@@ -2718,7 +2644,7 @@ const REFERENTIAL_ACTIONS = [
     'SetNull',
     'SetDefault',
 ];
-const createModelRelationFieldSchema = definitionSchema((ctx) => ctx.withRefBuilder(z$j.object({
+const createModelRelationFieldSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.refContext({ foreignModelSlot: modelEntityType }, ({ foreignModelSlot }) => ctx.withEnt(ctx.withEnt(z$j.object({
     id: z$j.string(),
     foreignId: z$j
         .string()
@@ -2728,48 +2654,43 @@ const createModelRelationFieldSchema = definitionSchema((ctx) => ctx.withRefBuil
         localRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
-            parentPath: { context: 'model' },
+            parentSlot: modelSlot,
         }),
         foreignRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
-            parentPath: { context: 'foreignModel' },
+            parentSlot: foreignModelSlot,
         }),
     })),
-    modelRef: z$j.string().min(1),
+    modelRef: ctx.withRef({
+        type: modelEntityType,
+        onDelete: 'RESTRICT',
+        provides: foreignModelSlot,
+    }),
     foreignRelationName: VALIDATORS.CAMEL_CASE_STRING,
     onDelete: z$j.enum(REFERENTIAL_ACTIONS).default('Cascade'),
     onUpdate: z$j.enum(REFERENTIAL_ACTIONS).default('Restrict'),
-}), (builder) => {
-    builder.addReference({
-        type: modelEntityType,
-        onDelete: 'RESTRICT',
-        addContext: 'foreignModel',
-        path: 'modelRef',
-    });
-    builder.addEntity({
-        type: modelLocalRelationEntityType,
-        parentPath: { context: 'model' },
-    });
-    builder.addEntity({
-        type: modelForeignRelationEntityType,
-        idPath: 'foreignId',
-        getNameResolver: (entity) => entity.foreignRelationName,
-        parentPath: 'modelRef',
-    });
-}));
-const createModelUniqueConstraintSchema = definitionSchema((ctx) => ctx.withEnt(z$j.object({
+}), {
+    type: modelLocalRelationEntityType,
+    parentSlot: modelSlot,
+}), {
+    type: modelForeignRelationEntityType,
+    idPath: ['foreignId'],
+    getNameResolver: (entity) => entity.foreignRelationName,
+    parentSlot: foreignModelSlot,
+})));
+const createModelUniqueConstraintSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.withEnt(z$j.object({
     id: z$j.string(),
     fields: z$j.array(z$j.object({
         fieldRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
-            parentPath: { context: 'model' },
+            parentSlot: modelSlot,
         }),
     })),
 }), {
     type: modelUniqueConstraintEntityType,
-    parentPath: { context: 'model' },
+    parentSlot: modelSlot,
     getNameResolver(value) {
         return createDefinitionEntityNameResolver({
             idsToResolve: { fields: value.fields.map((f) => f.fieldRef) },
@@ -2777,7 +2698,7 @@ const createModelUniqueConstraintSchema = definitionSchema((ctx) => ctx.withEnt(
         });
     },
 }));
-const createModelServiceSchema = definitionSchema((ctx) => z$j.object({
+const createModelServiceSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => z$j.object({
     create: z$j
         .object({
         enabled: z$j.boolean().default(false),
@@ -2785,14 +2706,14 @@ const createModelServiceSchema = definitionSchema((ctx) => z$j.object({
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
-            parentPath: { context: 'model' },
+            parentSlot: modelSlot,
         }))
             .optional(),
         transformerNames: z$j
             .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
-            parentPath: { context: 'model' },
+            parentSlot: modelSlot,
         }))
             .optional(),
     })
@@ -2804,14 +2725,14 @@ const createModelServiceSchema = definitionSchema((ctx) => z$j.object({
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
-            parentPath: { context: 'model' },
+            parentSlot: modelSlot,
         }))
             .optional(),
         transformerNames: z$j
             .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
-            parentPath: { context: 'model' },
+            parentSlot: modelSlot,
         }))
             .optional(),
     })
@@ -2823,9 +2744,11 @@ const createModelServiceSchema = definitionSchema((ctx) => z$j.object({
         .default({
         enabled: false,
     }),
-    transformers: z$j.array(createTransformerSchema(ctx)).default([]),
+    transformers: z$j
+        .array(createTransformerSchema(ctx, { modelSlot }))
+        .default([]),
 }));
-const createModelBaseSchema = definitionSchema((ctx) => z$j.object({
+const createModelBaseSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => z$j.object({
     id: z$j.string(),
     name: VALIDATORS.PASCAL_CASE_STRING,
     featureRef: ctx.withRef({
@@ -2833,31 +2756,33 @@ const createModelBaseSchema = definitionSchema((ctx) => z$j.object({
         onDelete: 'RESTRICT',
     }),
     model: z$j.object({
-        fields: z$j.array(createModelScalarFieldSchema(ctx)),
-        relations: z$j.array(createModelRelationFieldSchema(ctx)).optional(),
+        fields: z$j.array(createModelScalarFieldSchema(ctx, slots)),
+        relations: z$j
+            .array(createModelRelationFieldSchema(ctx, slots))
+            .optional(),
         primaryKeyFieldRefs: z$j
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
-            parentPath: { context: 'model' },
+            parentSlot: slots.modelSlot,
         }))
             .min(1),
         uniqueConstraints: z$j
-            .array(createModelUniqueConstraintSchema(ctx))
+            .array(createModelUniqueConstraintSchema(ctx, slots))
             .optional(),
     }),
-    service: createModelServiceSchema(ctx).default({
+    service: createModelServiceSchema(ctx, slots).default({
         create: { enabled: false },
         update: { enabled: false },
         delete: { enabled: false },
         transformers: [],
     }),
-    graphql: ctx.withDefault(createModelGraphqlSchema(ctx).optional(), {}),
+    graphql: ctx.withDefault(createModelGraphqlSchema(ctx, slots).optional(), {}),
 }));
-const createModelSchema = definitionSchema((ctx) => ctx.withEnt(createModelBaseSchema(ctx), {
+const createModelSchema = definitionSchema((ctx) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => ctx.withEnt(createModelBaseSchema(ctx, { modelSlot }), {
     type: modelEntityType,
-    addContext: 'model',
-}));
+    provides: modelSlot,
+})));
 
 const adminSectionEntityType = createEntityType('admin-section', {
     parentType: appEntityType,
@@ -2879,7 +2804,7 @@ const createBaseAdminSectionValidators = definitionSchema((ctx) => z$i.object({
 }));
 
 const {z: z$h} = await importShared('zod');
-const baseAdminCrudActionSchema = z$h.object({
+const baseAdminCrudActionSchema = z$h.looseObject({
     id: z$h
         .string()
         .min(1)
@@ -2942,29 +2867,20 @@ const adminCrudActionSpec = createPluginSpec('core/admin-crud-action', {
     defaultInitializer: createAdminCrudActionImplementation,
 });
 
-const createAdminCrudActionSchema = definitionSchema((ctx) => ctx
-    .withEnt(baseAdminCrudActionSchema.passthrough(), {
-    type: adminCrudActionEntityType,
-    parentPath: {
-        context: 'admin-section',
-    },
-    getNameResolver: (value) => value.type,
-})
-    .transform((data, parseCtx) => {
-    const { type } = data;
-    const crudAction = ctx.plugins
+const createAdminCrudActionSchema = definitionSchema((ctx) => {
+    const adminCrudActions = ctx.plugins
         .getPluginSpec(adminCrudActionSpec)
-        .getAdminCrudAction(type);
-    return crudAction
-        .createSchema(ctx)
-        .and(baseAdminCrudActionSchema)
-        .parse(data, {
-        path: parseCtx.path,
+        .getAdminCrudActions();
+    return baseAdminCrudActionSchema.transform((data) => {
+        const actionDef = adminCrudActions.get(data.type);
+        if (!actionDef)
+            return data;
+        return actionDef.createSchema(ctx).parse(data);
     });
-}));
+});
 
 const {z: z$f} = await importShared('zod');
-const baseAdminCrudColumnSchema = z$f.object({
+const baseAdminCrudColumnSchema = z$f.looseObject({
     id: z$f
         .string()
         .min(1)
@@ -2981,12 +2897,12 @@ const adminCrudColumnEntityType = createEntityType('admin-crud-column', {
 
 const {z: z$e} = await importShared('zod');
 // Text Column
-const createAdminCrudTextColumnSchema = definitionSchema((ctx) => baseAdminCrudColumnSchema.extend({
+const createAdminCrudTextColumnSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => baseAdminCrudColumnSchema.extend({
     type: z$e.literal('text'),
     modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
-        parentPath: { context: 'model' },
+        parentSlot: modelSlot,
     }),
 }));
 const adminCrudTextColumnType = createAdminCrudColumnType({
@@ -2994,12 +2910,12 @@ const adminCrudTextColumnType = createAdminCrudColumnType({
     createSchema: createAdminCrudTextColumnSchema,
 });
 // Foreign Column
-const createAdminCrudForeignColumnSchema = definitionSchema((ctx) => baseAdminCrudColumnSchema.extend({
+const createAdminCrudForeignColumnSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => baseAdminCrudColumnSchema.extend({
     type: z$e.literal('foreign'),
     localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
-        parentPath: { context: 'model' },
+        parentSlot: modelSlot,
     }),
     labelExpression: z$e.string().min(1),
     valueExpression: z$e.string().min(1),
@@ -3041,29 +2957,20 @@ const adminCrudColumnSpec = createPluginSpec('core/admin-crud-column', {
     defaultInitializer: createAdminCrudColumnImplementation,
 });
 
-const createAdminCrudColumnSchema = definitionSchema((ctx) => ctx
-    .withEnt(baseAdminCrudColumnSchema.passthrough(), {
-    type: adminCrudColumnEntityType,
-    parentPath: {
-        context: 'admin-section',
-    },
-    getNameResolver: (value) => value.type,
-})
-    .transform((data, parseCtx) => {
-    const { type } = data;
-    const crudColumn = ctx.plugins
+const createAdminCrudColumnSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => {
+    const adminCrudColumns = ctx.plugins
         .getPluginSpec(adminCrudColumnSpec)
-        .getAdminCrudColumn(type);
-    return crudColumn
-        .createSchema(ctx)
-        .and(baseAdminCrudColumnSchema)
-        .parse(data, {
-        path: parseCtx.path,
+        .getAdminCrudColumns();
+    return baseAdminCrudColumnSchema.transform((data) => {
+        const columnDef = adminCrudColumns.get(data.type);
+        if (!columnDef)
+            return data;
+        return columnDef.createSchema(ctx, slots).parse(data);
     });
-}));
+});
 
 const {z: z$d} = await importShared('zod');
-const baseAdminCrudInputSchema = z$d.object({
+const baseAdminCrudInputSchema = z$d.looseObject({
     id: z$d
         .string()
         .min(1)
@@ -3082,13 +2989,13 @@ const adminCrudInputEntityType = createEntityType('admin-crud-input', {
 });
 
 const {z: z$c} = await importShared('zod');
-const createAdminCrudTextInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
+const createAdminCrudTextInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot }) => baseAdminCrudInputSchema.extend({
     type: z$c.literal('text'),
     label: z$c.string().min(1),
     modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
-        parentPath: { context: 'model' },
+        parentSlot: modelSlot,
     }),
     validation: z$c.string().optional(),
 }));
@@ -3096,13 +3003,13 @@ const adminCrudTextInputType = createAdminCrudInputType({
     name: 'text',
     createSchema: createAdminCrudTextInputSchema,
 });
-const createAdminCrudForeignInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
+const createAdminCrudForeignInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot }) => baseAdminCrudInputSchema.extend({
     type: z$c.literal('foreign'),
     label: z$c.string().min(1),
     localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
-        parentPath: { context: 'model' },
+        parentSlot: modelSlot,
     }),
     labelExpression: z$c.string().min(1),
     valueExpression: z$c.string().min(1),
@@ -3113,30 +3020,30 @@ const adminCrudForeignInputType = createAdminCrudInputType({
     name: 'foreign',
     createSchema: createAdminCrudForeignInputSchema,
 });
-const createAdminCrudEnumInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
+const createAdminCrudEnumInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot }) => baseAdminCrudInputSchema.extend({
     type: z$c.literal('enum'),
     label: z$c.string().min(1),
     modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
-        parentPath: { context: 'model' },
+        parentSlot: modelSlot,
     }),
 }));
 const adminCrudEnumInputType = createAdminCrudInputType({
     name: 'enum',
     createSchema: createAdminCrudEnumInputSchema,
 });
-const createAdminCrudEmbeddedInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
+const createAdminCrudEmbeddedInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => baseAdminCrudInputSchema.extend({
     type: z$c.literal('embedded'),
     label: z$c.string().min(1),
     modelRelationRef: ctx.withRef({
         type: modelForeignRelationEntityType,
         onDelete: 'RESTRICT',
-        parentPath: { context: 'model' },
+        parentSlot: modelSlot,
     }),
     embeddedFormRef: ctx.withRef({
         type: adminCrudEmbeddedFormEntityType,
-        parentPath: { context: 'admin-section' },
+        parentSlot: adminSectionSlot,
         onDelete: 'RESTRICT',
     }),
 }));
@@ -3144,17 +3051,17 @@ const adminCrudEmbeddedInputType = createAdminCrudInputType({
     name: 'embedded',
     createSchema: createAdminCrudEmbeddedInputSchema,
 });
-const createAdminCrudEmbeddedLocalInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.extend({
+const createAdminCrudEmbeddedLocalInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => baseAdminCrudInputSchema.extend({
     type: z$c.literal('embeddedLocal'),
     label: z$c.string().min(1),
     localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
-        parentPath: { context: 'model' },
+        parentSlot: modelSlot,
     }),
     embeddedFormRef: ctx.withRef({
         type: adminCrudEmbeddedFormEntityType,
-        parentPath: { context: 'admin-section' },
+        parentSlot: adminSectionSlot,
         onDelete: 'RESTRICT',
     }),
 }));
@@ -3207,121 +3114,115 @@ const adminCrudInputSpec = createPluginSpec('core/admin-crud-input', {
     defaultInitializer: createAdminCrudInputImplementation,
 });
 
-const createAdminCrudInputSchema = definitionSchema((ctx) => ctx
-    .withEnt(baseAdminCrudInputSchema.passthrough(), {
-    type: adminCrudInputEntityType,
-    parentPath: {
-        context: 'admin-section',
-    },
-    getNameResolver: (value) => value.id ?? '',
-})
-    .transform((data, parseCtx) => {
-    const { type } = data;
-    const crudInput = ctx.plugins
+const createAdminCrudInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, slots) => {
+    const adminCrudInputs = ctx.plugins
         .getPluginSpec(adminCrudInputSpec)
-        .getAdminCrudInput(type);
-    return crudInput
-        .createSchema(ctx)
-        .and(baseAdminCrudInputSchema)
-        .parse(data, {
-        path: parseCtx.path,
+        .getAdminCrudInputs();
+    return baseAdminCrudInputSchema.transform((data) => {
+        const inputDef = adminCrudInputs.get(data.type);
+        if (!inputDef)
+            return data;
+        return inputDef.createSchema(ctx, slots).parse(data);
     });
-}));
+});
 
 const {z: z$b} = await importShared('zod');
 // Embedded Crud
-const createAdminCrudEmbeddedObjectSchema = definitionSchema((ctx) => z$b.object({
+const createAdminCrudEmbeddedObjectSchemaInternal = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => z$b.object({
     id: z$b.string().min(1),
     name: z$b.string().min(1),
     modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
+        provides: modelSlot,
     }),
     includeIdField: z$b.boolean().optional(),
     type: z$b.literal('object'),
     form: z$b.object({
-        fields: z$b.array(createAdminCrudInputSchema(ctx)),
+        fields: z$b.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
     }),
 }));
-const createAdminCrudEmbeddedListSchema = definitionSchema((ctx) => z$b.object({
+const createAdminCrudEmbeddedListSchemaInternal = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => z$b.object({
     id: z$b.string().min(1),
     name: z$b.string().min(1),
     modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
+        provides: modelSlot,
     }),
     includeIdField: z$b.boolean().optional(),
     type: z$b.literal('list'),
     table: z$b.object({
-        columns: z$b.array(createAdminCrudColumnSchema(ctx)),
+        columns: z$b.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
     }),
     form: z$b.object({
-        fields: z$b.array(createAdminCrudInputSchema(ctx)),
+        fields: z$b.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
     }),
 }));
-const createAdminCrudEmbeddedFormSchema = definitionSchema((ctx) => ctx.withRefBuilder(z$b.discriminatedUnion('type', [
-    createAdminCrudEmbeddedObjectSchema(ctx),
-    createAdminCrudEmbeddedListSchema(ctx),
-]), (builder) => {
-    builder.addEntity({
-        type: adminCrudEmbeddedFormEntityType,
-        parentPath: { context: 'admin-section' },
-    });
-    builder.addPathToContext('modelRef', modelEntityType, 'model');
-}));
+const createAdminCrudEmbeddedFormSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => ctx.withEnt(z$b.discriminatedUnion('type', [
+    createAdminCrudEmbeddedObjectSchemaInternal(ctx, {
+        modelSlot,
+        adminSectionSlot,
+    }),
+    createAdminCrudEmbeddedListSchemaInternal(ctx, {
+        modelSlot,
+        adminSectionSlot,
+    }),
+]), {
+    type: adminCrudEmbeddedFormEntityType,
+    parentSlot: adminSectionSlot,
+})));
 // Admin Section
-const createAdminCrudSectionSchema = definitionSchema((ctx) => ctx.withRefBuilder(createBaseAdminSectionValidators(ctx).and(z$b.object({
+const createAdminCrudSectionSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => createBaseAdminSectionValidators(ctx).and(z$b.object({
     type: z$b.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',
-        parentPath: {
-            context: 'model',
-        },
+        parentSlot: modelSlot,
     }),
     disableCreate: ctx.withDefault(z$b.boolean(), false),
     table: z$b.object({
-        columns: z$b.array(createAdminCrudColumnSchema(ctx)),
+        columns: z$b.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
         actions: ctx.withDefault(z$b.array(createAdminCrudActionSchema(ctx)), [
             { type: 'edit', position: 'inline' },
             { type: 'delete', position: 'dropdown' },
         ]),
     }),
     form: z$b.object({
-        fields: z$b.array(createAdminCrudInputSchema(ctx)),
+        fields: z$b.array(createAdminCrudInputSchema(ctx, {
+            modelSlot,
+            adminSectionSlot,
+        })),
     }),
     embeddedForms: z$b
-        .array(createAdminCrudEmbeddedFormSchema(ctx))
+        .array(createAdminCrudEmbeddedFormSchema(ctx, { adminSectionSlot }))
         .optional(),
-})), (builder) => {
-    builder.addPathToContext('modelRef', modelEntityType, 'model');
-}));
+}))));
 
 const {z: z$a} = await importShared('zod');
-const createWebAdminSectionSchema = definitionSchema((ctx) => ctx.withRefBuilder(createAdminCrudSectionSchema(ctx), (builder) => {
-    builder.addEntity({
-        type: adminSectionEntityType,
-        parentPath: { context: 'app' },
-        addContext: 'admin-section',
-    });
-}));
-const createAdminAppSchema = definitionSchema((ctx) => ctx.withDefault(z$a.object({
+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$a.object({
     enabled: z$a.boolean(),
     pathPrefix: z$a.string().default('/admin'),
     allowedRoles: ctx.withDefault(z$a.array(ctx.withRef({
         type: authRoleEntityType,
         onDelete: 'DELETE',
     })), []),
-    sections: ctx.withDefault(z$a.array(createWebAdminSectionSchema(ctx)), []),
+    sections: ctx.withDefault(z$a.array(createWebAdminSectionSchema(ctx, { appSlot })), []),
 }), { enabled: false, pathPrefix: '/admin' }));
 
 const {z: z$9} = await importShared('zod');
-const createWebAppSchema = definitionSchema((ctx) => z$9.object({
+const createWebAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => z$9.object({
     ...baseAppValidators,
     type: z$9.literal('web'),
     includeAuth: ctx.withDefault(z$9.boolean(), false),
@@ -3329,7 +3230,7 @@ const createWebAppSchema = definitionSchema((ctx) => z$9.object({
     description: z$9.string().default(''),
     includeUploadComponents: ctx.withDefault(z$9.boolean(), false),
     enableSubscriptions: ctx.withDefault(z$9.boolean(), false),
-    adminApp: createAdminAppSchema(ctx),
+    adminApp: createAdminAppSchema(ctx, { appSlot }),
 }));
 const webAppEntryType = createAppEntryType('web');
 
@@ -3343,23 +3244,20 @@ const basePluginDefinitionSchema = z$8.object({
     configSchemaVersion: z$8.number().optional(),
 });
 const createPluginWithConfigSchema = definitionSchema((ctx) => ctx
-    .withEnt(basePluginDefinitionSchema.passthrough(), {
+    .withEnt(basePluginDefinitionSchema, {
     type: pluginEntityType,
 })
-    .transform((data, parseCtx) => {
+    .transform((data) => {
     const pluginKey = pluginEntityType.keyFromId(data.id);
     const createConfigSchema = ctx.plugins
         .getPluginSpec(pluginConfigSpec)
         .getSchemaCreator(pluginKey);
-    let pluginDefinitionSchema = basePluginDefinitionSchema;
-    if (createConfigSchema) {
-        pluginDefinitionSchema = pluginDefinitionSchema.extend({
-            config: createConfigSchema(ctx),
-        });
-    }
-    return pluginDefinitionSchema.parse(data, {
-        path: parseCtx.path,
-    });
+    if (!createConfigSchema)
+        return data;
+    return {
+        ...data,
+        config: createConfigSchema(ctx).parse(data.config),
+    };
 }));
 const createPluginsSchema = definitionSchema((ctx) => z$8.array(createPluginWithConfigSchema(ctx)));
 
@@ -3530,7 +3428,7 @@ const oklchColor = z$3
  *
  * Maps semantic color keys (e.g. "background", "foreground", "primary") to OKLCH color values.
  */
-const themeColorSchema = z$3.record(z$3.enum(THEME_COLOR_KEYS), oklchColor);
+const themeColorSchema = z$3.record(z$3.enum(THEME_COLOR_KEYS), oklchColor.optional());
 /**
  * Palette configuration schema
  *
@@ -3648,15 +3546,13 @@ const createSettingsSchema = definitionSchema((ctx) => z$2.object({
 }));
 
 const {z: z$1} = await importShared('zod');
-const createAppSchema = definitionSchema((ctx) => ctx.withRefBuilder(z$1.discriminatedUnion('type', [
-    createBackendAppSchema(ctx),
-    createWebAppSchema(ctx),
-]), (builder) => {
-    builder.addEntity({
-        type: appEntityType,
-        addContext: 'app',
-    });
-}));
+const createAppSchema = definitionSchema((ctx) => ctx.refContext({ appSlot: appEntityType }, ({ appSlot }) => ctx.withEnt(z$1.discriminatedUnion('type', [
+    createBackendAppSchema(ctx, { appSlot }),
+    createWebAppSchema(ctx, { appSlot }),
+]), {
+    type: appEntityType,
+    provides: appSlot,
+})));
 const createProjectDefinitionSchema = definitionSchema((ctx) => z$1.object({
     cliVersion: z$1.string().nullish(),
     apps: z$1.array(createAppSchema(ctx)).default([]),
@@ -3724,7 +3620,9 @@ function getModelValidator(modelField) {
         case 'date': {
             return 'string()';
         }
-        case 'int':
+        case 'int': {
+            return 'int()';
+        }
         case 'float': {
             return 'number()';
         }
@@ -3746,12 +3644,6 @@ function getModelFieldValidation(projectDefinition, modelId, fieldId, preProcess
         throw new Error(`Field ${fieldId} not found in model ${model.name}`);
     }
     const nullishSuffix = field.isOptional ? '.nullish()' : '';
-    if (field.type === 'int') {
-        return `z.number().or(z.string()).pipe(z.coerce.number().finite().int())${nullishSuffix}`;
-    }
-    if (field.type === 'float') {
-        return `z.number().or(z.string()).pipe(z.coerce.number().finite())${nullishSuffix}`;
-    }
     const validator = `z.${getModelValidator(field)}${nullishSuffix}`;
     if (!preProcess) {
         return validator;
@@ -3779,75 +3671,6 @@ function getTransformName(definitionContainer, transformer, pluginStore) {
 }
 const ModelTransformerUtils = { getTransformer, getTransformName };
 
-function byKey(projectDefinition, key) {
-    const pluginEntityId = pluginEntityType.idFromKey(key);
-    const plugin = projectDefinition.plugins?.find((m) => m.id === pluginEntityId);
-    return plugin;
-}
-function byKeyOrThrow(projectDefinition, id) {
-    const plugin = byKey(projectDefinition, id);
-    if (!plugin) {
-        throw new Error(`Could not find plugin with ID ${id}`);
-    }
-    return plugin;
-}
-function configByKey(projectDefinition, key) {
-    const def = byKey(projectDefinition, key);
-    return def?.config;
-}
-function configByKeyOrThrow(projectDefinition, key) {
-    const def = byKeyOrThrow(projectDefinition, key);
-    return def.config;
-}
-function setPluginConfig(projectDefinition, plugin, pluginConfig, pluginImplementationStore) {
-    const plugins = projectDefinition.plugins ?? [];
-    const pluginEntityId = pluginEntityType.idFromKey(plugin.key);
-    const pluginConfigService = pluginImplementationStore.getPluginSpec(pluginConfigSpec);
-    const lastMigrationVersion = pluginConfigService.getLastMigrationVersion(plugin.key);
-    projectDefinition.plugins = plugins.some((p) => p.id === pluginEntityId)
-        ? plugins.map((p) => pluginEntityId === p.id ? { ...p, config: pluginConfig } : p)
-        : [
-            ...plugins,
-            {
-                id: pluginEntityId,
-                name: plugin.name,
-                version: plugin.version,
-                packageName: plugin.packageName,
-                config: pluginConfig,
-                configSchemaVersion: lastMigrationVersion,
-            },
-        ];
-}
-/**
- * Disables a plugin and all plugins that it manages recursively.
- *
- * @param projectDefinition The project definition to disable the plugin in
- * @param pluginKey The ID of the plugin to disable
- * @param context The schema parser context to use
- */
-function disablePlugin(projectDefinition, pluginKey, context) {
-    // Get plugin metadata to be disabled
-    const pluginMetadata = getPluginMetadataByKeyOrThrow(context.pluginStore, pluginKey);
-    // Make sure we disable any plugins that are managed by this plugin
-    const managedPlugins = projectDefinition.plugins?.filter((p) => {
-        const managedPlugin = getPluginMetadataByKeyOrThrow(context.pluginStore, pluginEntityType.keyFromId(p.id));
-        return managedPlugin.managedBy === pluginMetadata.fullyQualifiedName;
-    });
-    if (managedPlugins) {
-        for (const p of managedPlugins)
-            disablePlugin(projectDefinition, p.id, context);
-    }
-    projectDefinition.plugins = projectDefinition.plugins?.filter((p) => p.id !== pluginEntityType.idFromKey(pluginKey));
-}
-const PluginUtils = {
-    byKey,
-    byKeyOrThrow,
-    configByKey,
-    setPluginConfig,
-    configByKeyOrThrow,
-    disablePlugin,
-};
-
 const {z} = await importShared('zod');
 const COMMON_SPEC_IMPLEMENTATIONS = [
     pluginConfigSpec,
@@ -3923,6 +3746,7 @@ function createPluginImplementationStoreWithNewPlugins(pluginStore, plugins, pro
                 version: p.version,
                 name: p.name,
                 packageName: p.packageName,
+                config: undefined,
             })),
         ],
     };
@@ -3961,6 +3785,83 @@ function parseProjectDefinitionWithReferences(projectDefinition, context) {
     return { definition, pluginStore: pluginImplementationStore };
 }
 
+function byKey(projectDefinition, key) {
+    const pluginEntityId = pluginEntityType.idFromKey(key);
+    const plugin = projectDefinition.plugins?.find((m) => m.id === pluginEntityId);
+    return plugin;
+}
+function byKeyOrThrow(projectDefinition, id) {
+    const plugin = byKey(projectDefinition, id);
+    if (!plugin) {
+        throw new Error(`Could not find plugin with ID ${id}`);
+    }
+    return plugin;
+}
+function configByKey(projectDefinition, key) {
+    const def = byKey(projectDefinition, key);
+    return def?.config;
+}
+function configByKeyOrThrow(projectDefinition, key) {
+    const def = byKeyOrThrow(projectDefinition, key);
+    return def.config;
+}
+function setPluginConfig(projectDefinition, plugin, pluginConfig, definitionContainer) {
+    const plugins = projectDefinition.plugins ?? [];
+    const pluginEntityId = pluginEntityType.idFromKey(plugin.key);
+    const isNewPlugin = !plugins.some((p) => p.id === pluginEntityId);
+    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 lastMigrationVersion = pluginConfigService.getLastMigrationVersion(plugin.key);
+        projectDefinition.plugins = [
+            ...plugins,
+            {
+                id: pluginEntityId,
+                name: plugin.name,
+                version: plugin.version,
+                packageName: plugin.packageName,
+                config: pluginConfig,
+                configSchemaVersion: lastMigrationVersion,
+            },
+        ];
+    }
+    else {
+        // When updating an existing plugin, just update the config
+        projectDefinition.plugins = plugins.map((p) => pluginEntityId === p.id ? { ...p, config: pluginConfig } : p);
+    }
+}
+/**
+ * Disables a plugin and all plugins that it manages recursively.
+ *
+ * @param projectDefinition The project definition to disable the plugin in
+ * @param pluginKey The ID of the plugin to disable
+ * @param context The schema parser context to use
+ */
+function disablePlugin(projectDefinition, pluginKey, context) {
+    // Get plugin metadata to be disabled
+    const pluginMetadata = getPluginMetadataByKeyOrThrow(context.pluginStore, pluginKey);
+    // Make sure we disable any plugins that are managed by this plugin
+    const managedPlugins = projectDefinition.plugins?.filter((p) => {
+        const managedPlugin = getPluginMetadataByKeyOrThrow(context.pluginStore, pluginEntityType.keyFromId(p.id));
+        return managedPlugin.managedBy === pluginMetadata.fullyQualifiedName;
+    });
+    if (managedPlugins) {
+        for (const p of managedPlugins)
+            disablePlugin(projectDefinition, p.id, context);
+    }
+    projectDefinition.plugins = projectDefinition.plugins?.filter((p) => p.id !== pluginEntityType.idFromKey(pluginKey));
+}
+const PluginUtils = {
+    byKey,
+    byKeyOrThrow,
+    configByKey,
+    setPluginConfig,
+    configByKeyOrThrow,
+    disablePlugin,
+};
+
 const {stringifyPrettyStable} = await importShared('@baseplate-dev/utils');
 /**
  * Container for a project definition that includes references and entities.
@@ -9296,6 +9197,81 @@ const migration020MoveRedisToInfrastructure = createSchemaMigration({
     },
 });
 
+/**
+ * Migration to move enableBullQueue from backend apps to queue/bullmq plugins
+ *
+ * This migration:
+ * 1. Finds backend apps with enableBullQueue: true
+ * 2. If found, adds the queue parent plugin with implementationPluginKey pointing to bullmq
+ * 3. Adds the bullmq child plugin with default config
+ * 4. Removes enableBullQueue from all backend apps
+ */
+const migration021MigrateBullmqToPlugin = createSchemaMigration({
+    version: 21,
+    name: 'migrateBullmqToPlugin',
+    description: 'Migrate enableBullQueue from backend apps to queue/bullmq plugins',
+    migrate: (config) => {
+        // Find if any backend app has enableBullQueue: true
+        const hasBullQueue = config.apps?.some((app) => app.type === 'backend' && app.enableBullQueue === true);
+        // Remove enableBullQueue from all apps
+        const apps = config.apps?.map((app) => {
+            if (app.type === 'backend' && 'enableBullQueue' in app) {
+                const { enableBullQueue: _, ...rest } = app;
+                return rest;
+            }
+            return app;
+        });
+        // If enableBullQueue was set, add the plugins
+        const plugins = config.plugins ? [...config.plugins] : [];
+        if (hasBullQueue) {
+            const queuePluginId = 'plugin:baseplate-dev_plugin-queue_queue';
+            const bullmqPluginId = 'plugin:baseplate-dev_plugin-queue_bullmq';
+            // Add/update queue parent plugin
+            const queuePluginIndex = plugins.findIndex((p) => p.id === queuePluginId);
+            if (queuePluginIndex === -1) {
+                plugins.push({
+                    id: queuePluginId,
+                    name: 'queue',
+                    packageName: '@baseplate-dev/plugin-queue',
+                    version: '1.0.0',
+                    config: {
+                        implementationPluginKey: 'baseplate-dev_plugin-queue_bullmq',
+                    },
+                });
+            }
+            else {
+                plugins[queuePluginIndex] = {
+                    ...plugins[queuePluginIndex],
+                    config: {
+                        ...plugins[queuePluginIndex].config,
+                        implementationPluginKey: 'baseplate-dev_plugin-queue_bullmq',
+                    },
+                };
+            }
+            // Add bullmq child plugin if not exists
+            const bullmqPluginIndex = plugins.findIndex((p) => p.id === bullmqPluginId);
+            if (bullmqPluginIndex === -1) {
+                plugins.push({
+                    id: bullmqPluginId,
+                    name: 'bullmq',
+                    packageName: '@baseplate-dev/plugin-queue',
+                    version: '1.0.0',
+                    config: {
+                        bullmqOptions: {
+                            deleteAfterDays: 7,
+                        },
+                    },
+                });
+            }
+        }
+        return {
+            ...config,
+            apps,
+            plugins,
+        };
+    },
+});
+
 const SCHEMA_MIGRATIONS = [
     migration005PrimaryUniqueRefs,
     migration006IndividualServiceControllers,
@@ -9313,6 +9289,7 @@ const SCHEMA_MIGRATIONS = [
     migration018CrudNameFieldRef,
     migration019ColumnTypeBased,
     migration020MoveRedisToInfrastructure,
+    migration021MigrateBullmqToPlugin,
 ];
 function isMigrateableProjectDefinition(projectDefinition) {
     return (typeof projectDefinition === 'object' &&
@@ -9378,7 +9355,7 @@ function createTestProjectDefinitionContainer(input = {}) {
     const pluginStore = {
         availablePlugins: [],
     };
-    const pluginImplementationStore = new PluginImplementationStore({});
+    const pluginImplementationStore = createPluginImplementationStore(pluginStore, { plugins: [] });
     const resolvedRefPayload = deserializeSchemaWithTransformedReferences(createProjectDefinitionSchema, createTestProjectDefinitionInput(input), { plugins: pluginImplementationStore });
     return new ProjectDefinitionContainer(resolvedRefPayload, {
         pluginStore,
@@ -10427,10 +10404,9 @@ function generateThemeColorsFromShade(palettes, mode, previousValues) {
     return result;
 }
 function generateCssFromThemeConfig(config) {
-    return Object.fromEntries(Object.entries(config).map(([key, value]) => [
-        `--${inflectionExports.dasherize(inflectionExports.underscore(key))}`,
-        value,
-    ]));
+    return Object.fromEntries(Object.entries(config)
+        .filter((input) => input[1] !== undefined)
+        .map(([key, value]) => [`--${inflectionExports.dasherize(inflectionExports.underscore(key))}`, value]));
 }
 function generateDefaultTheme() {
     const slatePalette = {
@@ -10450,5 +10426,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, DefinitionRefBuilder, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, 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, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudActionCompilerImplementation, createAdminCrudActionImplementation, createAdminCrudActionSchema, createAdminCrudActionType, createAdminCrudColumnCompiler, createAdminCrudColumnCompilerImplementation, createAdminCrudColumnImplementation, createAdminCrudColumnSchema, createAdminCrudColumnType, createAdminCrudDeleteActionSchema, createAdminCrudEditActionSchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedListSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEmbeddedObjectSchema, 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, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginImplementationStoreWithNewPlugins, createPluginSpec, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAdminSectionSchema, createWebAppSchema, createWebConfigImplementation, definitionSchema, deserializeSchemaWithTransformedReferences, extractDefinitionRefs, extractDefinitionRefsRecursive, 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, oklchColor, 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-BvJ1_iif.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, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, 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, 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, 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, oklchColor, 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-FK4Jv94w.js.map