@baseplate-dev/project-builder-lib 0.4.1 → 0.4.3

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW9B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa9B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEtE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0C,CAAC"}

package/dist/schema/apps/web/web-app.js

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-import { definitionSchema } from '#src/schema/creator/schema-creator.js';
+import { definitionSchemaWithSlots } from '#src/schema/creator/schema-creator.js';
 import { baseAppValidators } from '../base.js';
-import { createAppEntryType } from '../types.js';
+import { appEntityType, createAppEntryType } from '../types.js';
 import { createAdminAppSchema } from './admin/admin.js';
-export const createWebAppSchema = definitionSchema((ctx) => z.object({
+export const createWebAppSchema = definitionSchemaWithSlots({ appSlot: appEntityType }, (ctx, { appSlot }) => z.object({
     ...baseAppValidators,
     type: z.literal('web'),
     includeAuth: ctx.withDefault(z.boolean(), false),
@@ -11,7 +11,7 @@ export const createWebAppSchema = definitionSchema((ctx) => z.object({
     description: z.string().default(''),
     includeUploadComponents: ctx.withDefault(z.boolean(), false),
     enableSubscriptions: ctx.withDefault(z.boolean(), false),
-    adminApp: createAdminAppSchema(ctx),
+    adminApp: createAdminAppSchema(ctx, { appSlot }),
 }));
 export const webAppEntryType = createAppEntryType('web');
 //# sourceMappingURL=web-app.js.map

package/dist/schema/apps/web/web-app.js.map

@@ -1 +1 @@
-{"version":3,"file":"web-app.js","sourceRoot":"","sources":["../../../../src/schema/apps/web/web-app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAEzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,CAAC,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,CAAC,GAAG,EAAE,EAAE,CACzD,CAAC,CAAC,MAAM,CAAC;IACP,GAAG,iBAAiB;IACpB,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;IACtB,WAAW,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC;IAChD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAC7B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IACnC,uBAAuB,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC;IAC5D,mBAAmB,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC;IACxD,QAAQ,EAAE,oBAAoB,CAAC,GAAG,CAAC;CACpC,CAAC,CACH,CAAC;AAIF,MAAM,CAAC,MAAM,eAAe,GAAG,kBAAkB,CAAe,KAAK,CAAC,CAAC"}
+{"version":3,"file":"web-app.js","sourceRoot":"","sources":["../../../../src/schema/apps/web/web-app.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAElF,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,CAAC,MAAM,kBAAkB,GAAG,yBAAyB,CACzD,EAAE,OAAO,EAAE,aAAa,EAAE,EAC1B,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CACnB,CAAC,CAAC,MAAM,CAAC;IACP,GAAG,iBAAiB;IACpB,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;IACtB,WAAW,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC;IAChD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAC7B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IACnC,uBAAuB,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC;IAC5D,mBAAmB,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,KAAK,CAAC;IACxD,QAAQ,EAAE,oBAAoB,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC;CACjD,CAAC,CACL,CAAC;AAIF,MAAM,CAAC,MAAM,eAAe,GAAG,kBAAkB,CAAe,KAAK,CAAC,CAAC"}

package/dist/schema/creator/extend-parser-context-with-defaults.d.ts

@@ -1,6 +1,6 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import type { DefinitionSchemaCreatorOptions } from './types.js';
-export type WithDefaultType = <T extends z.ZodTypeAny>(schema: T, defaultValue: z.input<T>) => z.ZodEffects<z.ZodOptional<T>, z.output<z.ZodOptional<T>>, z.input<z.ZodOptional<T>>>;
+export type WithDefaultType = <T extends z.ZodType>(schema: T, defaultValue: z.input<T>) => z.ZodOptional<z.ZodType<z.output<z.ZodOptional<T>>, z.input<z.ZodOptional<T>>>>;
 /**
  * Extends the parser context with default value handling functionality.
  *

package/dist/schema/creator/extend-parser-context-with-defaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extend-parser-context-with-defaults.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/extend-parser-context-with-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AAqBjE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACnD,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KACrB,CAAC,CAAC,UAAU,CACf,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAChB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAC1B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAC1B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,8BAA8B,GACtC;IACD,WAAW,EAAE,eAAe,CAAC;CAC9B,CAuCA"}
+{"version":3,"file":"extend-parser-context-with-defaults.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/extend-parser-context-with-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AAqBjE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAChD,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KACrB,CAAC,CAAC,WAAW,CAChB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CACjE,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,8BAA8B,GACtC;IACD,WAAW,EAAE,eAAe,CAAC;CAC9B,CAmCA"}

package/dist/schema/creator/extend-parser-context-with-defaults.js

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 function isEmpty(value) {
     if (value === undefined || value === null) {
         return true;
@@ -25,32 +24,26 @@ export function extendParserContextWithDefaults(options) {
     const mode = options.defaultMode ?? 'populate';
     return {
         withDefault: function withDefault(schema, defaultValue) {
-            // Auto-add .optional() to the schema
-            const optionalSchema = schema.optional();
             switch (mode) {
                 case 'populate': {
-                    // Use preprocess to inject defaults before validation
-                    return z.preprocess((value) => {
-                        if (value === undefined) {
-                            return defaultValue;
-                        }
-                        return value;
-                    }, optionalSchema);
+                    return schema.prefault(defaultValue).optional();
                 }
                 case 'strip': {
                     // Use transform to remove values matching defaults after validation
-                    return optionalSchema.transform((value) => {
+                    return schema
+                        .transform((value) => {
+                        if (value === defaultValue)
+                            return undefined;
                         if (isEmpty(value)) {
                             return undefined;
                         }
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- it's typed to a generic
                         return value;
-                    });
+                    })
+                        .optional();
                 }
                 case 'preserve': {
                     // Return schema with .optional() added
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- it's typed to a generic
-                    return optionalSchema.transform((x) => x);
+                    return schema.transform((x) => x).optional();
                 }
             }
         },

package/dist/schema/creator/extend-parser-context-with-defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"extend-parser-context-with-defaults.js","sourceRoot":"","sources":["../../../src/schema/creator/extend-parser-context-with-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,SAAS,OAAO,CAAC,KAAc;IAC7B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;IAC5B,CAAC;IACD,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,SAAS,EACjD,CAAC;QACD,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,KAAK,KAAK,EAAE,CAAC;IACtB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAWD;;;;;GAKG;AACH,MAAM,UAAU,+BAA+B,CAC7C,OAAuC;IAIvC,MAAM,IAAI,GAAG,OAAO,CAAC,WAAW,IAAI,UAAU,CAAC;IAE/C,OAAO;QACL,WAAW,EAAE,SAAS,WAAW,CAC/B,MAAS,EACT,YAAwB;YAExB,qCAAqC;YACrC,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;YAEzC,QAAQ,IAAI,EAAE,CAAC;gBACb,KAAK,UAAU,CAAC,CAAC,CAAC;oBAChB,sDAAsD;oBACtD,OAAO,CAAC,CAAC,UAAU,CAAC,CAAC,KAAgC,EAAE,EAAE;wBACvD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;4BACxB,OAAO,YAAY,CAAC;wBACtB,CAAC;wBACD,OAAO,KAAK,CAAC;oBACf,CAAC,EAAE,cAAc,CAAC,CAAC;gBACrB,CAAC;gBACD,KAAK,OAAO,CAAC,CAAC,CAAC;oBACb,oEAAoE;oBACpE,OAAO,cAAc,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;wBACxC,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;4BACnB,OAAO,SAAS,CAAC;wBACnB,CAAC;wBACD,0FAA0F;wBAC1F,OAAO,KAAK,CAAC;oBACf,CAAC,CAAC,CAAC;gBACL,CAAC;gBACD,KAAK,UAAU,CAAC,CAAC,CAAC;oBAChB,uCAAuC;oBACvC,0FAA0F;oBAC1F,OAAO,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC5C,CAAC;YACH,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"extend-parser-context-with-defaults.js","sourceRoot":"","sources":["../../../src/schema/creator/extend-parser-context-with-defaults.ts"],"names":[],"mappings":"AAIA,SAAS,OAAO,CAAC,KAAc;IAC7B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;IAC5B,CAAC;IACD,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,SAAS,EACjD,CAAC;QACD,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC;IAChE,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,KAAK,KAAK,EAAE,CAAC;IACtB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AASD;;;;;GAKG;AACH,MAAM,UAAU,+BAA+B,CAC7C,OAAuC;IAIvC,MAAM,IAAI,GAAG,OAAO,CAAC,WAAW,IAAI,UAAU,CAAC;IAE/C,OAAO;QACL,WAAW,EAAE,SAAS,WAAW,CAC/B,MAAS,EACT,YAAwB;YAIxB,QAAQ,IAAI,EAAE,CAAC;gBACb,KAAK,UAAU,CAAC,CAAC,CAAC;oBAChB,OAAO,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAClD,CAAC;gBACD,KAAK,OAAO,CAAC,CAAC,CAAC;oBACb,oEAAoE;oBACpE,OAAO,MAAM;yBACV,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;wBACnB,IAAI,KAAK,KAAK,YAAY;4BAAE,OAAO,SAAS,CAAC;wBAC7C,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;4BACnB,OAAO,SAAS,CAAC;wBACnB,CAAC;wBAED,OAAO,KAAK,CAAC;oBACf,CAAC,CAAC;yBACD,QAAQ,EAAE,CAAC;gBAChB,CAAC;gBACD,KAAK,UAAU,CAAC,CAAC,CAAC;oBAChB,uCAAuC;oBAEvC,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAC/C,CAAC;YACH,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/schema/creator/infer-types.d.ts

@@ -1,6 +1,23 @@
 import type { z } from 'zod';
-import type { DefinitionSchemaCreator } from './types.js';
-export type InferSchema<T extends DefinitionSchemaCreator> = ReturnType<T>;
-export type InferInput<T extends DefinitionSchemaCreator> = z.input<ReturnType<T>>;
-export type InferOutput<T extends DefinitionSchemaCreator> = z.output<ReturnType<T>>;
+import type { DefinitionSchemaParserContext } from './types.js';
+/**
+ * Type constraint for any schema creator function (with or without slots).
+ * Works with both:
+ * - `definitionSchema` which returns `(ctx) => ZodType`
+ * - `definitionSchemaWithSlots` which returns `(ctx, slots) => ZodType`
+ */
+type AnyDefinitionSchemaCreator = (ctx: DefinitionSchemaParserContext, ...args: any[]) => z.ZodType;
+/**
+ * Infers the Zod schema type from a schema creator function.
+ */
+export type InferSchema<T extends AnyDefinitionSchemaCreator> = ReturnType<T>;
+/**
+ * Infers the input type (what you pass to parse) from a schema creator function.
+ */
+export type InferInput<T extends AnyDefinitionSchemaCreator> = z.input<ReturnType<T>>;
+/**
+ * Infers the output type (what parse returns) from a schema creator function.
+ */
+export type InferOutput<T extends AnyDefinitionSchemaCreator> = z.output<ReturnType<T>>;
+export {};
 //# sourceMappingURL=infer-types.d.ts.map

package/dist/schema/creator/infer-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"infer-types.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/infer-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAE1D,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,uBAAuB,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;AAE3E,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,uBAAuB,IAAI,CAAC,CAAC,KAAK,CACjE,UAAU,CAAC,CAAC,CAAC,CACd,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,uBAAuB,IAAI,CAAC,CAAC,MAAM,CACnE,UAAU,CAAC,CAAC,CAAC,CACd,CAAC"}
+{"version":3,"file":"infer-types.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/infer-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAEhE;;;;;GAKG;AACH,KAAK,0BAA0B,GAAG,CAChC,GAAG,EAAE,6BAA6B,EAElC,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,CAAC,CAAC,OAAO,CAAC;AAEf;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,0BAA0B,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;AAE9E;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,0BAA0B,IAAI,CAAC,CAAC,KAAK,CACpE,UAAU,CAAC,CAAC,CAAC,CACd,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,0BAA0B,IAAI,CAAC,CAAC,MAAM,CACtE,UAAU,CAAC,CAAC,CAAC,CACd,CAAC"}

package/dist/schema/creator/schema-creator.d.ts

@@ -1,5 +1,49 @@
 import type { z } from 'zod';
-import type { DefinitionSchemaCreator, DefinitionSchemaCreatorOptions, DefinitionSchemaParserContext } from './types.js';
+import type { RefContextSlotDefinition, RefContextSlotMap } from '#src/references/ref-context-slot.js';
+import type { DefinitionSchemaCreator, DefinitionSchemaCreatorOptions, DefinitionSchemaCreatorWithSlots, DefinitionSchemaParserContext } from './types.js';
 export declare function createDefinitionSchemaParserContext(options: DefinitionSchemaCreatorOptions): DefinitionSchemaParserContext;
-export declare function definitionSchema<T extends z.ZodTypeAny>(creator: DefinitionSchemaCreator<T>): (context: DefinitionSchemaParserContext) => T;
+export declare function definitionSchema<T extends z.ZodType>(creator: DefinitionSchemaCreator<T>): (context: DefinitionSchemaParserContext) => T;
+/**
+ * Creates a schema that requires slots to be passed from parent schemas.
+ * Used when a schema needs to reference entities from a parent context.
+ *
+ * @example
+ * ```typescript
+ * // Child schema requiring modelSlot from parent
+ * export const createModelScalarFieldSchema = definitionSchemaWithSlots(
+ *   { modelSlot: modelEntityType },
+ *   (ctx, { modelSlot }) =>
+ *     ctx.withEnt(schema, {
+ *       type: modelScalarFieldEntityType,
+ *       parentSlot: modelSlot,
+ *     }),
+ * );
+ *
+ * // Called from parent:
+ * createModelScalarFieldSchema(ctx, { modelSlot: parentModelSlot })
+ * ```
+ */
+export declare function definitionSchemaWithSlots<TSlotDef extends RefContextSlotDefinition, T extends z.ZodType>(slotDefinition: TSlotDef, creator: (ctx: DefinitionSchemaParserContext, slots: RefContextSlotMap<TSlotDef>) => T): DefinitionSchemaCreatorWithSlots<T, TSlotDef>;
+/**
+ * Wraps a schema creator that requires slots with placeholder slots,
+ * producing a simple schema creator that can be used for validation-only
+ * contexts (e.g., React Hook Form).
+ *
+ * The placeholder slots allow the schema to parse without actual parent context,
+ * which is useful when you only need schema validation without ref extraction.
+ *
+ * @example
+ * ```typescript
+ * // Schema that normally requires modelSlot from parent
+ * const createModelScalarFieldSchema = definitionSchemaWithSlots(
+ *   { modelSlot: modelEntityType },
+ *   (ctx, { modelSlot }) => ctx.withEnt(schema, { parentSlot: modelSlot }),
+ * );
+ *
+ * // For React Hook Form validation, wrap with placeholder slots
+ * const fieldSchema = withPlaceholderSlots(createModelScalarFieldSchema);
+ * const zodSchema = fieldSchema(ctx); // No slots needed
+ * ```
+ */
+export declare function withPlaceholderSlots<T extends z.ZodType, TSlotDef extends RefContextSlotDefinition>(schemaCreator: DefinitionSchemaCreatorWithSlots<T, TSlotDef>): DefinitionSchemaCreator<T>;
 //# sourceMappingURL=schema-creator.d.ts.map

package/dist/schema/creator/schema-creator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-creator.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/schema-creator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAI7B,OAAO,KAAK,EACV,uBAAuB,EACvB,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,YAAY,CAAC;AAIpB,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,8BAA8B,GACtC,6BAA6B,CAM/B;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACrD,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAClC,CAAC,OAAO,EAAE,6BAA6B,KAAK,CAAC,CAE/C"}
+{"version":3,"file":"schema-creator.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/schema-creator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EACV,wBAAwB,EACxB,iBAAiB,EAClB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,KAAK,EACV,uBAAuB,EACvB,8BAA8B,EAC9B,gCAAgC,EAChC,6BAA6B,EAC9B,MAAM,YAAY,CAAC;AAIpB,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,8BAA8B,GACtC,6BAA6B,CAM/B;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAClD,OAAO,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAClC,CAAC,OAAO,EAAE,6BAA6B,KAAK,CAAC,CAE/C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,SAAS,wBAAwB,EACzC,CAAC,SAAS,CAAC,CAAC,OAAO,EAEnB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,CACP,GAAG,EAAE,6BAA6B,EAClC,KAAK,EAAE,iBAAiB,CAAC,QAAQ,CAAC,KAC/B,CAAC,GACL,gCAAgC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAO/C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,SAAS,CAAC,CAAC,OAAO,EACnB,QAAQ,SAAS,wBAAwB,EAEzC,aAAa,EAAE,gCAAgC,CAAC,CAAC,EAAE,QAAQ,CAAC,GAC3D,uBAAuB,CAAC,CAAC,CAAC,CAO5B"}

package/dist/schema/creator/schema-creator.js

@@ -1,4 +1,5 @@
 import { extendParserContextWithRefs } from '#src/references/extend-parser-context-with-refs.js';
+import { createRefContextSlotMap } from '#src/references/ref-context-slot.js';
 import { extendParserContextWithDefaults } from './extend-parser-context-with-defaults.js';
 export function createDefinitionSchemaParserContext(options) {
     return {
@@ -10,4 +11,56 @@ export function createDefinitionSchemaParserContext(options) {
 export function definitionSchema(creator) {
     return (context) => creator(context);
 }
+/**
+ * Creates a schema that requires slots to be passed from parent schemas.
+ * Used when a schema needs to reference entities from a parent context.
+ *
+ * @example
+ * ```typescript
+ * // Child schema requiring modelSlot from parent
+ * export const createModelScalarFieldSchema = definitionSchemaWithSlots(
+ *   { modelSlot: modelEntityType },
+ *   (ctx, { modelSlot }) =>
+ *     ctx.withEnt(schema, {
+ *       type: modelScalarFieldEntityType,
+ *       parentSlot: modelSlot,
+ *     }),
+ * );
+ *
+ * // Called from parent:
+ * createModelScalarFieldSchema(ctx, { modelSlot: parentModelSlot })
+ * ```
+ */
+export function definitionSchemaWithSlots(slotDefinition, creator) {
+    const creatorWithSlots = (context, slots) => creator(context, slots);
+    creatorWithSlots.slotDefinition = slotDefinition;
+    return creatorWithSlots;
+}
+/**
+ * Wraps a schema creator that requires slots with placeholder slots,
+ * producing a simple schema creator that can be used for validation-only
+ * contexts (e.g., React Hook Form).
+ *
+ * The placeholder slots allow the schema to parse without actual parent context,
+ * which is useful when you only need schema validation without ref extraction.
+ *
+ * @example
+ * ```typescript
+ * // Schema that normally requires modelSlot from parent
+ * const createModelScalarFieldSchema = definitionSchemaWithSlots(
+ *   { modelSlot: modelEntityType },
+ *   (ctx, { modelSlot }) => ctx.withEnt(schema, { parentSlot: modelSlot }),
+ * );
+ *
+ * // For React Hook Form validation, wrap with placeholder slots
+ * const fieldSchema = withPlaceholderSlots(createModelScalarFieldSchema);
+ * const zodSchema = fieldSchema(ctx); // No slots needed
+ * ```
+ */
+export function withPlaceholderSlots(schemaCreator) {
+    return (ctx) => {
+        const placeholderSlots = createRefContextSlotMap(schemaCreator.slotDefinition);
+        return schemaCreator(ctx, placeholderSlots);
+    };
+}
 //# sourceMappingURL=schema-creator.js.map

package/dist/schema/creator/schema-creator.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema-creator.js","sourceRoot":"","sources":["../../../src/schema/creator/schema-creator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,MAAM,oDAAoD,CAAC;AAQjG,OAAO,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAE3F,MAAM,UAAU,mCAAmC,CACjD,OAAuC;IAEvC,OAAO;QACL,GAAG,OAAO;QACV,GAAG,2BAA2B,CAAC,OAAO,CAAC;QACvC,GAAG,+BAA+B,CAAC,OAAO,CAAC;KAC5C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC9B,OAAmC;IAEnC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AACvC,CAAC"}
+{"version":3,"file":"schema-creator.js","sourceRoot":"","sources":["../../../src/schema/creator/schema-creator.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,2BAA2B,EAAE,MAAM,oDAAoD,CAAC;AACjG,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAS9E,OAAO,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAE3F,MAAM,UAAU,mCAAmC,CACjD,OAAuC;IAEvC,OAAO;QACL,GAAG,OAAO;QACV,GAAG,2BAA2B,CAAC,OAAO,CAAC;QACvC,GAAG,+BAA+B,CAAC,OAAO,CAAC;KAC5C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC9B,OAAmC;IAEnC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AACvC,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,yBAAyB,CAIvC,cAAwB,EACxB,OAGM;IAEN,MAAM,gBAAgB,GAAkD,CACtE,OAAO,EACP,KAAK,EACL,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC7B,gBAAgB,CAAC,cAAc,GAAG,cAAc,CAAC;IACjD,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,oBAAoB,CAIlC,aAA4D;IAE5D,OAAO,CAAC,GAAG,EAAE,EAAE;QACb,MAAM,gBAAgB,GAAG,uBAAuB,CAC9C,aAAa,CAAC,cAAc,CAC7B,CAAC;QACF,OAAO,aAAa,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;IAC9C,CAAC,CAAC;AACJ,CAAC"}

package/dist/schema/creator/types.d.ts

@@ -1,6 +1,7 @@
 import type { z } from 'zod';
 import type { PluginImplementationStore } from '#src/plugins/index.js';
-import type { WithEntType, WithRefBuilder, WithRefType } from '#src/references/extend-parser-context-with-refs.js';
+import type { RefContextType, WithEntType, WithRefType } from '#src/references/extend-parser-context-with-refs.js';
+import type { RefContextSlotDefinition, RefContextSlotMap } from '#src/references/ref-context-slot.js';
 import type { WithDefaultType } from './extend-parser-context-with-defaults.js';
 /**
  * Options for creating a definition schema.
@@ -50,10 +51,6 @@ export interface DefinitionSchemaParserContext {
      * Adds an entity to the schema.
      */
     withEnt: WithEntType;
-    /**
-     * Provides access to the reference builder functions for the schema.
-     */
-    withRefBuilder: WithRefBuilder;
     /**
      * Wraps a schema with default value handling based on the defaultMode.
      * - 'populate': Uses preprocess to ensure defaults are present
@@ -61,6 +58,14 @@ export interface DefinitionSchemaParserContext {
      * - 'preserve': Returns schema unchanged
      */
     withDefault: WithDefaultType;
+    /**
+     * Creates ref context slots for use within a schema definition.
+     * Slots provide type-safe context for parent-child entity relationships.
+     */
+    refContext: RefContextType;
 }
-export type DefinitionSchemaCreator<T extends z.ZodTypeAny = z.ZodTypeAny> = (ctx: DefinitionSchemaParserContext) => T;
+export type DefinitionSchemaCreator<T extends z.ZodType = z.ZodType> = (ctx: DefinitionSchemaParserContext) => T;
+export type DefinitionSchemaCreatorWithSlots<TDefinitionSchema extends z.ZodType = z.ZodType, TSlotDefinition extends RefContextSlotDefinition = RefContextSlotDefinition> = ((ctx: DefinitionSchemaParserContext, slots: RefContextSlotMap<TSlotDefinition>) => TDefinitionSchema) & {
+    slotDefinition: TSlotDefinition;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/schema/creator/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,WAAW,EACZ,MAAM,oDAAoD,CAAC;AAE5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C;;OAEG;IACH,OAAO,EAAE,yBAAyB,CAAC;IACnC;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC;CACjD;AAED,MAAM,WAAW,6BAA6B;IAC5C;;OAEG;IACH,OAAO,EAAE,yBAAyB,CAAC;IACnC;;OAEG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;OAEG;IACH,WAAW,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC;IAChD;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB;;OAEG;IACH,cAAc,EAAE,cAAc,CAAC;IAC/B;;;;;OAKG;IACH,WAAW,EAAE,eAAe,CAAC;CAC9B;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,IAAI,CAC3E,GAAG,EAAE,6BAA6B,KAC/B,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/schema/creator/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,WAAW,EACZ,MAAM,oDAAoD,CAAC;AAC5D,OAAO,KAAK,EACV,wBAAwB,EACxB,iBAAiB,EAClB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C;;OAEG;IACH,OAAO,EAAE,yBAAyB,CAAC;IACnC;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC;CACjD;AAED,MAAM,WAAW,6BAA6B;IAC5C;;OAEG;IACH,OAAO,EAAE,yBAAyB,CAAC;IACnC;;OAEG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;OAEG;IACH,WAAW,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC;IAChD;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC;IACrB;;;;;OAKG;IACH,WAAW,EAAE,eAAe,CAAC;IAC7B;;;OAGG;IACH,UAAU,EAAE,cAAc,CAAC;CAC5B;AAED,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,IAAI,CACrE,GAAG,EAAE,6BAA6B,KAC/B,CAAC,CAAC;AAEP,MAAM,MAAM,gCAAgC,CAC1C,iBAAiB,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,EAC/C,eAAe,SAAS,wBAAwB,GAAG,wBAAwB,IACzE,CAAC,CACH,GAAG,EAAE,6BAA6B,EAClC,KAAK,EAAE,iBAAiB,CAAC,eAAe,CAAC,KACtC,iBAAiB,CAAC,GAAG;IACxB,cAAc,EAAE,eAAe,CAAC;CACjC,CAAC"}

package/dist/schema/features/feature.d.ts

@@ -2,47 +2,39 @@ import { z } from 'zod';
 import type { def } from '#src/schema/creator/index.js';
 export declare const featureEntityType: import("#src/references/types.js").DefinitionEntityType<false>;
 export declare const featureNameSchema: z.ZodString;
-export declare const createFeatureSchema: (context: import("#src/schema/creator/index.js").DefinitionSchemaParserContext) => z.ZodEffects<z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodEffects<z.ZodString, string, string>;
-    parentRef: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
+export declare const createFeatureSchema: (context: import("#src/schema/creator/index.js").DefinitionSchemaParserContext) => z.ZodType<{
     id: string;
+    name: string;
     parentRef?: string | undefined;
 }, {
-    name: string;
     id: string;
-    parentRef?: string | undefined;
-}>, {
     name: string;
+    parentRef?: string | undefined;
+}, z.core.$ZodTypeInternals<{
     id: string;
+    name: string;
     parentRef?: string | undefined;
 }, {
-    name: string;
     id: string;
+    name: string;
     parentRef?: string | undefined;
-}>;
+}>>;
 export type FeatureConfig = def.InferOutput<typeof createFeatureSchema>;
-export declare const createFeaturesSchema: (context: import("#src/schema/creator/index.js").DefinitionSchemaParserContext) => z.ZodDefault<z.ZodArray<z.ZodEffects<z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodEffects<z.ZodString, string, string>;
-    parentRef: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
+export declare const createFeaturesSchema: (context: import("#src/schema/creator/index.js").DefinitionSchemaParserContext) => z.ZodDefault<z.ZodArray<z.ZodType<{
     id: string;
+    name: string;
     parentRef?: string | undefined;
 }, {
-    name: string;
     id: string;
-    parentRef?: string | undefined;
-}>, {
     name: string;
+    parentRef?: string | undefined;
+}, z.core.$ZodTypeInternals<{
     id: string;
+    name: string;
     parentRef?: string | undefined;
 }, {
-    name: string;
     id: string;
+    name: string;
     parentRef?: string | undefined;
-}>, "many">>;
+}>>>>;
 //# sourceMappingURL=feature.d.ts.map

package/dist/schema/features/feature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature.d.ts","sourceRoot":"","sources":["../../../src/schema/features/feature.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAKxD,eAAO,MAAM,iBAAiB,gEAA8B,CAAC;AAE7D,eAAO,MAAM,iBAAiB,aAA6B,CAAC;AAE5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;EA0B/B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;YAEhC,CAAC"}
+{"version":3,"file":"feature.d.ts","sourceRoot":"","sources":["../../../src/schema/features/feature.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAKxD,eAAO,MAAM,iBAAiB,gEAA8B,CAAC;AAE7D,eAAO,MAAM,iBAAiB,aAA6B,CAAC;AAE5D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;GA0B/B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAExE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;KAEhC,CAAC"}

package/dist/schema/models/enums.d.ts

@@ -1,141 +1,91 @@
 import { z } from 'zod';
 import type { def } from '#src/schema/creator/index.js';
-export declare const createEnumValueSchema: (context: import("#src/schema/creator/index.js").DefinitionSchemaParserContext) => z.ZodEffects<z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    friendlyName: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
+export declare const createEnumValueSchema: import("#src/schema/creator/index.js").DefinitionSchemaCreatorWithSlots<z.ZodType<{
     id: string;
+    name: string;
     friendlyName: string;
 }, {
-    name: string;
     id: string;
-    friendlyName: string;
-}>, {
     name: string;
+    friendlyName: string;
+}, z.core.$ZodTypeInternals<{
     id: string;
+    name: string;
     friendlyName: string;
 }, {
-    name: string;
     id: string;
+    name: string;
     friendlyName: string;
+}>>, {
+    enumSlot: import("../../index.js").DefinitionEntityType<false>;
 }>;
 export type EnumValueConfig = def.InferOutput<typeof createEnumValueSchema>;
-export declare const createEnumBaseSchema: (context: import("#src/schema/creator/index.js").DefinitionSchemaParserContext) => z.ZodObject<{
+export declare const createEnumBaseSchema: import("#src/schema/creator/index.js").DefinitionSchemaCreatorWithSlots<z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
-    featureRef: z.ZodEffects<z.ZodString, string, string>;
-    values: z.ZodArray<z.ZodEffects<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        friendlyName: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        id: string;
-        friendlyName: string;
-    }, {
-        name: string;
+    featureRef: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    values: z.ZodArray<z.ZodType<{
         id: string;
-        friendlyName: string;
-    }>, {
         name: string;
-        id: string;
         friendlyName: string;
     }, {
-        name: string;
         id: string;
-        friendlyName: string;
-    }>, "many">;
-    isExposed: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    values: {
         name: string;
-        id: string;
         friendlyName: string;
-    }[];
-    name: string;
-    id: string;
-    featureRef: string;
-    isExposed: boolean;
-}, {
-    values: {
-        name: string;
+    }, z.core.$ZodTypeInternals<{
         id: string;
-        friendlyName: string;
-    }[];
-    name: string;
-    id: string;
-    featureRef: string;
-    isExposed: boolean;
-}>;
-export declare const createEnumSchema: (context: import("#src/schema/creator/index.js").DefinitionSchemaParserContext) => z.ZodEffects<z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    featureRef: z.ZodEffects<z.ZodString, string, string>;
-    values: z.ZodArray<z.ZodEffects<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        friendlyName: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
         name: string;
-        id: string;
         friendlyName: string;
     }, {
-        name: string;
         id: string;
-        friendlyName: string;
-    }>, {
-        name: string;
-        id: string;
-        friendlyName: string;
-    }, {
         name: string;
-        id: string;
         friendlyName: string;
-    }>, "many">;
+    }>>>;
     isExposed: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
+}, z.core.$strip>, {
+    enumSlot: import("../../index.js").DefinitionEntityType<false>;
+}>;
+export declare const createEnumSchema: (context: import("#src/schema/creator/index.js").DefinitionSchemaParserContext) => z.ZodType<{
+    id: string;
+    name: string;
+    featureRef: string;
     values: {
-        name: string;
         id: string;
+        name: string;
         friendlyName: string;
     }[];
-    name: string;
-    id: string;
-    featureRef: string;
     isExposed: boolean;
 }, {
+    id: string;
+    name: string;
+    featureRef: string;
     values: {
-        name: string;
         id: string;
+        name: string;
         friendlyName: string;
     }[];
-    name: string;
+    isExposed: boolean;
+}, z.core.$ZodTypeInternals<{
     id: string;
+    name: string;
     featureRef: string;
-    isExposed: boolean;
-}>, {
     values: {
-        name: string;
         id: string;
+        name: string;
         friendlyName: string;
     }[];
-    name: string;
-    id: string;
-    featureRef: string;
     isExposed: boolean;
 }, {
+    id: string;
+    name: string;
+    featureRef: string;
     values: {
-        name: string;
         id: string;
+        name: string;
         friendlyName: string;
     }[];
-    name: string;
-    id: string;
-    featureRef: string;
     isExposed: boolean;
-}>;
+}>>;
 export type EnumConfig = def.InferOutput<typeof createEnumSchema>;
 export type EnumConfigInput = def.InferInput<typeof createEnumSchema>;
 //# sourceMappingURL=enums.d.ts.map

package/dist/schema/models/enums.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../src/schema/models/enums.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAOxD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;EAYjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE5E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWhC,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK5B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAElE,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../src/schema/models/enums.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAUxD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;EAcjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE5E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAahC,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAO5B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAElE,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schema/models/enums.js

@@ -1,27 +1,27 @@
 import { z } from 'zod';
-import { definitionSchema } from '#src/schema/creator/schema-creator.js';
+import { definitionSchema, definitionSchemaWithSlots, } from '#src/schema/creator/schema-creator.js';
 import { featureEntityType } from '../features/index.js';
 import { modelEnumEntityType, modelEnumValueEntityType } from './types.js';
-export const createEnumValueSchema = definitionSchema((ctx) => ctx.withEnt(z.object({
+export const createEnumValueSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => ctx.withEnt(z.object({
     id: z.string(),
     name: z.string().min(1),
     friendlyName: z.string().min(1),
 }), {
     type: modelEnumValueEntityType,
-    parentPath: { context: 'enum' },
+    parentSlot: enumSlot,
 }));
-export const createEnumBaseSchema = definitionSchema((ctx) => z.object({
+export const createEnumBaseSchema = definitionSchemaWithSlots({ enumSlot: modelEnumEntityType }, (ctx, { enumSlot }) => z.object({
     id: z.string(),
     name: z.string().min(1),
     featureRef: ctx.withRef({
         type: featureEntityType,
         onDelete: 'RESTRICT',
     }),
-    values: z.array(createEnumValueSchema(ctx)),
+    values: z.array(createEnumValueSchema(ctx, { enumSlot })),
     isExposed: z.boolean(),
 }));
-export const createEnumSchema = definitionSchema((ctx) => ctx.withEnt(createEnumBaseSchema(ctx), {
+export const createEnumSchema = definitionSchema((ctx) => ctx.refContext({ enumSlot: modelEnumEntityType }, ({ enumSlot }) => ctx.withEnt(createEnumBaseSchema(ctx, { enumSlot }), {
     type: modelEnumEntityType,
-    addContext: 'enum',
-}));
+    provides: enumSlot,
+})));
 //# sourceMappingURL=enums.js.map

package/dist/schema/models/enums.js.map

@@ -1 +1 @@
-{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../src/schema/models/enums.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAEzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3E,MAAM,CAAC,MAAM,qBAAqB,GAAG,gBAAgB,CAAC,CAAC,GAAG,EAAE,EAAE,CAC5D,GAAG,CAAC,OAAO,CACT,CAAC,CAAC,MAAM,CAAC;IACP,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAChC,CAAC,EACF;IACE,IAAI,EAAE,wBAAwB;IAC9B,UAAU,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE;CAChC,CACF,CACF,CAAC;AAIF,MAAM,CAAC,MAAM,oBAAoB,GAAG,gBAAgB,CAAC,CAAC,GAAG,EAAE,EAAE,CAC3D,CAAC,CAAC,MAAM,CAAC;IACP,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,UAAU,EAAE,GAAG,CAAC,OAAO,CAAC;QACtB,IAAI,EAAE,iBAAiB;QACvB,QAAQ,EAAE,UAAU;KACrB,CAAC;IACF,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC;IAC3C,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;CACvB,CAAC,CACH,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,CAAC,GAAG,EAAE,EAAE,CACvD,GAAG,CAAC,OAAO,CAAC,oBAAoB,CAAC,GAAG,CAAC,EAAE;IACrC,IAAI,EAAE,mBAAmB;IACzB,UAAU,EAAE,MAAM;CACnB,CAAC,CACH,CAAC"}
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../src/schema/models/enums.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EACL,gBAAgB,EAChB,yBAAyB,GAC1B,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3E,MAAM,CAAC,MAAM,qBAAqB,GAAG,yBAAyB,CAC5D,EAAE,QAAQ,EAAE,mBAAmB,EAAE,EACjC,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,CACpB,GAAG,CAAC,OAAO,CACT,CAAC,CAAC,MAAM,CAAC;IACP,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAChC,CAAC,EACF;IACE,IAAI,EAAE,wBAAwB;IAC9B,UAAU,EAAE,QAAQ;CACrB,CACF,CACJ,CAAC;AAIF,MAAM,CAAC,MAAM,oBAAoB,GAAG,yBAAyB,CAC3D,EAAE,QAAQ,EAAE,mBAAmB,EAAE,EACjC,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,CACpB,CAAC,CAAC,MAAM,CAAC;IACP,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,UAAU,EAAE,GAAG,CAAC,OAAO,CAAC;QACtB,IAAI,EAAE,iBAAiB;QACvB,QAAQ,EAAE,UAAU;KACrB,CAAC;IACF,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;IACzD,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;CACvB,CAAC,CACL,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,CAAC,GAAG,EAAE,EAAE,CACvD,GAAG,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,mBAAmB,EAAE,EAAE,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CACjE,GAAG,CAAC,OAAO,CAAC,oBAAoB,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE;IACnD,IAAI,EAAE,mBAAmB;IACzB,QAAQ,EAAE,QAAQ;CACnB,CAAC,CACH,CACF,CAAC"}