@almadar/core 4.4.2 → 4.6.0

package/dist/{compose-behaviors-Da0YDcli.d.ts → compose-behaviors-Bp32KayC.d.ts}

@@ -1,4 +1,4 @@
-import { O as OrbitalDefinition, c as OrbitalSchema } from './schema-B0Yin-RM.js';
+import { O as OrbitalDefinition, d as OrbitalSchema } from './schema-CLFPg1xW.js';
 
 /**
  * Event Wiring

package/dist/domain-language/index.d.ts

@@ -1,4 +1,4 @@
-import { bR as SExpr, e as Entity, P as Page, c as OrbitalSchema, d as Trait } from '../schema-B0Yin-RM.js';
+import { bS as SExpr, f as Entity, P as Page, d as OrbitalSchema, e as Trait } from '../schema-CLFPg1xW.js';
 import 'zod';
 import '@almadar/patterns';
 

package/dist/domain-language/index.js

@@ -3356,34 +3356,61 @@ var FieldFormatSchema = z.enum([
   "datetime",
   "uuid"
 ]);
+var FIELD_TYPE_ALIASES = {
+  text: "string",
+  int: "number",
+  float: "number",
+  ts: "timestamp"
+};
 var EntityFieldSchema = z.lazy(
-  () => z.object({
-    name: z.string().min(1, "Field name is required"),
-    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(),
-    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;
+  () => 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 };
+        }
+      }
+      return input;
     },
-    { message: "Enum field requires a non-empty `values` array", path: ["values"] }
+    z.object({
+      name: z.string().min(1, "Field name is required"),
+      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(),
+      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"] }
+    )
   )
 );
 var ENTITY_ROLES = [
@@ -3691,6 +3718,8 @@ var RequiredFieldSchema = z.object({
 });
 z.object({
   ref: z.string().min(1),
+  // Phase 1.2: optional registry path disambiguator, pairs with `ref`.
+  from: z.string().optional(),
   linkedEntity: z.string().optional(),
   name: z.string().optional(),
   events: z.record(
@@ -4071,6 +4100,8 @@ var PageRefStringSchema = z.string().regex(
 );
 var PageRefObjectSchema = z.object({
   ref: PageRefStringSchema,
+  // Phase 1.2: optional registry path disambiguator, pairs with `ref`.
+  from: z.string().optional(),
   path: z.string().startsWith("/").optional(),
   linkedEntity: z.string().optional(),
   traits: z.array(TraitRefSchema).optional()