@baseplate-dev/plugin-auth 1.0.1 → 1.0.3

package/dist/web/assets/__federation_shared_@baseplate-dev/{project-builder-lib-BAwM_-SS.js → project-builder-lib-CScAnw0t.js}

@@ -1,6 +1,6 @@
-import { c as createPluginSpec, i as isEqual, m as mapValues, a as createEntityType, z as zodPluginSymbol, Z as ZodRefWrapper, g as get$1, s as set$1, C as CASE_VALIDATORS, d as definitionSchema, b as zRef, e as modelForeignRelationEntityType, f as modelLocalRelationEntityType, h as modelScalarFieldEntityType, j as zEnt, k as modelTransformerEntityType, l as createDefinitionEntityNameResolver, n as modelEntityType, o as modelEnumValueEntityType, p as featureEntityType, q as modelEnumEntityType, r as zRefBuilder, t as zRefId, u as modelUniqueConstraintEntityType, v as createFeaturesSchema, M as ModelUtils, w as zPluginWrapper, x as omit, y as cloneDeep } from '../model-merger-gxuB007n.js';
-export { S as DefinitionDiffArrayIncludesField, Q as DefinitionDiffKeyedArrayField, R as DefinitionDiffReplacementField, G as DefinitionEntityType, F as FeatureUtils, A as ZodPluginWrapper, E as ZodRef, D as ZodRefBuilder, V as applyDefinitionDiff, N as applyModelMergerDiff, O as applyModelMergerResultInPlace, P as createAndApplyModelMergerResults, U as createDefinitionDiff, T as createDefinitionDiffConfig, I as createFeatureSchema, B as createInitializedPluginSpec, K as createModelMergerResult, L as createModelMergerResults, H as featureNameSchema, J as modelMergerDefinitionDiffConfig } from '../model-merger-gxuB007n.js';
-import { importShared } from '../__federation_fn_import-CxP86CUK.js';
+import { c as createPluginSpec, i as isEqual, m as mapValues, a as createEntityType, C as CASE_VALIDATORS, D as DefinitionReferenceMarker, g as get$1, R as REF_ANNOTATIONS_MARKER_SYMBOL, b as createDefinitionSchemaParserContext, s as set$1, d as definitionSchema, e as modelForeignRelationEntityType, f as modelLocalRelationEntityType, h as modelScalarFieldEntityType, j as modelTransformerEntityType, k as modelEntityType, l as modelEnumValueEntityType, n as featureEntityType, o as modelEnumEntityType, p as modelUniqueConstraintEntityType, q as createFeaturesSchema, M as ModelUtils, r as omit, t as cloneDeep } from '../model-merger-DYdmgijL.js';
+export { K as DefinitionDiffArrayIncludesField, I as DefinitionDiffKeyedArrayField, J as DefinitionDiffReplacementField, v as DefinitionEntityType, F as FeatureUtils, O as applyDefinitionDiff, E as applyModelMergerDiff, G as applyModelMergerResultInPlace, H as createAndApplyModelMergerResults, N as createDefinitionDiff, L as createDefinitionDiffConfig, x as createFeatureSchema, u as createInitializedPluginSpec, z as createModelMergerResult, B as createModelMergerResults, A as doesModelMergerResultsHaveChanges, w as featureNameSchema, y as modelMergerDefinitionDiffConfig } from '../model-merger-DYdmgijL.js';
+import { importShared } from '../__federation_fn_import-CktB8mRs.js';
 
 function createAdminCrudInputCompilerImplementation() {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -536,15 +536,20 @@ function detectCycle(nodes, visited, edges) {
         visitSet.delete(node);
         return false;
     }
-    // For cycle detection, we need to find nodes that weren't visited
-    const unvistedNodeIdx = nodes.findIndex((node, idx) => !visited.has(idx));
-    if (unvistedNodeIdx === -1) {
-        return [];
+    // For cycle detection, we need to try all unvisited nodes
+    for (let i = 0; i < nodes.length; i++) {
+        if (!visited.has(i)) {
+            // Reset path and visitSet for each starting node
+            path.length = 0;
+            visitSet.clear();
+            const cycleFound = dfs(i);
+            if (cycleFound) {
+                // Convert path indices to actual nodes
+                return path.map((idx) => nodes[idx]);
+            }
+        }
     }
-    // Start DFS from any unvisited node
-    dfs(unvistedNodeIdx);
-    // Convert path indices to actual nodes
-    return path.map((idx) => nodes[idx]);
+    return [];
 }
 /**
  * Default comparison function for stable topological sort
@@ -826,6 +831,12 @@ const pluginMetadataSchema = z$k.object({
         dependencies: z$k.array(pluginSpecDependencySchema).optional(),
     })
         .optional(),
+    /**
+     * Whether the plugin should be hidden in the project builder UI
+     *
+     * (It can be used once in the definition but cannot be added)
+     */
+    hidden: z$k.boolean().optional(),
 });
 
 var NOTHING = Symbol.for("immer-nothing");
