@almadar/core 8.5.1 → 8.6.1

package/dist/builders.d.ts

@@ -1,7 +1,7 @@
-import { bK as UISlot, t as Effect, bg as Trait, aC as RenderUIEffect, bs as TraitEventContract, y as Entity, bu as TraitEventListener, bj as TraitConfig, B as EntityField, H as EntityPersistence, L as EntityRow, bx as TraitRef, bz as TraitReference } from './trait-BV1DyJ2A.js';
-import { aA as UseDeclaration, B as EntityRef, ab as PageRef, X as OrbitalDefinition, a3 as OrbitalSchema, aa as Page, ac as PageRefObject } from './schema-Dp98Xt5i.js';
+import { bK as UISlot, t as Effect, bg as Trait, aC as RenderUIEffect, bs as TraitEventContract, y as Entity, bu as TraitEventListener, bj as TraitConfig, B as EntityField, H as EntityPersistence, L as EntityRow, bx as TraitRef, bz as TraitReference } from './trait-D1kGh81D.js';
+import { aA as UseDeclaration, B as EntityRef, ab as PageRef, X as OrbitalDefinition, a3 as OrbitalSchema, aa as Page, ac as PageRefObject } from './schema--EDm7mx5.js';
 import { S as SExpr } from './expression-BVRFm0sV.js';
-export { C as ComposeBehaviorsInput, a as ComposeBehaviorsResult, E as EventWiringEntry, L as LayoutStrategy, b as applyEventWiring, c as composeBehaviors, d as detectLayoutStrategy } from './compose-behaviors-TSp2c_dn.js';
+export { C as ComposeBehaviorsInput, a as ComposeBehaviorsResult, E as EventWiringEntry, L as LayoutStrategy, b as applyEventWiring, c as composeBehaviors, d as detectLayoutStrategy } from './compose-behaviors-CzTKCtrh.js';
 import { AnyPatternConfig } from '@almadar/patterns';
 import 'zod';
 

package/dist/builders.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 // src/types/orbital.ts
-var FieldTypeSchema = z.enum([
+z.enum([
   "string",
   "number",
   "boolean",
@@ -55,58 +55,70 @@ var FIELD_TYPE_ALIASES = {
   float: "number",
   ts: "timestamp"
 };
-var EntityFieldSchema = z.lazy(
-  () => z.preprocess(
+var EntityFieldSchema = z.lazy(() => {
+  const baseFieldShape = {
+    name: z.string().min(1, "Field name is required").optional(),
+    required: z.boolean().optional(),
+    default: z.unknown().optional(),
+    format: FieldFormatSchema.optional(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    properties: z.record(EntityFieldSchema).optional()
+  };
+  function scalarVariant(t) {
+    return z.object({
+      ...baseFieldShape,
+      type: z.literal(t),
+      values: z.array(z.string()).optional()
+    });
+  }
+  return z.preprocess(
     (input) => {
-      if (input !== null && typeof input === "object" && "type" in input && typeof input.type === "string") {
-        const raw = input.type;
-        const canonical = FIELD_TYPE_ALIASES[raw];
-        if (canonical !== void 0) {
-          return { ...input, type: canonical };
-        }
+      if (input === null || typeof input !== "object" || !("type" in input) || typeof input.type !== "string") {
+        return input;
+      }
+      const obj = input;
+      const next = { ...obj };
+      const aliased = FIELD_TYPE_ALIASES[obj.type];
+      if (aliased !== void 0) next["type"] = aliased;
+      if (next["enum"] !== void 0 && next["values"] === void 0) {
+        next["values"] = next["enum"];
       }
-      return input;
+      delete next["enum"];
+      return next;
     },
-    z.object({
-      name: z.string().min(1, "Field name is required").optional(),
-      type: FieldTypeSchema,
-      required: z.boolean().optional(),
-      default: z.unknown().optional(),
-      values: z.array(z.string()).optional(),
-      enum: z.array(z.string()).optional(),
-      format: FieldFormatSchema.optional(),
-      min: z.number().optional(),
-      max: z.number().optional(),
-      items: EntityFieldSchema.optional(),
-      properties: z.record(EntityFieldSchema).optional(),
-      relation: RelationConfigSchema.optional()
-    }).refine(
-      (field) => field.type !== "relation" || field.relation !== void 0,
-      { message: 'Relation config is required when type is "relation"', path: ["relation"] }
-    ).refine(
-      // Enum fields must carry their allowed values. Without this refine,
-      // the type was lying about what's valid — bare `type: 'enum'` without
-      // `values` passed zod but failed `orb validate` downstream with
-      // ORB_E_EMPTY_ENUM_VALUES, stalling the agent pipeline for 20 minutes.
-      // `enum` is the legacy field-name alias; accept either.
-      (field) => {
-        if (field.type !== "enum") return true;
-        const vals = field.values ?? field.enum;
-        return Array.isArray(vals) && vals.length > 0;
-      },
-      { message: "Enum field requires a non-empty `values` array", path: ["values"] }
-    ).refine(
-      // Array fields must describe their element shape. Bare `type: 'array'`
-      // with no `items` forces downstream consumers (builders, UI renderers,
-      // persistence) to guess, so reject it at the schema boundary.
-      (field) => {
-        if (field.type !== "array") return true;
-        return field.items !== void 0;
-      },
-      { message: "Array field requires an `items` schema describing each element", path: ["items"] }
-    )
-  )
-);
+    z.discriminatedUnion("type", [
+      scalarVariant("string"),
+      scalarVariant("number"),
+      scalarVariant("boolean"),
+      scalarVariant("date"),
+      scalarVariant("timestamp"),
+      scalarVariant("datetime"),
+      scalarVariant("object"),
+      scalarVariant("trait"),
+      scalarVariant("slot"),
+      scalarVariant("pattern"),
+      // Enum variant — REQUIRES non-empty values.
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("enum"),
+        values: z.array(z.string()).min(1, "Enum field requires a non-empty `values` array")
+      }),
+      // Relation variant — REQUIRES relation config.
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("relation"),
+        relation: RelationConfigSchema
+      }),
+      // Array variant — REQUIRES items schema.
+      z.object({
+        ...baseFieldShape,
+        type: z.literal("array"),
+        items: EntityFieldSchema
+      })
+    ])
+  );
+});
 var ENTITY_ROLES = [
   "player",
   "enemy",