@baseplate-dev/project-builder-lib 0.5.3 → 0.6.1

package/dist/schema/apps/web/admin/sections/crud-form/admin-crud-input.d.ts

@@ -1,19 +1,13 @@
-export declare const createAdminCrudInputSchema: import("../../../../../index.js").DefinitionSchemaCreatorWithSlots<import("zod").ZodPipe<import("zod").ZodObject<{
-    id: import("zod").ZodDefault<import("zod").ZodString>;
-    type: import("zod").ZodString;
-    label: import("zod").ZodString;
-}, import("zod/v4/core").$loose>, import("zod").ZodTransform<{
-    [x: string]: unknown;
-    id: string;
-    type: string;
-    label: string;
-}, {
-    [x: string]: unknown;
-    id: string;
-    type: string;
-    label: string;
-}>>, {
+import z from 'zod';
+import type { def } from '#src/schema/creator/index.js';
+export declare const createAdminCrudInputSchema: import("#src/schema/creator/index.js").DefinitionSchemaCreatorWithSlots<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    type: z.ZodString;
+    label: z.ZodString;
+}, z.z.core.$loose>], "type">, {
     modelSlot: import("../../../../../../index.js").DefinitionEntityType<false>;
     adminSectionSlot: import("../../../../../../index.js").DefinitionEntityType<true>;
 }>;
+export type AdminCrudInputConfig = def.InferOutput<typeof createAdminCrudInputSchema>;
+export type AdminCrudInputConfigInput = def.InferInput<typeof createAdminCrudInputSchema>;
 //# sourceMappingURL=admin-crud-input.d.ts.map

