@baseplate-dev/plugin-auth 3.0.4 → 4.0.0

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

@@ -1,6 +1,6 @@
-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 { c as createPluginSpec, m as mapValues, a as createEntityType, d as definitionSchemaWithSlots, D as DefinitionReferenceMarker, R as REF_ANNOTATIONS_MARKER_SYMBOL, s as stripRefMarkers, b as createDefinitionSchemaParserContext, g as get, e as set$1, f as definitionSchema, h as modelForeignRelationEntityType, i as modelLocalRelationEntityType, j as modelScalarFieldEntityType, k as modelEntityType, l as modelTransformerEntityType, n as modelEnumValueEntityType, o as modelEnumEntityType, p as featureEntityType, q as modelUniqueConstraintEntityType, r as createFeaturesSchema, M as ModelUtils, t as omit, u as cloneDeep } from '../model-merger-gGkFnyaY.js';
+export { O as DefinitionDiffArrayIncludesField, L as DefinitionDiffKeyedArrayField, N as DefinitionDiffReplacementField, y as DefinitionEntityType, F as FeatureUtils, S as applyDefinitionDiff, I as applyModelMergerDiff, J as applyModelMergerResultInPlace, K as createAndApplyModelMergerResults, Q as createDefinitionDiff, P as createDefinitionDiffConfig, B as createFeatureSchema, v as createInitializedPluginSpec, E as createModelMergerResult, H as createModelMergerResults, w as createRefContextSlot, x as createRefContextSlotMap, G as doesModelMergerResultsHaveChanges, A as featureNameSchema, C as modelMergerDefinitionDiffConfig, z as withPlaceholderSlots } from '../model-merger-gGkFnyaY.js';
+import { importShared } from '../__federation_fn_import-C_QCk5FX.js';
 import { i as isEqual } from '../isEqual-DAXqKRba.js';
 import { s as sortBy } from '../sortBy-BPH_zRB8.js';
 
@@ -312,45 +312,45 @@ function getManagedPluginsForPlugin(pluginStore, pluginKey) {
         .map((p) => p.metadata);
 }
 
-const {z: z$s} = await importShared('zod');
+const {z: z$u} = await importShared('zod');
 
 // matches semver
-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 versionSchema = z$u.string().regex(/^(\d+\.\d+\.\d+)$/);
+const pluginSpecSupportSchema = z$u.object({
+    spec: z$u.string().min(1),
+    version: z$u.string().min(1),
 });