@@ -1473,11 +1484,11 @@ function createPluginConfigImplementation() {
     const schemas = new Map();
     const migrationsMap = new Map();
     return {
-        registerSchema(pluginKey, schema) {
+        registerSchemaCreator(pluginKey, schemaCreator) {
             if (schemas.has(pluginKey)) {
                 throw new Error(`Schema for plugin ${pluginKey} is already registered`);
             }
-            schemas.set(pluginKey, schema);
+            schemas.set(pluginKey, schemaCreator);
         },
         registerMigrations(pluginKey, migrations) {
             if (migrationsMap.has(pluginKey)) {
@@ -1486,7 +1497,7 @@ function createPluginConfigImplementation() {
             const sortedMigrations = sortAndValidateMigrations(migrations);
             migrationsMap.set(pluginKey, sortedMigrations);
         },
-        getSchema(pluginKey) {
+        getSchemaCreator(pluginKey) {
             return schemas.get(pluginKey);
         },
         getMigrations(pluginKey) {
@@ -1540,31 +1551,6 @@ function runPluginMigrations(projectDefinition, pluginImplementationStore) {
     });
 }
 
-const {ZodType} = await importShared('zod');
-class ZodWithPlugins extends ZodType {
-    _parse(input) {
-        const context = input.parent.common;
-        // run builder
-        const zodPluginContext = context[zodPluginSymbol];
-        if (!zodPluginContext) {
-            throw new Error(`Spec must be run within a Zod plugin context`);
-        }
-        const innerType = this._def.getter(zodPluginContext.pluginStore, input.data);
-        return innerType._parse(input);
-    }
-}
-Object.defineProperty(ZodWithPlugins, "create", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: (getter) => new ZodWithPlugins({
-        getter,
-    })
-});
-function zWithPlugins(getter) {
-    return ZodWithPlugins.create(getter);
-}
-
 /**
  * Spec for adding config component for plugin
  */
@@ -2270,6 +2256,357 @@ const AppUtils = {
     getBackendRelativePath,
 };
 
+const authRoleEntityType = createEntityType('role');
+
+const appEntityType = createEntityType('app');
+function createAppEntryType(name) {
+    return name;
+}
+
+const {z: z$j} = await importShared('zod');
+const baseAppValidators = {
+    id: z$j.string().default(appEntityType.generateNewId()),
+    name: CASE_VALIDATORS.KEBAB_CASE,
+    type: z$j.string(),
+    packageLocation: z$j
+        .string()
+        .regex(/^(?!.*(?:\/|\.\.)\/)(?!^\.\.$)(?!^\.$)(?:[\w\-.]+\/?)+[\w\-.]*|^$/, {
+        message: 'Invalid package location. Must be a valid subdirectory.',
+    })
+        .optional(),
+};
+const baseAppSchema = z$j.object(baseAppValidators);
+
+/**
+ * Strips the DefinitionReferenceMarker from the value recursively.
+ * @param value - The value to strip the DefinitionReferenceMarker from.
+ * @returns The value without the DefinitionReferenceMarker.
+ */
+function stripRefMarkers(value) {
+    if (value instanceof DefinitionReferenceMarker) {
+        return value.value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(stripRefMarkers);
+    }
+    if (typeof value === 'object' && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([key, childValue]) => [
+            key,
+            stripRefMarkers(childValue),
+        ]));
+    }
+    return value;
+}
+
+/**
+ * Creates a definition entity name resolver.
+ * @param entityNameResolver - The entity name resolver.
+ * @returns The definition entity name resolver.
+ */
+function createDefinitionEntityNameResolver(entityNameResolver) {
+    return entityNameResolver;
+}
+/**
+ * DefinitionRefBuilder is responsible for constructing reference paths, and registering
+ * references and entities as defined in a Zod schema.
+ *
+ * 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.
+ */
+class DefinitionRefBuilder {
+    /**
+     * 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) {
+        Object.defineProperty(this, "references", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "entitiesWithNameResolver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pathPrefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pathMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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}`);
+        }
+        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$1(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);
+        }
+    }
+    /**
+     * 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$1(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$1(value, 'name'));
+        const nameResolver = getNameResolver(stripRefMarkers(this.data));
+        // 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);
+    }
+}
+
+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);
+        }
+        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 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 idSet = new Set();
+    for (const entity of refContext.entitiesWithNameResolver) {
+        if (idSet.has(entity.id)) {
+            throw new Error(`Duplicate ID found: ${entity.id}`);
+        }
+        idSet.add(entity.id);
+    }
+    return {
+        data: cleanData,
+        references: refContext.references,
+        entitiesWithNameResolver: refContext.entitiesWithNameResolver,
+    };
+}
+
 /**
  * Resolves entity names in a ZodRefPayload.
  *
@@ -2329,19 +2666,47 @@ function resolveZodRefPayloadNames(payload, { skipReferenceNameResolution = fals
  *
  * @returns The parsed data.
  */
-function parseSchemaWithReferences(schema, input, options) {
-    const wrapper = ZodRefWrapper.create(schema);
-    return resolveZodRefPayloadNames(wrapper.parse(input), options);
+function parseSchemaWithTransformedReferences(schemaCreator, input, schemaCreatorOptions, options) {
+    const schemaContext = createDefinitionSchemaParserContext({
+        ...schemaCreatorOptions,
+        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);
 }
 
 function referenceToNameParentId(name, parentId) {
     return JSON.stringify({ name, parentId });
 }
-function deserializeSchemaWithReferences(schema, input) {
-    const payload = parseSchemaWithReferences(schema, input, {
+/**
+ * Deserialize a schema with references using the new transform-based approach.
+ * This function converts human-readable names back to entity IDs.
+ *
+ * @template T - The schema creator type
+ * @param schemaCreator - The schema creator function
+ * @param input - The input data with names instead of IDs
+ * @param options - Options for the schema creator (excluding transformReferences)
+ * @returns The resolved payload with IDs instead of names
+ */
+function deserializeSchemaWithTransformedReferences(schemaCreator, input, options) {
+    const payload = parseSchemaWithTransformedReferences(schemaCreator, input, options, {
         skipReferenceNameResolution: true,
     });
-    // resolve all references
+    // Use the same resolution logic as the original function
+    return resolveReferencesToIds(payload);
+}
+/**
+ * Internal function to resolve entity names to IDs in the payload.
+ * This is shared logic between the old and new approaches.
+ *
+ * @param payload - The parsed payload with entities and references
+ * @returns The payload with references resolved to IDs
+ */
+function resolveReferencesToIds(payload) {
     const { references, entities, data } = payload;
     // check we don't have more entities than IDs
     const entitiesById = groupBy(entities, (entity) => entity.id);
@@ -2403,13 +2768,13 @@ const DELETED_SENTINEL_ID = 'deleted-sentinel-id';
 /**
  * Fixes any reference deletions by performing the appropriate action for the reference
  */
-function fixRefDeletions(schema, value) {
+function fixRefDeletions(schemaCreator, value, schemaCreatorOptions) {
     const issues = [];
     // find all references that do not have a corresponding entity
     let iterations;
     let valueToEdit = value;
     for (iterations = 0; iterations < 100; iterations++) {
-        const parseResult = parseSchemaWithReferences(schema, valueToEdit, {
+        const parseResult = parseSchemaWithTransformedReferences(schemaCreator, valueToEdit, schemaCreatorOptions, {
             allowInvalidReferences: true,
         });
         const { references, entities } = parseResult;
@@ -2452,8 +2817,16 @@ function fixRefDeletions(schema, value) {
         for (const ref of referencesMissingEntity) {
             const id = get$1(valueToEdit, ref.path);
             switch (ref.onDelete) {
-                case 'SET_NULL': {
-                    set$1(valueToEdit, ref.path, null);
+                case 'SET_UNDEFINED': {
+                    // Check if reference is inside an array
+                    if (ref.path.length > 0) {
+                        const parentPath = ref.path.slice(0, -1);
+                        const parent = get$1(valueToEdit, parentPath);
+                        if (Array.isArray(parent)) {
+                            throw new TypeError(`SET_UNDEFINED cannot be used for references inside arrays at path ${ref.path.join('.')}. Use DELETE instead to remove the array element.`);
+                        }
+                    }
+                    set$1(valueToEdit, ref.path, undefined);
                     break;
                 }
                 case 'RESTRICT': {
@@ -2508,32 +2881,12 @@ function serializeSchemaFromRefPayload(payload) {
         }
     })(data);
 }
-function serializeSchema(schema, value) {
-    const payload = parseSchemaWithReferences(schema, value);
+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);
 }
 
-const authRoleEntityType = createEntityType('role');
-
-const appEntityType = createEntityType('app');
-function createAppEntryType(name) {
-    return name;
-}
-
-const {z: z$j} = await importShared('zod');
-const baseAppValidators = {
-    id: z$j.string().default(appEntityType.generateNewId()),
-    name: CASE_VALIDATORS.KEBAB_CASE,
-    type: z$j.string(),
-    packageLocation: z$j
-        .string()
-        .regex(/^(?!.*(?:\/|\.\.)\/)(?!^\.\.$)(?!^\.$)(?:[\w\-.]+\/?)+[\w\-.]*|^$/, {
-        message: 'Invalid package location. Must be a valid subdirectory.',
-    })
-        .optional(),
-};
-const baseAppSchema = z$j.object(baseAppValidators);
-
 const SCALAR_FIELD_TYPES = [
     'string',
     'uuid',
@@ -2599,113 +2952,68 @@ const VALIDATORS = {
 };
 
 const {z: z$g} = await importShared('zod');
-const roleArray = z$g
-    .array(zRef(z$g.string(), {
+const createRoleArray = definitionSchema((ctx) => ctx.withDefault(z$g.array(ctx.withRef({
     type: authRoleEntityType,
     onDelete: 'DELETE',
-}))
-    .optional();
-const createModelGraphqlSchema = definitionSchema(() => z$g.object({
-    objectType: z$g
-        .object({
-        enabled: z$g.boolean().default(false),
-        fields: z$g.array(zRef(z$g.string(), {
+})), []));
+const createModelGraphqlSchema = definitionSchema((ctx) => z$g.object({
+    objectType: ctx.withDefault(z$g.object({
+        enabled: ctx.withDefault(z$g.boolean(), false),
+        fields: ctx.withDefault(z$g.array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
-        })),
-        localRelations: z$g
-            .array(zRef(z$g.string(), {
+        })), []),
+        localRelations: ctx.withDefault(z$g.array(ctx.withRef({
             type: modelLocalRelationEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
-        }))
-            .optional(),
-        foreignRelations: z$g
-            .array(zRef(z$g.string(), {
+        })), []),
+        foreignRelations: ctx.withDefault(z$g.array(ctx.withRef({
             type: modelForeignRelationEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
-        }))
-            .optional(),
-    })
-        .default({
-        enabled: false,
-        fields: [],
-    }),
-    queries: z$g
-        .object({
-        get: z$g
-            .object({
-            enabled: z$g.boolean().optional(),
-            roles: roleArray,
-        })
-            .optional(),
-        list: z$g
-            .object({
-            enabled: z$g.boolean().optional(),
-            roles: roleArray,
-        })
-            .optional(),
-    })
-        .default({
-        get: {
-            enabled: false,
-            roles: [],
-        },
-        list: {
-            enabled: false,
-            roles: [],
-        },
-    }),
-    mutations: z$g
-        .object({
-        create: z$g
-            .object({
-            enabled: z$g.boolean().optional(),
-            roles: roleArray,
-        })
-            .default({
-            enabled: false,
-            roles: [],
-        }),
-        update: z$g
-            .object({
-            enabled: z$g.boolean().optional(),
-            roles: roleArray,
-        })
-            .default({
-            enabled: false,
-            roles: [],
-        }),
-        delete: z$g
-            .object({
-            enabled: z$g.boolean().optional(),
-            roles: roleArray,
-        })
-            .default({
-            enabled: false,
-            roles: [],
-        }),
-    })
-        .default({}),
+        })), []),
+    }), {}),
+    queries: ctx.withDefault(z$g.object({
+        get: ctx.withDefault(z$g.object({
+            enabled: ctx.withDefault(z$g.boolean(), false),
+            roles: createRoleArray(ctx),
+        }), {}),
+        list: ctx.withDefault(z$g.object({
+            enabled: ctx.withDefault(z$g.boolean(), false),
+            roles: createRoleArray(ctx),
+        }), {}),
+    }), {}),
+    mutations: ctx.withDefault(z$g.object({
+        create: ctx.withDefault(z$g.object({
+            enabled: ctx.withDefault(z$g.boolean(), false),
+            roles: createRoleArray(ctx),
+        }), {}),
+        update: ctx.withDefault(z$g.object({
+            enabled: ctx.withDefault(z$g.boolean(), false),
+            roles: createRoleArray(ctx),
+        }), {}),
+        delete: ctx.withDefault(z$g.object({
+            enabled: ctx.withDefault(z$g.boolean(), false),
+            roles: createRoleArray(ctx),
+        }), {}),
+    }), {}),
 }));
 
 const {z: z$f} = await importShared('zod');
 
 const baseTransformerFields = {
+    id: z$f.string(),
     type: z$f.string().min(1),
 };
-const baseTransformerSchema = z$f.object({
-    id: z$f.string(),
-    ...baseTransformerFields,
-});
+const baseTransformerSchema = z$f.object(baseTransformerFields);
 function createModelTransformerType(payload) {
     return payload;
 }
 
 const {z: z$e} = await importShared('zod');
-const createPasswordTransformerSchema = definitionSchema(() => zEnt(z$e.object({
+const createPasswordTransformerSchema = definitionSchema((ctx) => ctx.withEnt(z$e.object({
     ...baseTransformerFields,
     type: z$e.literal('password'),
 }), {
@@ -2713,27 +3021,27 @@ const createPasswordTransformerSchema = definitionSchema(() => zEnt(z$e.object({
     parentPath: { context: 'model' },
     getNameResolver: () => 'password',
 }));
-const createEmbeddedRelationTransformerSchema = definitionSchema(() => zEnt(z$e.object({
+const createEmbeddedRelationTransformerSchema = definitionSchema((ctx) => ctx.withRefBuilder(ctx.withEnt(z$e.object({
     ...baseTransformerFields,
-    foreignRelationRef: zRef(z$e.string().min(1), {
+    foreignRelationRef: ctx.withRef({
         type: modelForeignRelationEntityType,
         onDelete: 'DELETE_PARENT',
         parentPath: { context: 'model' },
     }),
     type: z$e.literal('embeddedRelation'),
-    embeddedFieldNames: z$e.array(zRef(z$e.string().min(1), {
+    embeddedFieldNames: z$e.array(ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'embeddedModel' },
     })),
     embeddedTransformerNames: z$e
-        .array(zRef(z$e.string().min(1), {
+        .array(ctx.withRef({
         type: modelTransformerEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'embeddedModel' },
     }))
         .optional(),
-    modelRef: zRef(z$e.string().min(1), {
+    modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
     }),
@@ -2744,18 +3052,18 @@ const createEmbeddedRelationTransformerSchema = definitionSchema(() => zEnt(z$e.
         idsToResolve: { foreignRelation: entity.foreignRelationRef },
         resolveName: (entityNames) => entityNames.foreignRelation,
     }),
-}).refBuilder((builder) => {
+}), (builder) => {
     builder.addPathToContext('modelRef', modelEntityType, 'embeddedModel');
 }));
 const BUILT_IN_TRANSFORMERS = [
     createModelTransformerType({
         name: 'password',
-        schema: createPasswordTransformerSchema,
+        createSchema: createPasswordTransformerSchema,
         getName: () => 'Password',
     }),
     createModelTransformerType({
         name: 'embeddedRelation',
-        schema: createEmbeddedRelationTransformerSchema,
+        createSchema: createEmbeddedRelationTransformerSchema,
         getName: (definitionContainer, definition) => definitionContainer.nameFromId(definition.foreignRelationRef),
     }),
 ];
@@ -2793,16 +3101,22 @@ const modelTransformerSpec = createPluginSpec('core/model-transformer', {
     defaultInitializer: createModelTransformerImplementation,
 });
 
-const createTransformerSchema = definitionSchema((ctx) => zWithPlugins((plugins, data) => {
-    const { type } = baseTransformerSchema.parse(data);
-    const transformer = plugins
+const createTransformerSchema = definitionSchema((ctx) => baseTransformerSchema.passthrough().transform((data, parseCtx) => {
+    const { type } = data;
+    const transformer = ctx.plugins
         .getPluginSpec(modelTransformerSpec)
         .getModelTransformer(type);
-    return transformer.schema(ctx);
+    return transformer
+        .createSchema(ctx)
+        .and(baseTransformerSchema)
+        .parse(data, {
+        path: parseCtx.path,
+    });
 }));
 
 const {z: z$d} = await importShared('zod');
-const createEnumValueSchema = definitionSchema(() => zEnt(z$d.object({
+const createEnumValueSchema = definitionSchema((ctx) => ctx.withEnt(z$d.object({
+    id: z$d.string(),
     name: z$d.string().min(1),
     friendlyName: z$d.string().min(1),
 }), {
@@ -2810,25 +3124,28 @@ const createEnumValueSchema = definitionSchema(() => zEnt(z$d.object({
     parentPath: { context: 'enum' },
 }));
 const createEnumBaseSchema = definitionSchema((ctx) => z$d.object({
+    id: z$d.string(),
     name: z$d.string().min(1),
-    featureRef: zRef(z$d.string().min(1), {
+    featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
     values: z$d.array(createEnumValueSchema(ctx)),
     isExposed: z$d.boolean(),
 }));
-const createEnumSchema = definitionSchema((ctx) => zEnt(createEnumBaseSchema(ctx), {
+const createEnumSchema = definitionSchema((ctx) => ctx.withEnt(createEnumBaseSchema(ctx), {
     type: modelEnumEntityType,
     addContext: 'enum',
 }));
 
 const {z: z$c} = await importShared('zod');
-const createModelScalarFieldSchema = definitionSchema(() => zEnt(z$c.object({
+const createModelScalarFieldSchema = definitionSchema((ctx) => ctx
+    .withEnt(z$c.object({
+    id: z$c.string(),
     name: VALIDATORS.CAMEL_CASE_STRING,
     type: z$c.enum(SCALAR_FIELD_TYPES),
     isOptional: z$c.boolean().default(false),
-    options: zRefBuilder(z$c
+    options: ctx.withRefBuilder(z$c
         .object({
         // string options
         default: z$c.string().default(''),
@@ -2838,10 +3155,12 @@ const createModelScalarFieldSchema = definitionSchema(() => zEnt(z$c.object({
         updatedAt: z$c.boolean().optional(),
         defaultToNow: z$c.boolean().optional(),
         // enum options
-        enumRef: zRef(z$c.string().optional(), {
+        enumRef: ctx
+            .withRef({
             type: modelEnumEntityType,
             onDelete: 'RESTRICT',
-        }),
+        })
+            .optional(),
         defaultEnumValueRef: z$c.string().optional(),
     })
         .transform((val) => ({
@@ -2894,19 +3213,19 @@ const REFERENTIAL_ACTIONS = [
     'SetNull',
     'SetDefault',
 ];
-const createModelRelationFieldSchema = definitionSchema(() => zRefBuilder(z$c.object({
-    id: zRefId,
+const createModelRelationFieldSchema = definitionSchema((ctx) => ctx.withRefBuilder(z$c.object({
+    id: z$c.string(),
     foreignId: z$c
         .string()
         .default(() => modelForeignRelationEntityType.generateNewId()),
     name: VALIDATORS.CAMEL_CASE_STRING,
     references: z$c.array(z$c.object({
-        localRef: zRef(z$c.string(), {
+        localRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
             parentPath: { context: 'model' },
         }),
-        foreignRef: zRef(z$c.string(), {
+        foreignRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
             parentPath: { context: 'foreignModel' },
@@ -2934,9 +3253,10 @@ const createModelRelationFieldSchema = definitionSchema(() => zRefBuilder(z$c.ob
         parentPath: 'modelRef',
     });
 }));
-const createModelUniqueConstraintSchema = definitionSchema(() => zEnt(z$c.object({
+const createModelUniqueConstraintSchema = definitionSchema((ctx) => ctx.withEnt(z$c.object({
+    id: z$c.string(),
     fields: z$c.array(z$c.object({
-        fieldRef: zRef(z$c.string().min(1), {
+        fieldRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
             parentPath: { context: 'model' },
@@ -2957,14 +3277,14 @@ const createModelServiceSchema = definitionSchema((ctx) => z$c.object({
         .object({
         enabled: z$c.boolean().default(false),
         fields: z$c
-            .array(zRef(z$c.string(), {
+            .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
         }))
             .optional(),
         transformerNames: z$c
-            .array(zRef(z$c.string(), {
+            .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
@@ -2976,14 +3296,14 @@ const createModelServiceSchema = definitionSchema((ctx) => z$c.object({
         .object({
         enabled: z$c.boolean().default(false),
         fields: z$c
-            .array(zRef(z$c.string(), {
+            .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
         }))
             .optional(),
         transformerNames: z$c
-            .array(zRef(z$c.string(), {
+            .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
             parentPath: { context: 'model' },
@@ -3001,9 +3321,9 @@ const createModelServiceSchema = definitionSchema((ctx) => z$c.object({
     transformers: z$c.array(createTransformerSchema(ctx)).default([]),
 }));
 const createModelBaseSchema = definitionSchema((ctx) => z$c.object({
-    id: zRefId,
+    id: z$c.string(),
     name: VALIDATORS.PASCAL_CASE_STRING,
-    featureRef: zRef(z$c.string().min(1), {
+    featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
@@ -3011,7 +3331,7 @@ const createModelBaseSchema = definitionSchema((ctx) => z$c.object({
         fields: z$c.array(createModelScalarFieldSchema(ctx)),
         relations: z$c.array(createModelRelationFieldSchema(ctx)).optional(),
         primaryKeyFieldRefs: z$c
-            .array(zRef(z$c.string(), {
+            .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
             parentPath: { context: 'model' },
@@ -3029,7 +3349,7 @@ const createModelBaseSchema = definitionSchema((ctx) => z$c.object({
     }),
     graphql: createModelGraphqlSchema(ctx).optional(),
 }));
-const createModelSchema = definitionSchema((ctx) => zEnt(createModelBaseSchema(ctx), {
+const createModelSchema = definitionSchema((ctx) => ctx.withEnt(createModelBaseSchema(ctx), {
     type: modelEntityType,
     addContext: 'model',
 }));
@@ -3039,16 +3359,16 @@ const adminSectionEntityType = createEntityType('admin-section', {
 });
 
 const {z: z$b} = await importShared('zod');
-const baseAdminSectionValidators = {
+const createBaseAdminSectionValidators = definitionSchema((ctx) => z$b.object({
     id: z$b.string().default(adminSectionEntityType.generateNewId()),
     name: z$b.string().min(1),
-    featureRef: zRef(z$b.string().min(1), {
+    featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
     icon: z$b.string().optional(),
     type: z$b.string().min(1),
-};
+}));
 
 const {z: z$a} = await importShared('zod');
 const baseAdminCrudInputSchema = z$a.object({
@@ -3063,10 +3383,10 @@ const adminCrudEmbeddedFormEntityType = createEntityType('admin-crud-embedded-fo
 });
 
 const {z: z$9} = await importShared('zod');
-const createAdminCrudTextInputSchema = definitionSchema(() => z$9.object({
+const createAdminCrudTextInputSchema = definitionSchema((ctx) => z$9.object({
     type: z$9.literal('text'),
     label: z$9.string().min(1),
-    modelFieldRef: zRef(z$9.string(), {
+    modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
@@ -3075,12 +3395,12 @@ const createAdminCrudTextInputSchema = definitionSchema(() => z$9.object({
 }));
 const adminCrudTextInputType = createAdminCrudInputType({
     name: 'text',
-    schema: createAdminCrudTextInputSchema,
+    createSchema: createAdminCrudTextInputSchema,
 });
-const createAdminCrudForeignInputSchema = definitionSchema(() => z$9.object({
+const createAdminCrudForeignInputSchema = definitionSchema((ctx) => z$9.object({
     type: z$9.literal('foreign'),
     label: z$9.string().min(1),
-    localRelationRef: zRef(z$9.string(), {
+    localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
@@ -3092,12 +3412,12 @@ const createAdminCrudForeignInputSchema = definitionSchema(() => z$9.object({
 }));
 const adminCrudForeignInputType = createAdminCrudInputType({
     name: 'foreign',
-    schema: createAdminCrudForeignInputSchema,
+    createSchema: createAdminCrudForeignInputSchema,
 });
-const createAdminCrudEnumInputSchema = definitionSchema(() => z$9.object({
+const createAdminCrudEnumInputSchema = definitionSchema((ctx) => z$9.object({
     type: z$9.literal('enum'),
     label: z$9.string().min(1),
-    modelFieldRef: zRef(z$9.string(), {
+    modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
@@ -3105,17 +3425,17 @@ const createAdminCrudEnumInputSchema = definitionSchema(() => z$9.object({
 }));
 const adminCrudEnumInputType = createAdminCrudInputType({
     name: 'enum',
-    schema: createAdminCrudEnumInputSchema,
+    createSchema: createAdminCrudEnumInputSchema,
 });
-const createAdminCrudEmbeddedInputSchema = definitionSchema(() => z$9.object({
+const createAdminCrudEmbeddedInputSchema = definitionSchema((ctx) => z$9.object({
     type: z$9.literal('embedded'),
     label: z$9.string().min(1),
-    modelRelationRef: zRef(z$9.string(), {
+    modelRelationRef: ctx.withRef({
         type: modelForeignRelationEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
     }),
-    embeddedFormRef: zRef(z$9.string(), {
+    embeddedFormRef: ctx.withRef({
         type: adminCrudEmbeddedFormEntityType,
         parentPath: { context: 'admin-section' },
         onDelete: 'RESTRICT',
@@ -3123,17 +3443,17 @@ const createAdminCrudEmbeddedInputSchema = definitionSchema(() => z$9.object({
 }));
 const adminCrudEmbeddedInputType = createAdminCrudInputType({
     name: 'embedded',
-    schema: createAdminCrudEmbeddedInputSchema,
+    createSchema: createAdminCrudEmbeddedInputSchema,
 });
-const createAdminCrudEmbeddedLocalInputSchema = definitionSchema(() => z$9.object({
+const createAdminCrudEmbeddedLocalInputSchema = definitionSchema((ctx) => z$9.object({
     type: z$9.literal('embeddedLocal'),
     label: z$9.string().min(1),
-    localRelationRef: zRef(z$9.string(), {
+    localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
     }),
-    embeddedFormRef: zRef(z$9.string(), {
+    embeddedFormRef: ctx.withRef({
         type: adminCrudEmbeddedFormEntityType,
         parentPath: { context: 'admin-section' },
         onDelete: 'RESTRICT',
@@ -3141,7 +3461,7 @@ const createAdminCrudEmbeddedLocalInputSchema = definitionSchema(() => z$9.objec
 }));
 const adminCrudEmbeddedLocalInputType = createAdminCrudInputType({
     name: 'embeddedLocal',
-    schema: createAdminCrudEmbeddedLocalInputSchema,
+    createSchema: createAdminCrudEmbeddedLocalInputSchema,
 });
 const createAdminCrudPasswordInputSchema = definitionSchema(() => z$9.object({
     type: z$9.literal('password'),
@@ -3149,7 +3469,7 @@ const createAdminCrudPasswordInputSchema = definitionSchema(() => z$9.object({
 }));
 const adminCrudPasswordInputType = createAdminCrudInputType({
     name: 'password',
-    schema: createAdminCrudPasswordInputSchema,
+    createSchema: createAdminCrudPasswordInputSchema,
 });
 const BUILT_IN_ADMIN_CRUD_INPUTS = [
     adminCrudTextInputType,
@@ -3188,19 +3508,24 @@ const adminCrudInputSpec = createPluginSpec('core/admin-crud-input', {
     defaultInitializer: createAdminCrudInputImplementation,
 });
 
-const createAdminCrudInputSchema = definitionSchema((ctx) => zWithPlugins((plugins, data) => {
-    const { type } = baseAdminCrudInputSchema.parse(data);
-    const input = plugins
+const createAdminCrudInputSchema = definitionSchema((ctx) => baseAdminCrudInputSchema.passthrough().transform((data, parseCtx) => {
+    const { type } = data;
+    const crudInput = ctx.plugins
         .getPluginSpec(adminCrudInputSpec)
         .getAdminCrudInput(type);
-    return input.schema(ctx);
+    return crudInput
+        .createSchema(ctx)
+        .and(baseAdminCrudInputSchema)
+        .parse(data, {
+        path: parseCtx.path,
+    });
 }));
 
 const {z: z$8} = await importShared('zod');
 // Table Columns
-const createAdminCrudForeignDisplaySchema = definitionSchema(() => z$8.object({
+const createAdminCrudForeignDisplaySchema = definitionSchema((ctx) => z$8.object({
     type: z$8.literal('foreign'),
-    localRelationRef: zRef(z$8.string(), {
+    localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
@@ -3208,9 +3533,9 @@ const createAdminCrudForeignDisplaySchema = definitionSchema(() => z$8.object({
     labelExpression: z$8.string().min(1),
     valueExpression: z$8.string().min(1),
 }));
-const createAdminCrudTextDisplaySchema = definitionSchema(() => z$8.object({
+const createAdminCrudTextDisplaySchema = definitionSchema((ctx) => z$8.object({
     type: z$8.literal('text'),
-    modelFieldRef: zRef(z$8.string(), {
+    modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentPath: { context: 'model' },
@@ -3230,7 +3555,7 @@ const createAdminCrudTableColumnSchema = definitionSchema((ctx) => z$8.object({
 const createAdminCrudEmbeddedObjectSchema = definitionSchema((ctx) => z$8.object({
     id: z$8.string().min(1),
     name: z$8.string().min(1),
-    modelRef: zRef(z$8.string().min(1), {
+    modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
     }),
@@ -3243,7 +3568,7 @@ const createAdminCrudEmbeddedObjectSchema = definitionSchema((ctx) => z$8.object
 const createAdminCrudEmbeddedListSchema = definitionSchema((ctx) => z$8.object({
     id: z$8.string().min(1),
     name: z$8.string().min(1),
-    modelRef: zRef(z$8.string().min(1), {
+    modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
     }),
@@ -3258,7 +3583,7 @@ const createAdminCrudEmbeddedListSchema = definitionSchema((ctx) => z$8.object({
         fields: z$8.array(createAdminCrudInputSchema(ctx)),
     }),
 }));
-const createAdminCrudEmbeddedFormSchema = definitionSchema((ctx) => zRefBuilder(z$8.discriminatedUnion('type', [
+const createAdminCrudEmbeddedFormSchema = definitionSchema((ctx) => ctx.withRefBuilder(z$8.discriminatedUnion('type', [
     createAdminCrudEmbeddedObjectSchema(ctx),
     createAdminCrudEmbeddedListSchema(ctx),
 ]), (builder) => {
@@ -3269,10 +3594,9 @@ const createAdminCrudEmbeddedFormSchema = definitionSchema((ctx) => zRefBuilder(
     builder.addPathToContext('modelRef', modelEntityType, 'model');
 }));
 // Admin Section
-const createAdminCrudSectionSchema = definitionSchema((ctx) => zRefBuilder(z$8.object({
-    ...baseAdminSectionValidators,
+const createAdminCrudSectionSchema = definitionSchema((ctx) => ctx.withRefBuilder(createBaseAdminSectionValidators(ctx).and(z$8.object({
     type: z$8.literal('crud'),
-    modelRef: zRef(z$8.string().min(1), {
+    modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
     }),
@@ -3283,13 +3607,15 @@ const createAdminCrudSectionSchema = definitionSchema((ctx) => zRefBuilder(z$8.o
     form: z$8.object({
         fields: z$8.array(createAdminCrudInputSchema(ctx)),
     }),
-    embeddedForms: z$8.array(createAdminCrudEmbeddedFormSchema(ctx)).optional(),
-}), (builder) => {
+    embeddedForms: z$8
+        .array(createAdminCrudEmbeddedFormSchema(ctx))
+        .optional(),
+})), (builder) => {
     builder.addPathToContext('modelRef', modelEntityType, 'model');
 }));
 
 const {z: z$7} = await importShared('zod');
-const createAdminSectionSchema = definitionSchema((ctx) => zRefBuilder(createAdminCrudSectionSchema(ctx), (builder) => {
+const createAdminSectionSchema = definitionSchema((ctx) => ctx.withRefBuilder(createAdminCrudSectionSchema(ctx), (builder) => {
     builder.addEntity({
         type: adminSectionEntityType,
         parentPath: { context: 'app' },
@@ -3300,7 +3626,7 @@ const createAdminAppSchema = definitionSchema((ctx) => z$7.object({
     ...baseAppValidators,
     type: z$7.literal('admin'),
     allowedRoles: z$7
-        .array(zRef(z$7.string(), {
+        .array(ctx.withRef({
         type: authRoleEntityType,
         onDelete: 'DELETE',
     }))
@@ -3323,14 +3649,14 @@ const createBackendAppSchema = definitionSchema(() => z$6.object({
 const backendAppEntryType = createAppEntryType('backend');
 
 const {z: z$5} = await importShared('zod');
-const createWebAppSchema = definitionSchema(() => z$5.object({
+const createWebAppSchema = definitionSchema((ctx) => z$5.object({
     ...baseAppValidators,
     type: z$5.literal('web'),
     includeAuth: z$5.boolean().optional(),
     title: z$5.string().optional(),
     description: z$5.string().optional(),
     allowedRoles: z$5
-        .array(zRef(z$5.string().min(1), {
+        .array(ctx.withRef({
         type: authRoleEntityType,
         onDelete: 'DELETE',
     }))
@@ -3342,28 +3668,31 @@ const webAppEntryType = createAppEntryType('web');
 
 const {z: z$4} = await importShared('zod');
 const basePluginDefinitionSchema = z$4.object({
-    id: z$4.string().min(1),
+    id: z$4.string(),
     packageName: z$4.string(),
     name: z$4.string(),
     version: z$4.string(),
     config: z$4.unknown(),
     configSchemaVersion: z$4.number().optional(),
 });
-const createPluginWithConfigSchema = definitionSchema(() => zWithPlugins((plugins, data) => {
-    const parsedBasePlugin = basePluginDefinitionSchema.parse(data);
-    const pluginKey = pluginEntityType.keyFromId(parsedBasePlugin.id);
-    const configSchema = plugins
+const createPluginWithConfigSchema = definitionSchema((ctx) => ctx
+    .withEnt(basePluginDefinitionSchema.passthrough(), {
+    type: pluginEntityType,
+})
+    .transform((data, parseCtx) => {
+    const pluginKey = pluginEntityType.keyFromId(data.id);
+    const createConfigSchema = ctx.plugins
         .getPluginSpec(pluginConfigSpec)
-        .getSchema(pluginKey);
-    const pluginDefinitionWithEnt = zEnt(basePluginDefinitionSchema, {
-        type: pluginEntityType,
-    });
-    if (!configSchema) {
-        return pluginDefinitionWithEnt;
+        .getSchemaCreator(pluginKey);
+    let pluginDefinitionSchema = basePluginDefinitionSchema;
+    if (createConfigSchema) {
+        pluginDefinitionSchema = pluginDefinitionSchema.extend({
+            config: createConfigSchema(ctx),
+        });
     }
-    return pluginDefinitionWithEnt.and(z$4.object({
-        config: configSchema,
-    }));
+    return pluginDefinitionSchema.parse(data, {
+        path: parseCtx.path,
+    });
 }));
 const createPluginsSchema = definitionSchema((ctx) => z$4.array(createPluginWithConfigSchema(ctx)));
 
@@ -3414,7 +3743,7 @@ const createSettingsSchema = definitionSchema((ctx) => z$2.object({
 }));
 
 const {z: z$1} = await importShared('zod');
-const createAppSchema = definitionSchema((ctx) => zRefBuilder(z$1.discriminatedUnion('type', [
+const createAppSchema = definitionSchema((ctx) => ctx.withRefBuilder(z$1.discriminatedUnion('type', [
     createBackendAppSchema(ctx),
     createWebAppSchema(ctx),
     createAdminAppSchema(ctx),
@@ -3647,7 +3976,10 @@ function createPluginImplementationStore(pluginStore, projectDefinition) {
 function createProjectDefinitionSchemaWithContext(projectDefinition, context) {
     const { pluginStore } = context;
     const pluginImplementationStore = createPluginImplementationStore(pluginStore, projectDefinition);
-    return zPluginWrapper(createProjectDefinitionSchema({ plugins: pluginImplementationStore }), pluginImplementationStore);
+    const definitionContext = createDefinitionSchemaParserContext({
+        plugins: pluginImplementationStore,
+    });
+    return createProjectDefinitionSchema(definitionContext);
 }
 function parseProjectDefinitionWithContext(projectDefinition, context) {
     const schema = createProjectDefinitionSchemaWithContext(projectDefinition, context);
@@ -3661,9 +3993,10 @@ function parseProjectDefinitionWithContext(projectDefinition, context) {
  * @returns The parsed project definition with entities/references
  */
 function parseProjectDefinitionWithReferences(projectDefinition, context) {
-    const schema = createProjectDefinitionSchemaWithContext(projectDefinition, context);
-    const definition = parseSchemaWithReferences(schema, projectDefinition);
-    return { definition, pluginStore: schema._def.pluginStore };
+    const { pluginStore } = context;
+    const pluginImplementationStore = createPluginImplementationStore(pluginStore, projectDefinition);
+    const definition = parseSchemaWithTransformedReferences(createProjectDefinitionSchema, projectDefinition, { plugins: pluginImplementationStore });
+    return { definition, pluginStore: pluginImplementationStore };
 }
 
 /**
@@ -3745,8 +4078,9 @@ class ProjectDefinitionContainer {
      */
     fixRefDeletions(setter) {
         const newDefinition = produce(setter)(this.definition);
-        const schemaWithContext = createProjectDefinitionSchemaWithContext(newDefinition, this.parserContext);
-        return fixRefDeletions(schemaWithContext, newDefinition);
+        return fixRefDeletions(createProjectDefinitionSchema, newDefinition, {
+            plugins: this.pluginStore,
+        });
     }
     /**
      * Serializes the project definition resolving references to their names for easier reading.
@@ -3754,7 +4088,11 @@ class ProjectDefinitionContainer {
      * @returns The serialized contents of the project definition
      */
     toSerializedContents() {
-        return stringifyPrettyStable(serializeSchemaFromRefPayload(this.refPayload));
+        const serializedContents = serializeSchema(createProjectDefinitionSchema, this.definition, {
+            defaultMode: 'strip',
+            plugins: this.pluginStore,
+        });
+        return stringifyPrettyStable(serializedContents);
     }
     /**
      * Creates a new ProjectDefinitionContainer from a raw project definition.
@@ -3775,8 +4113,8 @@ class ProjectDefinitionContainer {
      * @returns A new ProjectDefinitionContainer
      */
     static fromSerializedConfig(config, context) {
-        const projectDefinitionSchemaWithContext = createProjectDefinitionSchemaWithContext(config, context);
-        return new ProjectDefinitionContainer(deserializeSchemaWithReferences(projectDefinitionSchemaWithContext, config), context, projectDefinitionSchemaWithContext.pluginStore);
+        const plugins = createPluginImplementationStore(context.pluginStore, config);
+        return new ProjectDefinitionContainer(deserializeSchemaWithTransformedReferences(createProjectDefinitionSchema, config, { plugins }), context, plugins);
     }
 }
 
@@ -8735,6 +9073,25 @@ const migration014MigratePluginIds = createSchemaMigration({
     },
 });
 
+const migration015NullParentRefs = createSchemaMigration({
+    version: 15,
+    name: 'nullParentRefs',
+    description: 'Convert null parentRefs to undefined in features',
+    migrate: (config) => {
+        if (!config.features) {
+            return config;
+        }
+        const features = config.features.map((feature) => ({
+            ...feature,
+            parentRef: feature.parentRef ?? undefined,
+        }));
+        return {
+            ...config,
+            features,
+        };
+    },
+});
+
 const SCHEMA_MIGRATIONS = [
     migration005PrimaryUniqueRefs,
     migration006IndividualServiceControllers,
@@ -8746,6 +9103,7 @@ const SCHEMA_MIGRATIONS = [
     migration012MigrateAuthConfig,
     migration013MoveGeneralSettings,
     migration014MigratePluginIds,
+    migration015NullParentRefs,
 ];
 function isMigrateableProjectDefinition(projectDefinition) {
     return (typeof projectDefinition === 'object' &&
@@ -8822,11 +9180,7 @@ function createTestProjectDefinitionContainer(input = {}) {
         availablePlugins: [],
     };
     const pluginImplementationStore = new PluginImplementationStore({});
-    const projectDefinitionSchema = createProjectDefinitionSchema({
-        plugins: pluginImplementationStore,
-    });
-    const schemaWithPlugins = zPluginWrapper(projectDefinitionSchema, pluginImplementationStore);
-    const resolvedRefPayload = deserializeSchemaWithReferences(schemaWithPlugins, createTestProjectDefinitionInput(input));
+    const resolvedRefPayload = deserializeSchemaWithTransformedReferences(createProjectDefinitionSchema, createTestProjectDefinitionInput(input), { plugins: pluginImplementationStore });
     return new ProjectDefinitionContainer(resolvedRefPayload, { pluginStore }, pluginImplementationStore);
 }
 
@@ -9888,5 +10242,5 @@ function generateDefaultTheme() {
     };
 }
 
-export { AVAILABLE_FLAGS, AppUtils, 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, ZodRefWrapper, ZodWithPlugins, adminAppEntryType, adminCrudDisplayTypes, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedInputType, adminCrudEmbeddedLocalInputType, adminCrudInputCompilerSpec, adminCrudInputSpec, adminSectionEntityType, appCompilerSpec, appEntityType, authConfigSpec, authRoleEntityType, backendAppEntryType, baseAdminCrudInputSchema, baseAdminSectionValidators, baseAppSchema, baseAppValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudDisplaySchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedListSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEmbeddedObjectSchema, createAdminCrudEnumInputSchema, createAdminCrudForeignDisplaySchema, createAdminCrudForeignInputSchema, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputSchema, createAdminCrudInputType, createAdminCrudPasswordInputSchema, createAdminCrudSectionSchema, createAdminCrudTableColumnSchema, createAdminCrudTextDisplaySchema, createAdminCrudTextInputSchema, createAdminSectionSchema, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createAppSchema, createBackendAppSchema, createDefinitionEntityNameResolver, createEmbeddedRelationTransformerSchema, createEntityType, createEnumBaseSchema, createEnumSchema, createEnumValueSchema, createFeaturesSchema, createModelBaseSchema, createModelGraphqlSchema, createModelRelationFieldSchema, createModelScalarFieldSchema, createModelSchema, createModelServiceSchema, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createModelUniqueConstraintSchema, createPasswordTransformerSchema, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginSpec, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAppSchema, createWebConfigImplementation, definitionSchema, deserializeSchemaWithReferences, featureEntityType, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, initializePlugins, isMigrateableProjectDefinition, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, oklchColor, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, pluginConfigSpec, pluginEntityType, pluginManifestJsonSchema, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, themeColorSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webConfigSpec, zEnt, zPluginWrapper, zRef, zRefBuilder, zRefId, zWithPlugins };
-//# sourceMappingURL=project-builder-lib-BAwM_-SS.js.map
+export { AVAILABLE_FLAGS, AppUtils, 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, adminAppEntryType, adminCrudDisplayTypes, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedInputType, adminCrudEmbeddedLocalInputType, adminCrudInputCompilerSpec, adminCrudInputSpec, adminSectionEntityType, appCompilerSpec, appEntityType, authConfigSpec, authRoleEntityType, backendAppEntryType, baseAdminCrudInputSchema, baseAppSchema, baseAppValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudDisplaySchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedListSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEmbeddedObjectSchema, createAdminCrudEnumInputSchema, createAdminCrudForeignDisplaySchema, createAdminCrudForeignInputSchema, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputSchema, createAdminCrudInputType, createAdminCrudPasswordInputSchema, createAdminCrudSectionSchema, createAdminCrudTableColumnSchema, createAdminCrudTextDisplaySchema, createAdminCrudTextInputSchema, createAdminSectionSchema, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createAppSchema, createBackendAppSchema, createBaseAdminSectionValidators, createDefinitionEntityNameResolver, createDefinitionSchemaParserContext, createEmbeddedRelationTransformerSchema, createEntityType, createEnumBaseSchema, createEnumSchema, createEnumValueSchema, createFeaturesSchema, createModelBaseSchema, createModelGraphqlSchema, createModelRelationFieldSchema, createModelScalarFieldSchema, createModelSchema, createModelServiceSchema, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createModelUniqueConstraintSchema, createPasswordTransformerSchema, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginSpec, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAppSchema, createWebConfigImplementation, definitionSchema, deserializeSchemaWithTransformedReferences, extractDefinitionRefs, extractDefinitionRefsRecursive, featureEntityType, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, initializePlugins, isMigrateableProjectDefinition, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, oklchColor, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, pluginConfigSpec, pluginEntityType, pluginManifestJsonSchema, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, themeColorSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webConfigSpec };
+//# sourceMappingURL=project-builder-lib-CScAnw0t.js.map