package/dist/schema/apps/web/admin/sections/crud-form/admin-crud-input.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"admin-crud-input.d.ts","sourceRoot":"","sources":["../../../../../../../src/schema/apps/web/admin/sections/crud-form/admin-crud-input.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;EAWtC,CAAC"}
+{"version":3,"file":"admin-crud-input.d.ts","sourceRoot":"","sources":["../../../../../../../src/schema/apps/web/admin/sections/crud-form/admin-crud-input.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAUxD,eAAO,MAAM,0BAA0B;;;;;;;EAWtC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,GAAG,CAAC,WAAW,CAChD,OAAO,0BAA0B,CAClC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,GAAG,CAAC,UAAU,CACpD,OAAO,0BAA0B,CAClC,CAAC"}

package/dist/schema/apps/web/admin/sections/crud-form/admin-crud-input.js

@@ -1,15 +1,10 @@
+import z from 'zod';
 import { definitionSchemaWithSlots } from '#src/schema/creator/schema-creator.js';
 import { modelEntityType } from '#src/schema/models/index.js';
 import { adminSectionEntityType } from '../types.js';
 import { adminCrudInputSpec } from './admin-input-spec.js';
-import { baseAdminCrudInputSchema } from './types.js';
 export const createAdminCrudInputSchema = definitionSchemaWithSlots({ modelSlot: modelEntityType, adminSectionSlot: adminSectionEntityType }, (ctx, slots) => {
-    const adminCrudInputs = ctx.plugins.use(adminCrudInputSpec).inputs;
-    return baseAdminCrudInputSchema.transform((data) => {
-        const inputDef = adminCrudInputs.get(data.type);
-        if (!inputDef)
-            return data;
-        return inputDef.createSchema(ctx, slots).parse(data);
-    });
+    const { inputs } = ctx.plugins.use(adminCrudInputSpec);
+    return z.discriminatedUnion('type', [...inputs.values()].map((input) => input.createSchema(ctx, slots)));
 });
 //# sourceMappingURL=admin-crud-input.js.map

package/dist/schema/apps/web/admin/sections/crud-form/admin-crud-input.js.map

@@ -1 +1 @@
-{"version":3,"file":"admin-crud-input.js","sourceRoot":"","sources":["../../../../../../../src/schema/apps/web/admin/sections/crud-form/admin-crud-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEtD,MAAM,CAAC,MAAM,0BAA0B,GAAG,yBAAyB,CACjE,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,EACxE,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;IACb,MAAM,eAAe,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC;IAEnE,OAAO,wBAAwB,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;QACjD,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChD,IAAI,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC;QAC3B,OAAO,QAAQ,CAAC,YAAY,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;AACL,CAAC,CACF,CAAC"}
+{"version":3,"file":"admin-crud-input.js","sourceRoot":"","sources":["../../../../../../../src/schema/apps/web/admin/sections/crud-form/admin-crud-input.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAI9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,MAAM,CAAC,MAAM,0BAA0B,GAAG,yBAAyB,CACjE,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,EACxE,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;IACb,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;IACvD,OAAO,CAAC,CAAC,kBAAkB,CACzB,MAAM,EACN,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,EAAE,KAAK,CAAC,CAEjE,CACF,CAAC;AACJ,CAAC,CACF,CAAC"}

package/dist/schema/apps/web/admin/sections/crud.d.ts

@@ -159,6 +159,7 @@ export declare const createAdminCrudSectionSchema: import("#src/schema/creator/i
     type: "crud";
     modelRef: string;
     nameFieldRef: string;
+    disableCreate: boolean;
     table: {
         columns: {
             [x: string]: unknown;
@@ -166,12 +167,12 @@ export declare const createAdminCrudSectionSchema: import("#src/schema/creator/i
             type: string;
             label: string;
         }[];
-        actions?: {
+        actions: {
             [x: string]: unknown;
             id: string;
             type: string;
             position: "inline" | "dropdown";
-        }[] | undefined;
+        }[];
     };
     form: {
         fields: {
@@ -181,7 +182,6 @@ export declare const createAdminCrudSectionSchema: import("#src/schema/creator/i
             label: string;
         }[];
     };
-    disableCreate?: boolean | undefined;
     embeddedForms?: ({
         id: string;
         name: string;
@@ -299,6 +299,7 @@ export declare const createAdminCrudSectionSchema: import("#src/schema/creator/i
     type: "crud";
     modelRef: string;
     nameFieldRef: string;
+    disableCreate: boolean;
     table: {
         columns: {
             [x: string]: unknown;
@@ -306,12 +307,12 @@ export declare const createAdminCrudSectionSchema: import("#src/schema/creator/i
             type: string;
             label: string;
         }[];
-        actions?: {
+        actions: {
             [x: string]: unknown;
             id: string;
             type: string;
             position: "inline" | "dropdown";
-        }[] | undefined;
+        }[];
     };
     form: {
         fields: {
@@ -321,7 +322,6 @@ export declare const createAdminCrudSectionSchema: import("#src/schema/creator/i
             label: string;
         }[];
     };
-    disableCreate?: boolean | undefined;
     embeddedForms?: ({
         id: string;
         name: string;

package/dist/schema/apps/web/web-app.d.ts

@@ -3,16 +3,16 @@ import type { def } from '#src/schema/creator/index.js';
 export declare const createWebAppSchema: import("#src/schema/creator/index.js").DefinitionSchemaCreatorWithSlots<z.ZodObject<{
     devPort: z.ZodNumber;
     type: z.ZodLiteral<"web">;
-    includeAuth: z.ZodOptional<z.ZodType<boolean | undefined, boolean | undefined, z.core.$ZodTypeInternals<boolean | undefined, boolean | undefined>>>;
+    includeAuth: z.ZodPrefault<z.ZodBoolean>;
     title: z.ZodDefault<z.ZodString>;
     description: z.ZodDefault<z.ZodString>;
-    includeUploadComponents: z.ZodOptional<z.ZodType<boolean | undefined, boolean | undefined, z.core.$ZodTypeInternals<boolean | undefined, boolean | undefined>>>;
-    enableSubscriptions: z.ZodOptional<z.ZodType<boolean | undefined, boolean | undefined, z.core.$ZodTypeInternals<boolean | undefined, boolean | undefined>>>;
-    adminApp: z.ZodOptional<z.ZodType<{
-        enabled: boolean;
-        pathPrefix: string;
-        allowedRoles?: string[] | undefined;
-        sections?: ({
+    includeUploadComponents: z.ZodPrefault<z.ZodBoolean>;
+    enableSubscriptions: z.ZodPrefault<z.ZodBoolean>;
+    adminApp: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        pathPrefix: z.ZodDefault<z.ZodString>;
+        allowedRoles: z.ZodPrefault<z.ZodArray<z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>>;
+        sections: z.ZodPrefault<z.ZodArray<z.ZodType<{
             id: string;
             name: string;
             featureRef: string;
@@ -22,6 +22,7 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
             type: "crud";
             modelRef: string;
             nameFieldRef: string;
+            disableCreate: boolean;
             table: {
                 columns: {
                     [x: string]: unknown;
@@ -29,12 +30,12 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
                     type: string;
                     label: string;
                 }[];
-                actions?: {
+                actions: {
                     [x: string]: unknown;
                     id: string;
                     type: string;
                     position: "inline" | "dropdown";
-                }[] | undefined;
+                }[];
             };
             form: {
                 fields: {
@@ -44,7 +45,6 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
                     label: string;
                 }[];
             };
-            disableCreate?: boolean | undefined;
             embeddedForms?: ({
                 id: string;
                 name: string;
@@ -82,12 +82,7 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
                 };
                 includeIdField?: boolean | undefined;
             })[] | undefined;
-        })[] | undefined;
-    } | undefined, {
-        enabled: boolean;
-        pathPrefix?: string | undefined;
-        allowedRoles?: string[] | undefined;
-        sections?: ({
+        }, {
             name: string;
             featureRef: string;
             type: string;
@@ -157,12 +152,7 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
                 };
                 includeIdField?: boolean | undefined;
             })[] | undefined;
-        })[] | undefined;
-    } | undefined, z.core.$ZodTypeInternals<{
-        enabled: boolean;
-        pathPrefix: string;
-        allowedRoles?: string[] | undefined;
-        sections?: ({
+        }, z.core.$ZodTypeInternals<{
             id: string;
             name: string;
             featureRef: string;
@@ -172,6 +162,7 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
             type: "crud";
             modelRef: string;
             nameFieldRef: string;
+            disableCreate: boolean;
             table: {
                 columns: {
                     [x: string]: unknown;
@@ -179,12 +170,12 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
                     type: string;
                     label: string;
                 }[];
-                actions?: {
+                actions: {
                     [x: string]: unknown;
                     id: string;
                     type: string;
                     position: "inline" | "dropdown";
-                }[] | undefined;
+                }[];
             };
             form: {
                 fields: {
@@ -194,7 +185,6 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
                     label: string;
                 }[];
             };
-            disableCreate?: boolean | undefined;
             embeddedForms?: ({
                 id: string;
                 name: string;
@@ -232,12 +222,7 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
                 };
                 includeIdField?: boolean | undefined;
             })[] | undefined;
-        })[] | undefined;
-    } | undefined, {
-        enabled: boolean;
-        pathPrefix?: string | undefined;
-        allowedRoles?: string[] | undefined;
-        sections?: ({
+        }, {
             name: string;
             featureRef: string;
             type: string;
@@ -307,8 +292,8 @@ export declare const createWebAppSchema: import("#src/schema/creator/index.js").
                 };
                 includeIdField?: boolean | undefined;
             })[] | undefined;
-        })[] | undefined;
-    } | undefined>>>;
+        }>>>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodString>;
     name: z.ZodString;
 }, z.core.$strip>, {
@@ -318,18 +303,16 @@ export type WebAppConfig = def.InferOutput<typeof createWebAppSchema>;
 export declare const webAppEntryType: import("../types.js").AppEntryType<{
     devPort: number;
     type: "web";
+    includeAuth: boolean;
     title: string;
     description: string;
-    id: string;
-    name: string;
-    includeAuth?: boolean | undefined;
-    includeUploadComponents?: boolean | undefined;
-    enableSubscriptions?: boolean | undefined;
-    adminApp?: {
+    includeUploadComponents: boolean;
+    enableSubscriptions: boolean;
+    adminApp: {
         enabled: boolean;
         pathPrefix: string;
-        allowedRoles?: string[] | undefined;
-        sections?: ({
+        allowedRoles: string[];
+        sections: ({
             id: string;
             name: string;
             featureRef: string;
@@ -339,6 +322,7 @@ export declare const webAppEntryType: import("../types.js").AppEntryType<{
             type: "crud";
             modelRef: string;
             nameFieldRef: string;
+            disableCreate: boolean;
             table: {
                 columns: {
                     [x: string]: unknown;
@@ -346,12 +330,12 @@ export declare const webAppEntryType: import("../types.js").AppEntryType<{
                     type: string;
                     label: string;
                 }[];
-                actions?: {
+                actions: {
                     [x: string]: unknown;
                     id: string;
                     type: string;
                     position: "inline" | "dropdown";
-                }[] | undefined;
+                }[];
             };
             form: {
                 fields: {
@@ -361,7 +345,6 @@ export declare const webAppEntryType: import("../types.js").AppEntryType<{
                     label: string;
                 }[];
             };
-            disableCreate?: boolean | undefined;
             embeddedForms?: ({
                 id: string;
                 name: string;
@@ -399,7 +382,9 @@ export declare const webAppEntryType: import("../types.js").AppEntryType<{
                 };
                 includeIdField?: boolean | undefined;
             })[] | undefined;
-        })[] | undefined;
-    } | undefined;
+        })[];
+    };
+    id: string;
+    name: string;
 }>;
 //# sourceMappingURL=web-app.d.ts.map

package/dist/schema/apps/web/web-app.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-app.d.ts","sourceRoot":"","sources":["../../../../src/schema/apps/web/web-app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAQxD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc9B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEtE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0C,CAAC"}
+{"version":3,"file":"web-app.d.ts","sourceRoot":"","sources":["../../../../src/schema/apps/web/web-app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAQxD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc9B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEtE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0C,CAAC"}

package/dist/schema/creator/definition-default-registry.d.ts

@@ -0,0 +1,22 @@
+import type { z } from 'zod';
+/**
+ * Metadata stored on a schema node annotated by `withDefault`.
+ *
+ * During serialization, `cleanDefaultValues()` walks the schema and uses this
+ * metadata to identify and remove values that match their defaults.
+ */
+interface DefaultSchemaMeta {
+    readonly defaultValue: unknown;
+}
+/**
+ * Registry that stores default-value metadata on Zod schema instances.
+ *
+ * Uses a WeakMap to avoid interfering with Zod's type system.
+ * Annotated by `withDefault()`; read by `cleanDefaultValues()`.
+ */
+export declare const definitionDefaultRegistry: {
+    set(schema: z.ZodType, meta: DefaultSchemaMeta): void;
+    get(schema: z.ZodType): DefaultSchemaMeta | undefined;
+};
+export {};
+//# sourceMappingURL=definition-default-registry.d.ts.map

package/dist/schema/creator/definition-default-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-default-registry.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/definition-default-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B;;;;;GAKG;AACH,UAAU,iBAAiB;IACzB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC;AAED;;;;;GAKG;AAEH,eAAO,MAAM,yBAAyB;gBAGtB,CAAC,CAAC,OAAO,QAAQ,iBAAiB,GAAG,IAAI;gBAGzC,CAAC,CAAC,OAAO,GAAG,iBAAiB,GAAG,SAAS;CAIrD,CAAC"}

package/dist/schema/creator/definition-default-registry.js

@@ -0,0 +1,18 @@
+/**
+ * Registry that stores default-value metadata on Zod schema instances.
+ *
+ * Uses a WeakMap to avoid interfering with Zod's type system.
+ * Annotated by `withDefault()`; read by `cleanDefaultValues()`.
+ */
+export const definitionDefaultRegistry = (() => {
+    const map = new WeakMap();
+    return {
+        set(schema, meta) {
+            map.set(schema, meta);
+        },
+        get(schema) {
+            return map.get(schema);
+        },
+    };
+})();
+//# sourceMappingURL=definition-default-registry.js.map

package/dist/schema/creator/definition-default-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-default-registry.js","sourceRoot":"","sources":["../../../src/schema/creator/definition-default-registry.ts"],"names":[],"mappings":"AAYA;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,GAAG,EAAE;IAC7C,MAAM,GAAG,GAAG,IAAI,OAAO,EAAgC,CAAC;IACxD,OAAO;QACL,GAAG,CAAC,MAAiB,EAAE,IAAuB;YAC5C,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACxB,CAAC;QACD,GAAG,CAAC,MAAiB;YACnB,OAAO,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACzB,CAAC;KACF,CAAC;AACJ,CAAC,CAAC,EAAE,CAAC"}

package/dist/schema/creator/definition-fix-registry.d.ts

@@ -0,0 +1,45 @@
+import type { z } from 'zod';
+import type { ReferencePath } from '#src/references/types.js';
+/**
+ * Context passed to fix functions during the schema+data walk.
+ * Contains only the path — fixes operate on local values without rootData access.
+ */
+export interface DefinitionFixContext {
+    /** The absolute path to the current node in the data */
+    readonly path: ReferencePath;
+}
+/**
+ * A fix function that silently transforms a value during the save pipeline.
+ * Return the fixed value, or the original value if no fix is needed.
+ */
+export type DefinitionFix<T = unknown> = (value: T, ctx: DefinitionFixContext) => T;
+/**
+ * Metadata stored on a schema node annotated by `withFix`.
+ * Exposed as readonly; the registry manages mutation internally.
+ */
+export interface FixSchemaMeta {
+    readonly fixes: readonly DefinitionFix[];
+}
+/**
+ * Registry that stores fix metadata on Zod schema instances.
+ *
+ * Uses a WeakMap to avoid interfering with Zod's type system.
+ * Annotated by `withFix()`; read by `applyDefinitionFixes()`.
+ */
+export declare const definitionFixRegistry: {
+    add(schema: z.ZodType, fix: DefinitionFix): void;
+    get(schema: z.ZodType): FixSchemaMeta | undefined;
+};
+/**
+ * Creates a schema decorator that registers a silent auto-fix.
+ *
+ * Used with `.apply()`:
+ * ```typescript
+ * z.object({ ... }).apply(withFix<MyType>((value, ctx) => fixedValue))
+ * ```
+ *
+ * @param fix - The fix function to register
+ * @returns A function that decorates a schema with the fix
+ */
+export declare function withFix<T extends z.ZodType>(fix: DefinitionFix<z.output<T>>): (schema: T) => T;
+//# sourceMappingURL=definition-fix-registry.d.ts.map

package/dist/schema/creator/definition-fix-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-fix-registry.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/definition-fix-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,OAAO,IAAI,CACvC,KAAK,EAAE,CAAC,EACR,GAAG,EAAE,oBAAoB,KACtB,CAAC,CAAC;AAEP;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;CAC1C;AAOD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;gBAGlB,CAAC,CAAC,OAAO,OAAO,aAAa,GAAG,IAAI;gBAQpC,CAAC,CAAC,OAAO,GAAG,aAAa,GAAG,SAAS;CAIjD,CAAC;AAEL;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EACzC,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAC9B,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAKlB"}

package/dist/schema/creator/definition-fix-registry.js

@@ -0,0 +1,41 @@
+/**
+ * Registry that stores fix metadata on Zod schema instances.
+ *
+ * Uses a WeakMap to avoid interfering with Zod's type system.
+ * Annotated by `withFix()`; read by `applyDefinitionFixes()`.
+ */
+export const definitionFixRegistry = (() => {
+    const map = new WeakMap();
+    return {
+        add(schema, fix) {
+            const existing = map.get(schema);
+            if (existing) {
+                existing.fixes.push(fix);
+            }
+            else {
+                map.set(schema, { fixes: [fix] });
+            }
+        },
+        get(schema) {
+            return map.get(schema);
+        },
+    };
+})();
+/**
+ * Creates a schema decorator that registers a silent auto-fix.
+ *
+ * Used with `.apply()`:
+ * ```typescript
+ * z.object({ ... }).apply(withFix<MyType>((value, ctx) => fixedValue))
+ * ```
+ *
+ * @param fix - The fix function to register
+ * @returns A function that decorates a schema with the fix
+ */
+export function withFix(fix) {
+    return (schema) => {
+        definitionFixRegistry.add(schema, fix);
+        return schema;
+    };
+}
+//# sourceMappingURL=definition-fix-registry.js.map

package/dist/schema/creator/definition-fix-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-fix-registry.js","sourceRoot":"","sources":["../../../src/schema/creator/definition-fix-registry.ts"],"names":[],"mappings":"AAmCA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,GAAG,EAAE;IACzC,MAAM,GAAG,GAAG,IAAI,OAAO,EAAmC,CAAC;IAC3D,OAAO;QACL,GAAG,CAAC,MAAiB,EAAE,GAAkB;YACvC,MAAM,QAAQ,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACjC,IAAI,QAAQ,EAAE,CAAC;gBACb,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACN,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;QACD,GAAG,CAAC,MAAiB;YACnB,OAAO,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACzB,CAAC;KACF,CAAC;AACJ,CAAC,CAAC,EAAE,CAAC;AAEL;;;;;;;;;;GAUG;AACH,MAAM,UAAU,OAAO,CACrB,GAA+B;IAE/B,OAAO,CAAC,MAAS,EAAK,EAAE;QACtB,qBAAqB,CAAC,GAAG,CAAC,MAAM,EAAE,GAAoB,CAAC,CAAC;QACxD,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC"}

package/dist/schema/creator/definition-issue-checker-spec.d.ts

@@ -0,0 +1,37 @@
+import type { ProjectDefinitionContainer } from '#src/definition/project-definition-container.js';
+import type { DefinitionIssue } from './definition-issue-types.js';
+/**
+ * A definition-level issue checker that operates on the full project definition.
+ * Can propose definition-wide auto-fixes.
+ *
+ * Unlike field-level checkers (registered via `withIssueChecker` on schema nodes),
+ * definition-level checkers receive the definition container and can perform
+ * cross-cutting validations like port conflicts, FK type mismatches, or missing
+ * models required by plugins.
+ */
+export type DefinitionIssueChecker = (container: ProjectDefinitionContainer) => DefinitionIssue[];
+/**
+ * Plugin spec for registering definition-level issue checkers.
+ *
+ * Built-in checkers (relation type mismatch, mutation roles) are registered
+ * by `collectDefinitionIssues` at runtime to avoid circular imports between
+ * schema/creator/ and parser/. Plugins can register additional checkers during
+ * initialization:
+ * ```typescript
+ * createPluginModule({
+ *   dependencies: { issueCheckers: definitionIssueCheckerSpec },
+ *   initialize: ({ issueCheckers }, { pluginKey }) => {
+ *     issueCheckers.checkers.set(pluginKey, (container) => {
+ *       // validate container.definition and return issues
+ *       return [];
+ *     });
+ *   },
+ * });
+ * ```
+ */
+export declare const definitionIssueCheckerSpec: import("../../index.js").PluginSpec<{
+    checkers: import("@baseplate-dev/utils").MapContainer<string, DefinitionIssueChecker>;
+}, {
+    getAllCheckers: () => Map<string, DefinitionIssueChecker>;
+}>;
+//# sourceMappingURL=definition-issue-checker-spec.d.ts.map

package/dist/schema/creator/definition-issue-checker-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-issue-checker-spec.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/definition-issue-checker-spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAC;AAIlG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE;;;;;;;;GAQG;AACH,MAAM,MAAM,sBAAsB,GAAG,CACnC,SAAS,EAAE,0BAA0B,KAClC,eAAe,EAAE,CAAC;AAEvB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,0BAA0B;;;0BAOb,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC;EAI5D,CAAC"}

package/dist/schema/creator/definition-issue-checker-spec.js

@@ -0,0 +1,28 @@
+import { createFieldMapSpec } from '#src/plugins/utils/create-field-map-spec.js';
+/**
+ * Plugin spec for registering definition-level issue checkers.
+ *
+ * Built-in checkers (relation type mismatch, mutation roles) are registered
+ * by `collectDefinitionIssues` at runtime to avoid circular imports between
+ * schema/creator/ and parser/. Plugins can register additional checkers during
+ * initialization:
+ * ```typescript
+ * createPluginModule({
+ *   dependencies: { issueCheckers: definitionIssueCheckerSpec },
+ *   initialize: ({ issueCheckers }, { pluginKey }) => {
+ *     issueCheckers.checkers.set(pluginKey, (container) => {
+ *       // validate container.definition and return issues
+ *       return [];
+ *     });
+ *   },
+ * });
+ * ```
+ */
+export const definitionIssueCheckerSpec = createFieldMapSpec('core/definition-issue-checkers', (t) => ({
+    checkers: t.map(),
+}), {
+    use: (values) => ({
+        getAllCheckers: () => values.checkers,
+    }),
+});
+//# sourceMappingURL=definition-issue-checker-spec.js.map

package/dist/schema/creator/definition-issue-checker-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-issue-checker-spec.js","sourceRoot":"","sources":["../../../src/schema/creator/definition-issue-checker-spec.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6CAA6C,CAAC;AAiBjF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,kBAAkB,CAC1D,gCAAgC,EAChC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACN,QAAQ,EAAE,CAAC,CAAC,GAAG,EAAkC;CAClD,CAAC,EACF;IACE,GAAG,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAChB,cAAc,EAAE,GAAwC,EAAE,CACxD,MAAM,CAAC,QAAQ;KAClB,CAAC;CACH,CACF,CAAC"}

package/dist/schema/creator/definition-issue-checkers.d.ts

@@ -0,0 +1,16 @@
+import type { DefinitionFieldIssueChecker } from './definition-issue-registry.js';
+/**
+ * Creates an issue checker that detects duplicate values for a given field
+ * in an array of objects.
+ *
+ * Used with `.apply(withIssueChecker(checkUniqueField(...)))` on array schemas.
+ *
+ * @param field - The field name to check for uniqueness
+ * @param options.label - Human-readable label for the field (e.g. "name", "port")
+ * @param options.severity - Severity level for duplicate issues (default: 'error')
+ */
+export declare function checkUniqueField<K extends string>(field: K, options?: {
+    label?: string;
+    severity?: 'error' | 'warning';
+}): DefinitionFieldIssueChecker<Record<K, unknown>[]>;
+//# sourceMappingURL=definition-issue-checkers.d.ts.map

package/dist/schema/creator/definition-issue-checkers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-issue-checkers.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/definition-issue-checkers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,gCAAgC,CAAC;AAExC;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAC/C,KAAK,EAAE,CAAC,EACR,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC3B,GACL,2BAA2B,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,CAyBnD"}

package/dist/schema/creator/definition-issue-checkers.js

@@ -0,0 +1,35 @@
+/**
+ * Creates an issue checker that detects duplicate values for a given field
+ * in an array of objects.
+ *
+ * Used with `.apply(withIssueChecker(checkUniqueField(...)))` on array schemas.
+ *
+ * @param field - The field name to check for uniqueness
+ * @param options.label - Human-readable label for the field (e.g. "name", "port")
+ * @param options.severity - Severity level for duplicate issues (default: 'error')
+ */
+export function checkUniqueField(field, options = {}) {
+    const { label = field, severity = 'error' } = options;
+    return (items) => {
+        const issues = [];
+        const seen = new Map();
+        for (const [i, item] of items.entries()) {
+            const value = item[field];
+            if (value === undefined || value === null || value === '')
+                continue;
+            const existingPath = seen.get(value);
+            if (existingPath) {
+                issues.push({
+                    message: `Duplicate ${label} "${String(value)}"`,
+                    path: [i, field],
+                    severity,
+                });
+            }
+            else {
+                seen.set(value, [i, field]);
+            }
+        }
+        return issues;
+    };
+}
+//# sourceMappingURL=definition-issue-checkers.js.map

package/dist/schema/creator/definition-issue-checkers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-issue-checkers.js","sourceRoot":"","sources":["../../../src/schema/creator/definition-issue-checkers.ts"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAQ,EACR,UAGI,EAAE;IAEN,MAAM,EAAE,KAAK,GAAG,KAAK,EAAE,QAAQ,GAAG,OAAO,EAAE,GAAG,OAAO,CAAC;IAEtD,OAAO,CAAC,KAAK,EAAE,EAAE;QACf,MAAM,MAAM,GAAuB,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,IAAI,GAAG,EAA0B,CAAC;QAE/C,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;YACxC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;YAC1B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE;gBAAE,SAAS;YAEpE,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACrC,IAAI,YAAY,EAAE,CAAC;gBACjB,MAAM,CAAC,IAAI,CAAC;oBACV,OAAO,EAAE,aAAa,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC,GAAG;oBAChD,IAAI,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC;oBAChB,QAAQ;iBACT,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;YAC9B,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC"}