-const pluginSpecDependencySchema = z$s.object({
-    spec: z$s.string(),
-    version: z$s.string(),
+const pluginSpecDependencySchema = z$u.object({
+    spec: z$u.string(),
+    version: z$u.string(),
 });
 /**
  * Schema for the plugin's metadata (plugin.json)
  */
-const pluginMetadataSchema = z$s.object({
+const pluginMetadataSchema = z$u.object({
     /**
      * The name of the plugin - must be lowercase and contain only letters, numbers, and hyphens
      */
-    name: z$s
+    name: z$u
         .string()
         .min(1)
         .regex(/^[a-z0-9-]+$/),
     /**
      * A list of directories with entrypoints in them. Defaults to ['.']
      */
-    moduleDirectories: z$s.array(z$s.string()).optional(),
+    moduleDirectories: z$u.array(z$u.string()).optional(),
     /**
      * The display name of the plugin
      */
-    displayName: z$s.string().min(1),
+    displayName: z$u.string().min(1),
     /**
      * The icon to display for the plugin as a pointer to the icon in the plugin's static folder
      */
-    icon: z$s.string().optional(),
+    icon: z$u.string().optional(),
     /**
      * A description of the plugin
      */
-    description: z$s.string(),
+    description: z$u.string(),
     /**
      * The fully qualified name of the plugin that manages this plugin,
      * e.g. "@baseplate-dev/plugin-auth:auth0" would be managed by the "@baseplate-dev/plugin-auth:auth" plugin.
@@ -358,7 +358,7 @@ const pluginMetadataSchema = z$s.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$s.string().optional(),
+    managedBy: z$u.string().optional(),
     /**
      * The version of the plugin using semver
      */
@@ -366,16 +366,16 @@ const pluginMetadataSchema = z$s.object({
     /**
      * Configuration for the specs that the plugin exports/depends on
      */
-    specs: z$s
+    specs: z$u
         .object({
         /**
          * The specs that the plugin exports
          */
-        exports: z$s.array(pluginSpecSupportSchema).optional(),
+        exports: z$u.array(pluginSpecSupportSchema).optional(),
         /**
          * The specs that the plugin depends on
          */
-        dependencies: z$s.array(pluginSpecDependencySchema).optional(),
+        dependencies: z$u.array(pluginSpecDependencySchema).optional(),
     })
         .optional(),
     /**
@@ -383,7 +383,7 @@ const pluginMetadataSchema = z$s.object({
      *
      * (It can be used once in the definition but cannot be added)
      */
-    hidden: z$s.boolean().optional(),
+    hidden: z$u.boolean().optional(),
 });
 
 var NOTHING = Symbol.for("immer-nothing");
@@ -1785,7 +1785,7 @@ function computeRelativePath(fromPath, toPath) {
     return relativePath;
 }
 
-function byId$1(projectDefinition, id) {
+function byId$2(projectDefinition, id) {
     const config = projectDefinition.apps.find((app) => app.id === id);
     if (!config) {
         throw new Error(`Unable to find app with ID ${id}`);
@@ -1816,7 +1816,7 @@ function getBackendRelativePath(appConfig, backendApp, monorepoSettings) {
     return backendRelativePath;
 }
 const AppUtils = {
-    byId: byId$1,
+    byId: byId$2,
     getBackendApp,
     getBackendRelativePath,
     getAppDirectory,
@@ -1827,24 +1827,24 @@ function createAppEntryType(name) {
     return name;
 }
 
-const {CASE_VALIDATORS: CASE_VALIDATORS$2} = await importShared('@baseplate-dev/utils');
+const {CASE_VALIDATORS: CASE_VALIDATORS$3} = await importShared('@baseplate-dev/utils');
 
-const {z: z$r} = await importShared('zod');
+const {z: z$t} = await importShared('zod');
 const baseAppValidators = {
-    id: z$r.string().default(appEntityType.generateNewId()),
-    name: CASE_VALIDATORS$2.KEBAB_CASE,
-    type: z$r.string(),
+    id: z$t.string().default(appEntityType.generateNewId()),
+    name: CASE_VALIDATORS$3.KEBAB_CASE,
+    type: z$t.string(),
 };
-const baseAppSchema = z$r.object(baseAppValidators);
+const baseAppSchema = z$t.object(baseAppValidators);
 
-const {z: z$q} = await importShared('zod');
-const createBackendAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, () => z$q.object({
+const {z: z$s} = await importShared('zod');
+const createBackendAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, () => z$s.object({
     ...baseAppValidators,
-    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(),
+    type: z$s.literal('backend'),
+    enableStripe: z$s.boolean().optional(),
+    enablePostmark: z$s.boolean().optional(),
+    enableSubscriptions: z$s.boolean().optional(),
+    enableAxios: z$s.boolean().optional(),
 }));
 const backendAppEntryType = createAppEntryType('backend');
 
@@ -2381,103 +2381,103 @@ const SCALAR_FIELD_TYPES = [
     'enum',
 ];
 
-const {z: z$p} = await importShared('zod');
+const {z: z$r} = await importShared('zod');
 
 const VALIDATORS = {
-    PASCAL_CASE_STRING: z$p
+    PASCAL_CASE_STRING: z$r
         .string()
         .regex(/^[A-Z][a-zA-Z0-9]*$/, "Should be PascalCase, e.g. 'MyModel'"),
-    CAMEL_CASE_STRING: z$p
+    CAMEL_CASE_STRING: z$r
         .string()
         .regex(/^[a-z][a-zA-Z0-9]*$/, "Should be camelCase, e.g. 'myField'"),
-    CONSTANT_CASE_STRING: z$p
+    CONSTANT_CASE_STRING: z$r
         .string()
         .regex(/^[A-Z][A-Z0-9_]*$/, "Should be CONSTANT_CASE, e.g. 'MY_CONSTANT'"),
-    OPTIONAL_CONSTANT_CASE_STRING: z$p
+    OPTIONAL_CONSTANT_CASE_STRING: z$r
         .string()
         .regex(/^[A-Z][A-Z0-9_]*$/, "Should be CONSTANT_CASE, e.g. 'MY_CONSTANT'")
-        .or(z$p.literal(''))
+        .or(z$r.literal(''))
         .optional(),
 };
 
-const {z: z$o} = await importShared('zod');
-const createRoleArray = definitionSchema((ctx) => ctx.withDefault(z$o.array(ctx.withRef({
+const {z: z$q} = await importShared('zod');
+const createRoleArray = definitionSchema((ctx) => ctx.withDefault(z$q.array(ctx.withRef({
     type: authRoleEntityType,
     onDelete: 'DELETE',
 })), []));
 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({
+}, (ctx, { modelSlot }) => z$q.object({
+    objectType: ctx.withDefault(z$q.object({
+        enabled: ctx.withDefault(z$q.boolean(), false),
+        fields: ctx.withDefault(z$q.array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         })), []),
-        localRelations: ctx.withDefault(z$o.array(ctx.withRef({
+        localRelations: ctx.withDefault(z$q.array(ctx.withRef({
             type: modelLocalRelationEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         })), []),
-        foreignRelations: ctx.withDefault(z$o.array(ctx.withRef({
+        foreignRelations: ctx.withDefault(z$q.array(ctx.withRef({
             type: modelForeignRelationEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         })), []),
     }), {}),
-    queries: ctx.withDefault(z$o.object({
-        get: ctx.withDefault(z$o.object({
-            enabled: ctx.withDefault(z$o.boolean(), false),
+    queries: ctx.withDefault(z$q.object({
+        get: ctx.withDefault(z$q.object({
+            enabled: ctx.withDefault(z$q.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        list: ctx.withDefault(z$o.object({
-            enabled: ctx.withDefault(z$o.boolean(), false),
+        list: ctx.withDefault(z$q.object({
+            enabled: ctx.withDefault(z$q.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
     }), {}),
-    mutations: ctx.withDefault(z$o.object({
-        create: ctx.withDefault(z$o.object({
-            enabled: ctx.withDefault(z$o.boolean(), false),
+    mutations: ctx.withDefault(z$q.object({
+        create: ctx.withDefault(z$q.object({
+            enabled: ctx.withDefault(z$q.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        update: ctx.withDefault(z$o.object({
-            enabled: ctx.withDefault(z$o.boolean(), false),
+        update: ctx.withDefault(z$q.object({
+            enabled: ctx.withDefault(z$q.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
-        delete: ctx.withDefault(z$o.object({
-            enabled: ctx.withDefault(z$o.boolean(), false),
+        delete: ctx.withDefault(z$q.object({
+            enabled: ctx.withDefault(z$q.boolean(), false),
             roles: createRoleArray(ctx),
         }), {}),
     }), {}),
 }));
 
-const {z: z$n} = await importShared('zod');
+const {z: z$p} = await importShared('zod');
 
 const baseTransformerFields = {
-    id: z$n.string(),
-    type: z$n.string().min(1),
+    id: z$p.string(),
+    type: z$p.string().min(1),
 };
-const baseTransformerSchema = z$n.looseObject(baseTransformerFields);
+const baseTransformerSchema = z$p.looseObject(baseTransformerFields);
 function createModelTransformerType(payload) {
     return payload;
 }
 
-const {z: z$m} = await importShared('zod');
-const createEmbeddedRelationTransformerSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.refContext({ embeddedModelSlot: modelEntityType }, ({ embeddedModelSlot }) => ctx.withEnt(z$m.object({
+const {z: z$o} = await importShared('zod');
+const createEmbeddedRelationTransformerSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.refContext({ embeddedModelSlot: modelEntityType }, ({ embeddedModelSlot }) => ctx.withEnt(z$o.object({
     ...baseTransformerFields,
     foreignRelationRef: ctx.withRef({
         type: modelForeignRelationEntityType,
         onDelete: 'DELETE_PARENT',
         parentSlot: modelSlot,
     }),
-    type: z$m.literal('embeddedRelation'),
-    embeddedFieldNames: z$m.array(ctx.withRef({
+    type: z$o.literal('embeddedRelation'),
+    embeddedFieldNames: z$o.array(ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentSlot: embeddedModelSlot,
     })),
-    embeddedTransformerNames: z$m
+    embeddedTransformerNames: z$o
         .array(ctx.withRef({
         type: modelTransformerEntityType,
         onDelete: 'RESTRICT',
@@ -2537,54 +2537,54 @@ const modelTransformerSpec = createPluginSpec('core/model-transformer', {
     defaultInitializer: createModelTransformerImplementation,
 });
 
-const z$l = await importShared('zod');
+const z$n = await importShared('zod');
 const createTransformerSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => {
     const transformers = ctx.plugins
         .getPluginSpec(modelTransformerSpec)
         .getModelTransformers();
-    return z$l.discriminatedUnion('type', Object.values(transformers).map((transformer) => transformer.createSchema(ctx, slots)));
+    return z$n.discriminatedUnion('type', Object.values(transformers).map((transformer) => transformer.createSchema(ctx, slots)));
 });
 
-const {z: z$k} = await importShared('zod');
-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),
+const {z: z$m} = await importShared('zod');
+const createEnumValueSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => ctx.withEnt(z$m.object({
+    id: z$m.string(),
+    name: z$m.string().min(1),
+    friendlyName: z$m.string().min(1),
 }), {
     type: modelEnumValueEntityType,
     parentSlot: enumSlot,
 }));
-const createEnumBaseSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => z$k.object({
-    id: z$k.string(),
-    name: z$k.string().min(1),
+const createEnumBaseSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => z$m.object({
+    id: z$m.string(),
+    name: z$m.string().min(1),
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    values: z$k.array(createEnumValueSchema(ctx, { enumSlot })),
-    isExposed: z$k.boolean(),
+    values: z$m.array(createEnumValueSchema(ctx, { enumSlot })),
+    isExposed: z$m.boolean(),
 }));
 const createEnumSchema = definitionSchema((ctx) => ctx.refContext({ enumSlot: modelEnumEntityType }, ({ enumSlot }) => ctx.withEnt(createEnumBaseSchema(ctx, { enumSlot }), {
     type: modelEnumEntityType,
     provides: enumSlot,
 })));
 
-const {z: z$j} = await importShared('zod');
+const {z: z$l} = await importShared('zod');
 const createModelScalarFieldSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx
-    .withEnt(z$j.object({
-    id: z$j.string(),
+    .withEnt(z$l.object({
+    id: z$l.string(),
     name: VALIDATORS.CAMEL_CASE_STRING,
-    type: z$j.enum(SCALAR_FIELD_TYPES),
-    isOptional: z$j.boolean().default(false),
-    options: ctx.refContext({ enumSlot: modelEnumEntityType }, ({ enumSlot }) => z$j
+    type: z$l.enum(SCALAR_FIELD_TYPES),
+    isOptional: z$l.boolean().default(false),
+    options: ctx.refContext({ enumSlot: modelEnumEntityType }, ({ enumSlot }) => z$l
         .object({
         // string options
-        default: z$j.string().default(''),
+        default: z$l.string().default(''),
         // uuid options
-        genUuid: z$j.boolean().optional(),
+        genUuid: z$l.boolean().optional(),
         // date options
-        updatedAt: z$j.boolean().optional(),
-        defaultToNow: z$j.boolean().optional(),
+        updatedAt: z$l.boolean().optional(),
+        defaultToNow: z$l.boolean().optional(),
         // enum options
         enumRef: ctx
             .withRef({
@@ -2644,13 +2644,13 @@ const REFERENTIAL_ACTIONS = [
     'SetNull',
     'SetDefault',
 ];
-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
+const createModelRelationFieldSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.refContext({ foreignModelSlot: modelEntityType }, ({ foreignModelSlot }) => ctx.withEnt(ctx.withEnt(z$l.object({
+    id: z$l.string(),
+    foreignId: z$l
         .string()
         .default(() => modelForeignRelationEntityType.generateNewId()),
     name: VALIDATORS.CAMEL_CASE_STRING,
-    references: z$j.array(z$j.object({
+    references: z$l.array(z$l.object({
         localRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
@@ -2668,8 +2668,8 @@ const createModelRelationFieldSchema = definitionSchemaWithSlots({ modelSlot: mo
         provides: foreignModelSlot,
     }),
     foreignRelationName: VALIDATORS.CAMEL_CASE_STRING,
-    onDelete: z$j.enum(REFERENTIAL_ACTIONS).default('Cascade'),
-    onUpdate: z$j.enum(REFERENTIAL_ACTIONS).default('Restrict'),
+    onDelete: z$l.enum(REFERENTIAL_ACTIONS).default('Cascade'),
+    onUpdate: z$l.enum(REFERENTIAL_ACTIONS).default('Restrict'),
 }), {
     type: modelLocalRelationEntityType,
     parentSlot: modelSlot,
@@ -2679,9 +2679,9 @@ const createModelRelationFieldSchema = definitionSchemaWithSlots({ modelSlot: mo
     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({
+const createModelUniqueConstraintSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => ctx.withEnt(z$l.object({
+    id: z$l.string(),
+    fields: z$l.array(z$l.object({
         fieldRef: ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
@@ -2698,18 +2698,18 @@ const createModelUniqueConstraintSchema = definitionSchemaWithSlots({ modelSlot:
         });
     },
 }));
-const createModelServiceSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => z$j.object({
-    create: z$j
+const createModelServiceSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => z$l.object({
+    create: z$l
         .object({
-        enabled: z$j.boolean().default(false),
-        fields: z$j
+        enabled: z$l.boolean().default(false),
+        fields: z$l
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         }))
             .optional(),
-        transformerNames: z$j
+        transformerNames: z$l
             .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
@@ -2718,17 +2718,17 @@ const createModelServiceSchema = definitionSchemaWithSlots({ modelSlot: modelEnt
             .optional(),
     })
         .default({ enabled: false }),
-    update: z$j
+    update: z$l
         .object({
-        enabled: z$j.boolean().default(false),
-        fields: z$j
+        enabled: z$l.boolean().default(false),
+        fields: z$l
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'DELETE',
             parentSlot: modelSlot,
         }))
             .optional(),
-        transformerNames: z$j
+        transformerNames: z$l
             .array(ctx.withRef({
             type: modelTransformerEntityType,
             onDelete: 'DELETE',
@@ -2737,37 +2737,37 @@ const createModelServiceSchema = definitionSchemaWithSlots({ modelSlot: modelEnt
             .optional(),
     })
         .default({ enabled: false }),
-    delete: z$j
+    delete: z$l
         .object({
-        enabled: z$j.boolean().default(false),
+        enabled: z$l.boolean().default(false),
     })
         .default({
         enabled: false,
     }),
-    transformers: z$j
+    transformers: z$l
         .array(createTransformerSchema(ctx, { modelSlot }))
         .default([]),
 }));
-const createModelBaseSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => z$j.object({
-    id: z$j.string(),
+const createModelBaseSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, slots) => z$l.object({
+    id: z$l.string(),
     name: VALIDATORS.PASCAL_CASE_STRING,
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    model: z$j.object({
-        fields: z$j.array(createModelScalarFieldSchema(ctx, slots)),
-        relations: z$j
+    model: z$l.object({
+        fields: z$l.array(createModelScalarFieldSchema(ctx, slots)),
+        relations: z$l
             .array(createModelRelationFieldSchema(ctx, slots))
             .optional(),
-        primaryKeyFieldRefs: z$j
+        primaryKeyFieldRefs: z$l
             .array(ctx.withRef({
             type: modelScalarFieldEntityType,
             onDelete: 'RESTRICT',
             parentSlot: slots.modelSlot,
         }))
             .min(1),
-        uniqueConstraints: z$j
+        uniqueConstraints: z$l
             .array(createModelUniqueConstraintSchema(ctx, slots))
             .optional(),
     }),
@@ -2791,26 +2791,26 @@ const adminCrudSectionColumnEntityType = createEntityType('admin-crud-section-co
     parentType: adminSectionEntityType,
 });
 
-const {z: z$i} = await importShared('zod');
-const createBaseAdminSectionValidators = definitionSchema((ctx) => z$i.object({
-    id: z$i.string().default(adminSectionEntityType.generateNewId()),
-    name: z$i.string().min(1),
+const {z: z$k} = await importShared('zod');
+const createBaseAdminSectionValidators = definitionSchema((ctx) => z$k.object({
+    id: z$k.string().default(adminSectionEntityType.generateNewId()),
+    name: z$k.string().min(1),
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    icon: z$i.string().optional(),
-    type: z$i.string().min(1),
+    icon: z$k.string().optional(),
+    type: z$k.string().min(1),
 }));
 
-const {z: z$h} = await importShared('zod');
-const baseAdminCrudActionSchema = z$h.looseObject({
-    id: z$h
+const {z: z$j} = await importShared('zod');
+const baseAdminCrudActionSchema = z$j.looseObject({
+    id: z$j
         .string()
         .min(1)
         .default(() => adminCrudActionEntityType.generateNewId()),
-    type: z$h.string().min(1),
-    position: z$h.enum(['inline', 'dropdown']).default('dropdown'),
+    type: z$j.string().min(1),
+    position: z$j.enum(['inline', 'dropdown']).default('dropdown'),
 });
 function createAdminCrudActionType(payload) {
     return payload;
@@ -2819,16 +2819,16 @@ const adminCrudActionEntityType = createEntityType('admin-crud-action', {
     parentType: adminSectionEntityType,
 });
 
-const {z: z$g} = await importShared('zod');
+const {z: z$i} = await importShared('zod');
 const createAdminCrudEditActionSchema = definitionSchema(() => baseAdminCrudActionSchema.extend({
-    type: z$g.literal('edit'),
+    type: z$i.literal('edit'),
 }));
 const adminCrudEditActionType = createAdminCrudActionType({
     name: 'edit',
     createSchema: createAdminCrudEditActionSchema,
 });
 const createAdminCrudDeleteActionSchema = definitionSchema(() => baseAdminCrudActionSchema.extend({
-    type: z$g.literal('delete'),
+    type: z$i.literal('delete'),
 }));
 const adminCrudDeleteActionType = createAdminCrudActionType({
     name: 'delete',
@@ -2879,14 +2879,14 @@ const createAdminCrudActionSchema = definitionSchema((ctx) => {
     });
 });
 
-const {z: z$f} = await importShared('zod');
-const baseAdminCrudColumnSchema = z$f.looseObject({
-    id: z$f
+const {z: z$h} = await importShared('zod');
+const baseAdminCrudColumnSchema = z$h.looseObject({
+    id: z$h
         .string()
         .min(1)
         .default(() => adminCrudColumnEntityType.generateNewId()),
-    type: z$f.string().min(1),
-    label: z$f.string().min(1),
+    type: z$h.string().min(1),
+    label: z$h.string().min(1),
 });
 function createAdminCrudColumnType(payload) {
     return payload;
@@ -2895,10 +2895,10 @@ const adminCrudColumnEntityType = createEntityType('admin-crud-column', {
     parentType: adminSectionEntityType,
 });
 
-const {z: z$e} = await importShared('zod');
+const {z: z$g} = await importShared('zod');
 // Text Column
 const createAdminCrudTextColumnSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => baseAdminCrudColumnSchema.extend({
-    type: z$e.literal('text'),
+    type: z$g.literal('text'),
     modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
@@ -2911,14 +2911,14 @@ const adminCrudTextColumnType = createAdminCrudColumnType({
 });
 // Foreign Column
 const createAdminCrudForeignColumnSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType }, (ctx, { modelSlot }) => baseAdminCrudColumnSchema.extend({
-    type: z$e.literal('foreign'),
+    type: z$g.literal('foreign'),
     localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
         parentSlot: modelSlot,
     }),
-    labelExpression: z$e.string().min(1),
-    valueExpression: z$e.string().min(1),
+    labelExpression: z$g.string().min(1),
+    valueExpression: z$g.string().min(1),
 }));
 const adminCrudForeignColumnType = createAdminCrudColumnType({
     name: 'foreign',
@@ -2969,14 +2969,14 @@ const createAdminCrudColumnSchema = definitionSchemaWithSlots({ modelSlot: model
     });
 });
 
-const {z: z$d} = await importShared('zod');
-const baseAdminCrudInputSchema = z$d.looseObject({
-    id: z$d
+const {z: z$f} = await importShared('zod');
+const baseAdminCrudInputSchema = z$f.looseObject({
+    id: z$f
         .string()
         .min(1)
         .default(() => adminCrudInputEntityType.generateNewId()),
-    type: z$d.string().min(1),
-    label: z$d.string().min(1),
+    type: z$f.string().min(1),
+    label: z$f.string().min(1),
 });
 function createAdminCrudInputType(payload) {
     return payload;
@@ -2988,41 +2988,41 @@ const adminCrudInputEntityType = createEntityType('admin-crud-input', {
     parentType: adminSectionEntityType,
 });
 
-const {z: z$c} = await importShared('zod');
+const {z: z$e} = await importShared('zod');
 const createAdminCrudTextInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$c.literal('text'),
-    label: z$c.string().min(1),
+    type: z$e.literal('text'),
+    label: z$e.string().min(1),
     modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
         parentSlot: modelSlot,
     }),
-    validation: z$c.string().optional(),
+    validation: z$e.string().optional(),
 }));
 const adminCrudTextInputType = createAdminCrudInputType({
     name: 'text',
     createSchema: createAdminCrudTextInputSchema,
 });
 const createAdminCrudForeignInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$c.literal('foreign'),
-    label: z$c.string().min(1),
+    type: z$e.literal('foreign'),
+    label: z$e.string().min(1),
     localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
         parentSlot: modelSlot,
     }),
-    labelExpression: z$c.string().min(1),
-    valueExpression: z$c.string().min(1),
-    defaultLabel: z$c.string().optional(),
-    nullLabel: z$c.string().optional(),
+    labelExpression: z$e.string().min(1),
+    valueExpression: z$e.string().min(1),
+    defaultLabel: z$e.string().optional(),
+    nullLabel: z$e.string().optional(),
 }));
 const adminCrudForeignInputType = createAdminCrudInputType({
     name: 'foreign',
     createSchema: createAdminCrudForeignInputSchema,
 });
 const createAdminCrudEnumInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$c.literal('enum'),
-    label: z$c.string().min(1),
+    type: z$e.literal('enum'),
+    label: z$e.string().min(1),
     modelFieldRef: ctx.withRef({
         type: modelScalarFieldEntityType,
         onDelete: 'RESTRICT',
@@ -3034,8 +3034,8 @@ const adminCrudEnumInputType = createAdminCrudInputType({
     createSchema: createAdminCrudEnumInputSchema,
 });
 const createAdminCrudEmbeddedInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$c.literal('embedded'),
-    label: z$c.string().min(1),
+    type: z$e.literal('embedded'),
+    label: z$e.string().min(1),
     modelRelationRef: ctx.withRef({
         type: modelForeignRelationEntityType,
         onDelete: 'RESTRICT',
@@ -3052,8 +3052,8 @@ const adminCrudEmbeddedInputType = createAdminCrudInputType({
     createSchema: createAdminCrudEmbeddedInputSchema,
 });
 const createAdminCrudEmbeddedLocalInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => baseAdminCrudInputSchema.extend({
-    type: z$c.literal('embeddedLocal'),
-    label: z$c.string().min(1),
+    type: z$e.literal('embeddedLocal'),
+    label: z$e.string().min(1),
     localRelationRef: ctx.withRef({
         type: modelLocalRelationEntityType,
         onDelete: 'RESTRICT',
@@ -3070,8 +3070,8 @@ const adminCrudEmbeddedLocalInputType = createAdminCrudInputType({
     createSchema: createAdminCrudEmbeddedLocalInputSchema,
 });
 const createAdminCrudPasswordInputSchema = definitionSchema(() => baseAdminCrudInputSchema.extend({
-    type: z$c.literal('password'),
-    label: z$c.string().min(1),
+    type: z$e.literal('password'),
+    label: z$e.string().min(1),
 }));
 const adminCrudPasswordInputType = createAdminCrudInputType({
     name: 'password',
@@ -3126,40 +3126,40 @@ const createAdminCrudInputSchema = definitionSchemaWithSlots({ modelSlot: modelE
     });
 });
 
-const {z: z$b} = await importShared('zod');
+const {z: z$d} = await importShared('zod');
 // Embedded Crud
-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),
+const createAdminCrudEmbeddedObjectSchemaInternal = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => z$d.object({
+    id: z$d.string().min(1),
+    name: z$d.string().min(1),
     modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
         provides: modelSlot,
     }),
-    includeIdField: z$b.boolean().optional(),
-    type: z$b.literal('object'),
-    form: z$b.object({
-        fields: z$b.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
+    includeIdField: z$d.boolean().optional(),
+    type: z$d.literal('object'),
+    form: z$d.object({
+        fields: z$d.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
     }),
 }));
-const createAdminCrudEmbeddedListSchemaInternal = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => z$b.object({
-    id: z$b.string().min(1),
-    name: z$b.string().min(1),
+const createAdminCrudEmbeddedListSchemaInternal = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, { modelSlot, adminSectionSlot }) => z$d.object({
+    id: z$d.string().min(1),
+    name: z$d.string().min(1),
     modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
         provides: modelSlot,
     }),
-    includeIdField: z$b.boolean().optional(),
-    type: z$b.literal('list'),
-    table: z$b.object({
-        columns: z$b.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
+    includeIdField: z$d.boolean().optional(),
+    type: z$d.literal('list'),
+    table: z$d.object({
+        columns: z$d.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
     }),
-    form: z$b.object({
-        fields: z$b.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
+    form: z$d.object({
+        fields: z$d.array(createAdminCrudInputSchema(ctx, { modelSlot, adminSectionSlot })),
     }),
 }));
-const createAdminCrudEmbeddedFormSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => ctx.withEnt(z$b.discriminatedUnion('type', [
+const createAdminCrudEmbeddedFormSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => ctx.withEnt(z$d.discriminatedUnion('type', [
     createAdminCrudEmbeddedObjectSchemaInternal(ctx, {
         modelSlot,
         adminSectionSlot,
@@ -3173,8 +3173,8 @@ const createAdminCrudEmbeddedFormSchema = definitionSchemaWithSlots({ adminSecti
     parentSlot: adminSectionSlot,
 })));
 // Admin Section
-const createAdminCrudSectionSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => createBaseAdminSectionValidators(ctx).and(z$b.object({
-    type: z$b.literal('crud'),
+const createAdminCrudSectionSchema = definitionSchemaWithSlots({ adminSectionSlot: adminSectionEntityType }, (ctx, { adminSectionSlot }) => ctx.refContext({ modelSlot: modelEntityType }, ({ modelSlot }) => createBaseAdminSectionValidators(ctx).and(z$d.object({
+    type: z$d.literal('crud'),
     modelRef: ctx.withRef({
         type: modelEntityType,
         onDelete: 'RESTRICT',
@@ -3186,54 +3186,76 @@ const createAdminCrudSectionSchema = definitionSchemaWithSlots({ adminSectionSlo
         onDelete: 'RESTRICT',
         parentSlot: modelSlot,
     }),
-    disableCreate: ctx.withDefault(z$b.boolean(), false),
-    table: z$b.object({
-        columns: z$b.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
-        actions: ctx.withDefault(z$b.array(createAdminCrudActionSchema(ctx)), [
+    disableCreate: ctx.withDefault(z$d.boolean(), false),
+    table: z$d.object({
+        columns: z$d.array(createAdminCrudColumnSchema(ctx, { modelSlot })),
+        actions: ctx.withDefault(z$d.array(createAdminCrudActionSchema(ctx)), [
             { type: 'edit', position: 'inline' },
             { type: 'delete', position: 'dropdown' },
         ]),
     }),
-    form: z$b.object({
-        fields: z$b.array(createAdminCrudInputSchema(ctx, {
+    form: z$d.object({
+        fields: z$d.array(createAdminCrudInputSchema(ctx, {
             modelSlot,
             adminSectionSlot,
         })),
     }),
-    embeddedForms: z$b
+    embeddedForms: z$d
         .array(createAdminCrudEmbeddedFormSchema(ctx, { adminSectionSlot }))
         .optional(),
 }))));
 
-const {z: z$a} = await importShared('zod');
+const {z: z$c} = await importShared('zod');
 const createWebAdminSectionSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => ctx.refContext({ adminSectionSlot: adminSectionEntityType }, ({ adminSectionSlot }) => ctx.withEnt(createAdminCrudSectionSchema(ctx, { adminSectionSlot }), {
     type: adminSectionEntityType,
     parentSlot: appSlot,
     provides: adminSectionSlot,
 })));
-const createAdminAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => ctx.withDefault(z$a.object({
-    enabled: z$a.boolean(),
-    pathPrefix: z$a.string().default('/admin'),
-    allowedRoles: ctx.withDefault(z$a.array(ctx.withRef({
+const createAdminAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => ctx.withDefault(z$c.object({
+    enabled: z$c.boolean(),
+    pathPrefix: z$c.string().default('/admin'),
+    allowedRoles: ctx.withDefault(z$c.array(ctx.withRef({
         type: authRoleEntityType,
         onDelete: 'DELETE',
     })), []),
-    sections: ctx.withDefault(z$a.array(createWebAdminSectionSchema(ctx, { appSlot })), []),
+    sections: ctx.withDefault(z$c.array(createWebAdminSectionSchema(ctx, { appSlot })), []),
 }), { enabled: false, pathPrefix: '/admin' }));
 
-const {z: z$9} = await importShared('zod');
-const createWebAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => z$9.object({
+const {z: z$b} = await importShared('zod');
+const createWebAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => z$b.object({
     ...baseAppValidators,
-    type: z$9.literal('web'),
-    includeAuth: ctx.withDefault(z$9.boolean(), false),
-    title: z$9.string().default(''),
-    description: z$9.string().default(''),
-    includeUploadComponents: ctx.withDefault(z$9.boolean(), false),
-    enableSubscriptions: ctx.withDefault(z$9.boolean(), false),
+    type: z$b.literal('web'),
+    includeAuth: ctx.withDefault(z$b.boolean(), false),
+    title: z$b.string().default(''),
+    description: z$b.string().default(''),
+    includeUploadComponents: ctx.withDefault(z$b.boolean(), false),
+    enableSubscriptions: ctx.withDefault(z$b.boolean(), false),
     adminApp: createAdminAppSchema(ctx, { appSlot }),
 }));
 const webAppEntryType = createAppEntryType('web');
 
+const packageEntityType = createEntityType('package');
+function createPackageEntryType(name) {
+    return name;
+}
+
+const {CASE_VALIDATORS: CASE_VALIDATORS$2} = await importShared('@baseplate-dev/utils');
+
+const {z: z$a} = await importShared('zod');
+const basePackageValidators = {
+    id: z$a.string().default(packageEntityType.generateNewId()),
+    name: CASE_VALIDATORS$2.KEBAB_CASE,
+    type: z$a.string(),
+};
+const basePackageSchema = z$a.object(basePackageValidators);
+
+const {z: z$9} = await importShared('zod');
+const createNodeLibraryPackageSchema = definitionSchemaWithSlots({ packageSlot: packageEntityType }, () => z$9.object({
+    ...basePackageValidators,
+    type: z$9.literal('node-library'),
+}));
+const nodeLibraryPackageEntryType = createPackageEntryType('node-library');
+
 const {z: z$8} = await importShared('zod');
 const basePluginDefinitionSchema = z$8.object({
     id: z$8.string(),
@@ -3343,7 +3365,6 @@ const {z: z$5} = await importShared('zod');
  * Monorepo settings schema
  *
  * Configures the folder structure for monorepo packages.
- * In V1, only supports configuring the apps folder location.
  */
 const monorepoSettingsSchema = z$5.object({
     /**
@@ -3362,6 +3383,22 @@ const monorepoSettingsSchema = z$5.object({
         message: 'Apps folder must contain only lowercase letters, numbers, and dashes (no slashes)',
     })
         .default('apps'),
+    /**
+     * The folder where library packages are located in the monorepo.
+     *
+     * Must be in kebab-case format (lowercase letters and dashes only).
+     * Packages will be placed in {packagesFolder}/{package-name}, e.g. "packages/shared-utils".
+     *
+     * @default "packages"
+     * @example "packages" → packages/shared-utils, packages/common
+     * @example "libs" → libs/shared-utils, libs/common
+     */
+    packagesFolder: CASE_VALIDATORS.KEBAB_CASE.min(1)
+        .max(50)
+        .regex(/^[a-z0-9-]+$/, {
+        message: 'Packages folder must contain only lowercase letters, numbers, and dashes (no slashes)',
+    })
+        .default('packages'),
 });
 
 const {z: z$4} = await importShared('zod');
@@ -3553,9 +3590,17 @@ const createAppSchema = definitionSchema((ctx) => ctx.refContext({ appSlot: appE
     type: appEntityType,
     provides: appSlot,
 })));
+const createPackageSchema = definitionSchema((ctx) => ctx.refContext({ packageSlot: packageEntityType }, ({ packageSlot }) => ctx.withEnt(z$1.discriminatedUnion('type', [
+    createNodeLibraryPackageSchema(ctx, { packageSlot }),
+    // Future: add more package types here
+]), {
+    type: packageEntityType,
+    provides: packageSlot,
+})));
 const createProjectDefinitionSchema = definitionSchema((ctx) => z$1.object({
     cliVersion: z$1.string().nullish(),
     apps: z$1.array(createAppSchema(ctx)).default([]),
+    packages: z$1.array(createPackageSchema(ctx)).default([]),
     features: createFeaturesSchema(ctx),
     models: z$1.array(createModelSchema(ctx)).default([]),
     enums: z$1.array(createEnumSchema(ctx)).optional(),
@@ -3565,18 +3610,18 @@ const createProjectDefinitionSchema = definitionSchema((ctx) => z$1.object({
     settings: createSettingsSchema(ctx),
 }));
 
-function byId(projectDefinition, id) {
+function byId$1(projectDefinition, id) {
     return projectDefinition.enums?.find((e) => e.id === id);
 }
 function byIdOrThrow(projectDefinition, id) {
-    const enumConfig = byId(projectDefinition, id);
+    const enumConfig = byId$1(projectDefinition, id);
     if (!enumConfig) {
         throw new Error(`Could not find enum with ID ${id}`);
     }
     return enumConfig;
 }
 const EnumUtils = {
-    byId,
+    byId: byId$1,
     byIdOrThrow,
 };
 
@@ -3602,6 +3647,13 @@ function getRelationLocalFields(model, relation) {
         return field;
     });
 }
+function relationByIdOrThrow(model, relationId) {
+    const relation = model.model.relations?.find((r) => r.id === relationId);
+    if (!relation) {
+        throw new Error(`Relation ${relationId} not found in model ${model.name}`);
+    }
+    return relation;
+}
 function isRelationOptional(model, relation) {
     const localFields = getRelationLocalFields(model, relation);
     return localFields.some((f) => f.isOptional);
@@ -3657,6 +3709,7 @@ const ModelFieldUtils = {
     isRelationOptional,
     isRelationOneToOne,
     getModelFieldValidation,
+    relationByIdOrThrow,
 };
 
 function getTransformer(transformer, pluginStore) {
@@ -3671,6 +3724,29 @@ function getTransformName(definitionContainer, transformer, pluginStore) {
 }
 const ModelTransformerUtils = { getTransformer, getTransformName };
 
+function byId(projectDefinition, id) {
+    const config = projectDefinition.packages.find((pkg) => pkg.id === id);
+    if (!config) {
+        throw new Error(`Unable to find package with ID ${id}`);
+    }
+    return config;
+}
+/**
+ * Given a package config, get the relative directory of the package
+ *
+ * @param packageConfig The package config
+ * @param monorepoSettings Optional monorepo settings to determine packages folder location
+ * @returns The directory of the package
+ */
+function getPackageDirectory(packageConfig, monorepoSettings) {
+    const packagesFolder = monorepoSettings?.packagesFolder ?? 'packages';
+    return `${packagesFolder}/${packageConfig.name}`;
+}
+const PackageUtils = {
+    byId,
+    getPackageDirectory,
+};
+
 const {z} = await importShared('zod');
 const COMMON_SPEC_IMPLEMENTATIONS = [
     pluginConfigSpec,
@@ -9339,6 +9415,7 @@ function createTestProjectDefinition(input = {}) {
         features: [],
         cliVersion: '1.0.0',
         apps: [],
+        packages: [],
         models: [],
         isInitialized: true,
         schemaVersion: getLatestMigrationVersion(),
@@ -10426,5 +10503,5 @@ function generateDefaultTheme() {
     };
 }
 
-export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_ACTIONS, BUILT_IN_ADMIN_CRUD_COLUMNS, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, 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
+export { AVAILABLE_FLAGS, AppUtils, BUILT_IN_ADMIN_CRUD_ACTIONS, BUILT_IN_ADMIN_CRUD_COLUMNS, BUILT_IN_ADMIN_CRUD_INPUTS, BUILT_IN_TRANSFORMERS, COLOR_PALETTES, EnumUtils, FIXED_COLOR_MAPPINGS, ModelFieldUtils, ModelTransformerUtils, ModelUtils, PALETTE_SHADES, PackageUtils, PluginImplementationStore, PluginUtils, ProjectDefinitionContainer, REFERENTIAL_ACTIONS, SCALAR_FIELD_TYPES, SCHEMA_MIGRATIONS, SchemaMigrationError, THEME_COLORS, THEME_COLOR_KEYS, VALIDATORS, adminCrudActionCompilerSpec, adminCrudActionEntityType, adminCrudActionSpec, adminCrudColumnCompilerSpec, adminCrudColumnEntityType, adminCrudColumnSpec, adminCrudEmbeddedFormEntityType, adminCrudEmbeddedInputType, adminCrudEmbeddedLocalInputType, adminCrudInputCompilerSpec, adminCrudInputEntityType, adminCrudInputSpec, adminCrudSectionColumnEntityType, adminSectionEntityType, appCompilerSpec, appEntityType, authConfigSpec, authModelConfigSpec, authRoleEntityType, backendAppEntryType, baseAdminCrudActionSchema, baseAdminCrudColumnSchema, baseAdminCrudInputSchema, baseAppSchema, baseAppValidators, basePackageSchema, basePackageValidators, basePluginDefinitionSchema, baseTransformerFields, baseTransformerSchema, convertColorNameToOklch, convertHexToOklch, convertOklchToColorName, convertOklchToHex, createAdminAppSchema, createAdminCrudActionCompilerImplementation, createAdminCrudActionImplementation, createAdminCrudActionSchema, createAdminCrudActionType, createAdminCrudColumnCompiler, createAdminCrudColumnCompilerImplementation, createAdminCrudColumnImplementation, createAdminCrudColumnSchema, createAdminCrudColumnType, createAdminCrudDeleteActionSchema, createAdminCrudEditActionSchema, createAdminCrudEmbeddedFormSchema, createAdminCrudEmbeddedInputSchema, createAdminCrudEmbeddedLocalInputSchema, createAdminCrudEnumInputSchema, createAdminCrudForeignColumnSchema, createAdminCrudForeignInputSchema, createAdminCrudInputCompilerImplementation, createAdminCrudInputImplementation, createAdminCrudInputSchema, createAdminCrudInputType, createAdminCrudPasswordInputSchema, createAdminCrudSectionSchema, createAdminCrudTextColumnSchema, createAdminCrudTextInputSchema, createAppCompiler, createAppCompilerPlugin, createAppEntryType, createAppSchema, createBackendAppSchema, createBaseAdminSectionValidators, createDefinitionEntityNameResolver, createDefinitionSchemaParserContext, createEmbeddedRelationTransformerSchema, createEntityType, createEnumBaseSchema, createEnumSchema, createEnumValueSchema, createFeaturesSchema, createModelBaseSchema, createModelGraphqlSchema, createModelRelationFieldSchema, createModelScalarFieldSchema, createModelSchema, createModelServiceSchema, createModelTransformerCompilerImplementation, createModelTransformerImplementation, createModelTransformerType, createModelUniqueConstraintSchema, createNodeLibraryPackageSchema, createPackageEntryType, createPackageSchema, createPlatformPluginExport, createPluginConfigImplementation, createPluginImplementationStore, createPluginImplementationStoreWithNewPlugins, createPluginSpec, createPluginWithConfigSchema, createPluginsSchema, createProjectDefinitionSchema, createProjectDefinitionSchemaWithContext, createSettingsSchema, createTemplateExtractorSchema, createTestProjectDefinition, createTestProjectDefinitionContainer, createTestProjectDefinitionInput, createThemeSchema, createTransformerSchema, createWebAdminSectionSchema, createWebAppSchema, createWebConfigImplementation, definitionSchema, definitionSchemaWithSlots, deserializeSchemaWithTransformedReferences, extractDefinitionRefs, featureEntityType, fixRefDeletions, generalSettingsSchema, generateCssFromThemeConfig, generateDefaultTheme, generateThemeColorsFromShade, getBackendRelativePath, getDefaultThemeColorFromShade, getLatestMigrationVersion, getManagedPluginsForPlugin, getPluginMetadataByKey, getPluginMetadataByKeyOrThrow, infrastructureSettingsSchema, initializePlugins, isMigrateableProjectDefinition, modelEntityType, modelEnumEntityType, modelEnumValueEntityType, modelForeignRelationEntityType, modelLocalRelationEntityType, modelScalarFieldEntityType, modelTransformerCompilerSpec, modelTransformerEntityType, modelTransformerSpec, modelUniqueConstraintEntityType, monorepoSettingsSchema, nodeLibraryPackageEntryType, oklchColor, packageEntityType, paletteSchema, palettesSchema, parseOklch, parseProjectDefinitionWithContext, parseProjectDefinitionWithReferences, pluginConfigSpec, pluginEntityType, pluginMetadataSchema, pluginSpecDependencySchema, pluginSpecSupportSchema, runPluginMigrations, runSchemaMigrations, serializeSchema, serializeSchemaFromRefPayload, stripEmptyGeneratorChildren, stripUndefinedValues, themeColorSchema, undefinedIfEmpty, undefinedIfFalsy, webAppEntryType, webConfigSpec };
+//# sourceMappingURL=project-builder-lib-CcNtL_U6.js.map