@almadar/core 7.16.0 → 7.17.0

package/dist/builders.d.ts

@@ -1,6 +1,6 @@
-import { d6 as UISlot, Z as Effect, cE as Trait, bN as RenderUIEffect, cQ as TraitEventContract, a2 as Entity, cS as TraitEventListener, cH as TraitConfig, a6 as EntityField, a9 as EntityPersistence, ag as EntityRow, db as UseDeclaration, ab as EntityRef, cV as TraitRef, bs as PageRef, b6 as OrbitalDefinition, bh as OrbitalSchema, br as Page, bt as PageRefObject, cX as TraitReference } from './schema-DJzXvJHi.js';
+import { d7 as UISlot, Z as Effect, cE as Trait, bN as RenderUIEffect, cQ as TraitEventContract, a2 as Entity, cS as TraitEventListener, cH as TraitConfig, a6 as EntityField, a9 as EntityPersistence, ag as EntityRow, dc as UseDeclaration, ab as EntityRef, cV as TraitRef, bs as PageRef, b6 as OrbitalDefinition, bh as OrbitalSchema, br as Page, bt as PageRefObject, cX as TraitReference } from './schema-WX5fN1Ra.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-D2vPjRpX.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-DWMFJEz3.js';
 import { AnyPatternConfig } from '@almadar/patterns';
 import 'zod';
 

package/dist/{compose-behaviors-D2vPjRpX.d.ts → compose-behaviors-DWMFJEz3.d.ts}

@@ -1,4 +1,4 @@
-import { b6 as OrbitalDefinition, bh as OrbitalSchema } from './schema-DJzXvJHi.js';
+import { b6 as OrbitalDefinition, bh as OrbitalSchema } from './schema-WX5fN1Ra.js';
 
 /**
  * Event Wiring

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

@@ -1,8 +1,18 @@
+import { c$ as TraitScope, a9 as EntityPersistence, a2 as Entity, br as Page, bh as OrbitalSchema, cE as Trait } from '../schema-WX5fN1Ra.js';
 import { S as SExpr } from '../expression-BVRFm0sV.js';
-import { a2 as Entity, br as Page, bh as OrbitalSchema, cE as Trait } from '../schema-DJzXvJHi.js';
 import 'zod';
 import '@almadar/patterns';
 
+/**
+ * Domain Language Types
+ *
+ * AST node types for the domain language that maps to KFlow schema.
+ * All entity references use explicit names (e.g., Order, Task, CurrentUser)
+ * per GAP-002 - no magic variables like `entity.` or `context.`.
+ *
+ * @packageDocumentation
+ */
+
 /**
  * Effect operator mapping: Both systems use the same operator names
  */
@@ -31,6 +41,23 @@ interface ASTNode {
  * Note: These map to OrbitalSchema types via DOMAIN_TO_SCHEMA_FIELD_TYPE
  */
 type DomainFieldType = 'text' | 'long text' | 'number' | 'currency' | 'date' | 'timestamp' | 'datetime' | 'yes/no' | 'enum' | 'list' | 'object' | 'relation';
+/**
+ * Default value for a `DomainField`. Mirrors the JSON-leaf shape an
+ * `EntityField.default` may carry on `OrbitalSchema`: scalar, list, or
+ * nested object (when the field type is `'object'` or `'list'`).
+ */
+type DomainFieldDefault = string | number | boolean | null | DomainFieldDefault[] | {
+    [k: string]: DomainFieldDefault;
+};
+/**
+ * For `fieldType: 'list'`, the typed shape of each item. Mirrors
+ * `EntityField.items` on `OrbitalSchema`. Currently a single-level
+ * type tag (matching how the schema uses it); extend if/when nested
+ * list-of-list / list-of-object signatures are required.
+ */
+interface DomainFieldItems {
+    type: DomainFieldType;
+}
 interface DomainField extends ASTNode {
     type: 'field';
     name: string;
@@ -38,8 +65,10 @@ interface DomainField extends ASTNode {
     required: boolean;
     unique: boolean;
     auto: boolean;
-    default?: unknown;
+    default?: DomainFieldDefault;
     enumValues?: string[];
+    /** List-of-X item type when `fieldType === 'list'`. */
+    items?: DomainFieldItems;
 }
 type RelationshipType = 'belongs_to' | 'has_many' | 'has_one';
 interface DomainRelationship extends ASTNode {
@@ -56,6 +85,13 @@ interface DomainEntity extends ASTNode {
     relationships: DomainRelationship[];
     states?: string[];
     initialState?: string;
+    /**
+     * Storage mode on the resolved schema. Mirrors `EntityPersistence` in
+     * `@almadar/core/types/entity.ts`. Omitted ⇒ projector defaults to
+     * `'persistent'`. Domain text syntax: `Persistence: <value>` line in
+     * the entity section.
+     */
+    persistence?: EntityPersistence;
 }
 interface DomainPageSection extends ASTNode {
     type: 'page_section';
@@ -146,6 +182,13 @@ interface DomainBehavior extends ASTNode {
     transitions: DomainTransition[];
     ticks: DomainTick[];
     rules: string[];
+    /**
+     * Instance- vs collection-scoped state machine. Mirrors
+     * `Trait.scope: TraitScope` in `@almadar/core/types/trait.ts`.
+     * Omitted ⇒ projector defaults to `'instance'`. Domain text syntax:
+     * `Scope: instance|collection` line in the behavior section.
+     */
+    scope?: TraitScope;
 }
 interface DomainDocument extends ASTNode {
     type: 'document';
@@ -926,4 +969,4 @@ declare function getRegistryStats(): {
  */
 declare function generateDomainLanguageReference(): string;
 
-export { type ASTNode, type ComparisonCondition, type ComparisonOperator, type DomainBehavior, type DomainChunk, type DomainDocument, type DomainEffect, type DomainEntity, type DomainField, type DomainFieldType, type DomainGuard, type DomainPage, type DomainPageAction, type DomainPageSection, type DomainRelationship, type DomainTick, type DomainToSchemaResult, type DomainTransition, EFFECT_REGISTRY, type EffectMapping, type EffectType, FIELD_TYPE_REGISTRY, type FieldCheckCondition, type FieldReference, type FieldTypeMapping, GUARD_REGISTRY, type GuardCondition, type GuardMapping, KEYWORDS, Lexer, type LogicalCondition, type LogicalOperator, MULTI_WORD_KEYWORDS, type MappingStore, type MergeResult, type ParseError, type ParseResult, type RelationshipType, type SchemaToDomainResult, type SectionMapping, type SourceLocation, type SourceRange, type Token, TokenType, type UserCheckCondition, applySectionUpdate, computeSchemaHash, convertDomainToSchema, convertEntitiesToDomain, convertPagesToDomain, convertSchemaToDomain, convertTraitsToDomain, createMappingStore, deleteSection, detectChanges, domainKeywordToSchemaType, findMapping, findMappingByPath, findMappingsByType, formatBehaviorToDomain, formatBehaviorToSchema, formatDomainGuardToSchema, formatEntityToDomain, formatEntityToSchema, formatGuardConditionToDomain, formatGuardToDomain, formatGuardToSchema, formatMergeSummary, formatPageToDomain, formatPageToSchema, formatSchemaEntityToDomain, formatSchemaGuardToDomain, formatSchemaPageToDomain, formatSchemaTraitToDomain, generateDomainLanguageReference, generateSectionId, getEffectMapping, getFieldTypeMapping, getGuardMapping, getRegisteredEffects, getRegisteredFieldTypes, getRegisteredGuards, getRegistryStats, getSchemaPath, hasSchemaChanged, isEffectRegistered, isFieldTypeRegistered, isGuardRegistered, mergeDomainChunks, parseBehavior, parseDomainEffect, parseDomainEffects, parseDomainGuard, parseEntity, parseGuard, parsePage, parseSectionId, removeMapping, resolveConflict, schemaEntityToDomainEntity, schemaPageToDomainPage, schemaTraitToDomainBehavior, schemaTypeToDomainKeyword, tokenize, updateMappingRange, updateSchemaHash, upsertMapping, validateDomainChunk };
+export { type ASTNode, type ComparisonCondition, type ComparisonOperator, type DomainBehavior, type DomainChunk, type DomainDocument, type DomainEffect, type DomainEntity, type DomainField, type DomainFieldDefault, type DomainFieldItems, type DomainFieldType, type DomainGuard, type DomainPage, type DomainPageAction, type DomainPageSection, type DomainRelationship, type DomainTick, type DomainToSchemaResult, type DomainTransition, EFFECT_REGISTRY, type EffectMapping, type EffectType, EntityPersistence, FIELD_TYPE_REGISTRY, type FieldCheckCondition, type FieldReference, type FieldTypeMapping, GUARD_REGISTRY, type GuardCondition, type GuardMapping, KEYWORDS, Lexer, type LogicalCondition, type LogicalOperator, MULTI_WORD_KEYWORDS, type MappingStore, type MergeResult, type ParseError, type ParseResult, type RelationshipType, type SchemaToDomainResult, type SectionMapping, type SourceLocation, type SourceRange, type Token, TokenType, TraitScope, type UserCheckCondition, applySectionUpdate, computeSchemaHash, convertDomainToSchema, convertEntitiesToDomain, convertPagesToDomain, convertSchemaToDomain, convertTraitsToDomain, createMappingStore, deleteSection, detectChanges, domainKeywordToSchemaType, findMapping, findMappingByPath, findMappingsByType, formatBehaviorToDomain, formatBehaviorToSchema, formatDomainGuardToSchema, formatEntityToDomain, formatEntityToSchema, formatGuardConditionToDomain, formatGuardToDomain, formatGuardToSchema, formatMergeSummary, formatPageToDomain, formatPageToSchema, formatSchemaEntityToDomain, formatSchemaGuardToDomain, formatSchemaPageToDomain, formatSchemaTraitToDomain, generateDomainLanguageReference, generateSectionId, getEffectMapping, getFieldTypeMapping, getGuardMapping, getRegisteredEffects, getRegisteredFieldTypes, getRegisteredGuards, getRegistryStats, getSchemaPath, hasSchemaChanged, isEffectRegistered, isFieldTypeRegistered, isGuardRegistered, mergeDomainChunks, parseBehavior, parseDomainEffect, parseDomainEffects, parseDomainGuard, parseEntity, parseGuard, parsePage, parseSectionId, removeMapping, resolveConflict, schemaEntityToDomainEntity, schemaPageToDomainPage, schemaTraitToDomainBehavior, schemaTypeToDomainKeyword, tokenize, updateMappingRange, updateSchemaHash, upsertMapping, validateDomainChunk };

package/dist/domain-language/index.js

@@ -445,6 +445,7 @@ function parseEntity(text) {
   const tokens = lexer.tokenize();
   let pos = 0;
   const current = () => tokens[pos] || { type: "EOF" /* EOF */, value: "", line: 0, column: 0, offset: 0 };
+  const peek = (offset = 0) => tokens[pos + offset] || { type: "EOF" /* EOF */, value: "", line: 0, column: 0, offset: 0 };
   const advance = () => tokens[pos++];
   const isAtEnd = () => current().type === "EOF" /* EOF */;
   const skip = (type) => {
@@ -526,6 +527,21 @@ function parseEntity(text) {
   }
   function parseSection(entity2) {
     const token = current();
+    if (token.type === "IDENTIFIER" /* IDENTIFIER */ && peek(1).type === "COLON" /* COLON */) {
+      const propName = token.value.toLowerCase();
+      if (propName === "persistence") {
+        advance();
+        advance();
+        if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
+          const val = current().value.toLowerCase();
+          if (val === "persistent" || val === "runtime" || val === "singleton" || val === "instance" || val === "local") {
+            entity2.persistence = val;
+            advance();
+          }
+        }
+        return true;
+      }
+    }
     if (token.type === "INDENT" /* INDENT */) {
       advance();
       parseIndentedFields(entity2);
@@ -759,36 +775,71 @@ function parseEntity(text) {
     };
     const parts = [];
     while (!isAtEnd() && current().type !== "NEWLINE" /* NEWLINE */) {
-      parts.push(current().value);
+      const tok = current();
+      parts.push(tok.type === "STRING" /* STRING */ ? `"${tok.value}"` : tok.value);
       advance();
     }
     const content = parts.join(" ").trim();
-    if (content.includes("|")) {
-      field.fieldType = "enum";
-      field.enumValues = content.split("|").map((v) => v.trim()).filter((v) => v);
-      return field;
-    }
-    const segments = content.split(",").map((s) => s.trim().toLowerCase());
-    for (const segment of segments) {
-      if (segment === "text") field.fieldType = "text";
-      else if (segment === "long text") field.fieldType = "long text";
-      else if (segment === "number") field.fieldType = "number";
-      else if (segment === "currency") field.fieldType = "currency";
-      else if (segment === "date") field.fieldType = "date";
-      else if (segment === "timestamp") field.fieldType = "timestamp";
-      else if (segment === "datetime") field.fieldType = "datetime";
-      else if (segment === "yes/no" || segment === "boolean") field.fieldType = "yes/no";
-      else if (segment === "list") field.fieldType = "list";
-      else if (segment === "object") field.fieldType = "object";
-      else if (segment === "required") field.required = true;
-      else if (segment === "unique") field.unique = true;
-      else if (segment === "auto") field.auto = true;
-      else if (segment.startsWith("default ")) {
-        field.default = parseValue(segment.slice(8));
+    const segments = content.split(",").map((s) => s.trim());
+    if (segments.length === 0) return field;
+    const typeSpec = segments[0];
+    if (typeSpec.includes("|")) {
+      field.fieldType = "text";
+      field.enumValues = typeSpec.split("|").map((v) => v.trim()).filter((v) => v.length > 0);
+    } else {
+      const lower = typeSpec.toLowerCase();
+      if (lower.startsWith("list of ")) {
+        field.fieldType = "list";
+        field.items = { type: parseDomainFieldType(lower.slice("list of ".length).trim()) };
+      } else {
+        field.fieldType = parseDomainFieldType(lower);
+      }
+    }
+    for (let i = 1; i < segments.length; i++) {
+      const segment = segments[i];
+      const lower = segment.toLowerCase();
+      if (lower === "required") field.required = true;
+      else if (lower === "unique") field.unique = true;
+      else if (lower === "auto") field.auto = true;
+      else if (lower.startsWith("default ")) {
+        field.default = parseDefaultLiteral(segment.slice("default ".length).trim());
       }
     }
     return field;
   }
+  function parseDomainFieldType(keyword) {
+    if (keyword === "long text") return "long text";
+    if (keyword === "text" || keyword === "string") return "text";
+    if (keyword === "number" || keyword === "integer") return "number";
+    if (keyword === "currency") return "currency";
+    if (keyword === "date") return "date";
+    if (keyword === "timestamp") return "timestamp";
+    if (keyword === "datetime") return "datetime";
+    if (keyword === "yes/no" || keyword === "boolean") return "yes/no";
+    if (keyword === "list" || keyword === "array") return "list";
+    if (keyword === "object") return "object";
+    if (keyword === "enum") return "enum";
+    if (keyword === "relation") return "relation";
+    return "text";
+  }
+  function parseDefaultLiteral(text2) {
+    const trimmed = text2.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return trimmed.slice(1, -1);
+    }
+    if (trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch {
+      }
+    }
+    if (trimmed.toLowerCase() === "true") return true;
+    if (trimmed.toLowerCase() === "false") return false;
+    if (trimmed.toLowerCase() === "null") return null;
+    const num = Number(trimmed);
+    if (!Number.isNaN(num) && trimmed !== "") return num;
+    return trimmed;
+  }
   function parseRelationship(entity2, relType) {
     if (current().type !== "IDENTIFIER" /* IDENTIFIER */) {
       return;
@@ -859,27 +910,32 @@ function formatEntityToDomain(entity) {
   return lines.join("\n");
 }
 function formatEntityToSchema(entity) {
-  const fields = entity.fields.map((field) => ({
-    name: field.name,
-    type: mapFieldTypeToSchema(field.fieldType),
-    required: field.required || void 0,
-    unique: field.unique || void 0,
-    auto: field.auto || void 0,
-    values: field.enumValues,
-    // OrbitalSchema uses 'values' not 'enumValues'
-    default: field.default
-  }));
+  const fields = entity.fields.map((field) => {
+    const schemaType = field.enumValues && field.enumValues.length > 0 ? mapFieldTypeToSchema(field.fieldType === "enum" ? "text" : field.fieldType) : mapFieldTypeToSchema(field.fieldType);
+    const out2 = {
+      name: field.name,
+      type: schemaType
+    };
+    if (field.required) out2.required = true;
+    if (field.unique) out2.unique = true;
+    if (field.auto) out2.auto = true;
+    if (field.enumValues && field.enumValues.length > 0) {
+      out2.values = field.enumValues;
+    }
+    if (field.items) {
+      out2.items = { type: mapFieldTypeToSchema(field.items.type) };
+    }
+    if (field.default !== void 0) {
+      out2.default = field.default;
+    }
+    return out2;
+  });
   for (const rel of entity.relationships) {
     if (rel.relationshipType === "belongs_to") {
       const fieldName = rel.alias ? toCamelCase(rel.alias) + "Id" : toCamelCase(rel.targetEntity) + "Id";
       fields.push({
         name: fieldName,
         type: "relation",
-        required: void 0,
-        unique: void 0,
-        auto: void 0,
-        values: void 0,
-        default: void 0,
         relation: {
           entity: rel.targetEntity,
           type: "many-to-one"
@@ -887,13 +943,15 @@ function formatEntityToSchema(entity) {
       });
     }
   }
-  return {
+  const out = {
     name: entity.name,
     collection: toKebabCase(entity.name) + "s",
-    fields: fields.filter((f) => Object.keys(f).length > 0),
-    states: entity.states,
-    initialState: entity.initialState
+    fields: fields.filter((f) => Object.keys(f).length > 0)
   };
+  if (entity.states && entity.states.length > 0) out.states = entity.states;
+  if (entity.initialState !== void 0) out.initialState = entity.initialState;
+  if (entity.persistence !== void 0) out.persistence = entity.persistence;
+  return out;
 }
 function toCamelCase(text) {
   return text.toLowerCase().split(/\s+/).map(
@@ -916,14 +974,6 @@ function startsWithVowel(text) {
   }
   return /^[aeiou]/i.test(text);
 }
-function parseValue(text) {
-  text = text.trim();
-  if (text.toLowerCase() === "true") return true;
-  if (text.toLowerCase() === "false") return false;
-  const num = parseFloat(text);
-  if (!isNaN(num)) return num;
-  return text.replace(/^["']|["']$/g, "");
-}
 function formatFieldType(field) {
   const parts = [];
   if (field.enumValues && field.enumValues.length > 0) {
@@ -1523,7 +1573,7 @@ function parseFieldCheck(text, ctx) {
         type: "field_check",
         field,
         check: "equals",
-        value: parseValue2(value)
+        value: parseValue(value)
       };
     }
   }
@@ -1546,7 +1596,7 @@ function parseComparison(text, ctx) {
         type: "comparison",
         field,
         operator: "!=",
-        value: parseValue2(isNotMatch[2])
+        value: parseValue(isNotMatch[2])
       };
     }
   }
@@ -1559,7 +1609,7 @@ function parseComparison(text, ctx) {
           type: "comparison",
           field,
           operator,
-          value: parseValue2(match[2])
+          value: parseValue(match[2])
         };
       }
     }
@@ -1583,7 +1633,7 @@ function parseFieldReference(text, ctx) {
     fieldName
   };
 }
-function parseValue2(text) {
+function parseValue(text) {
   text = text.trim();
   if (text.startsWith('"') && text.endsWith('"') || text.startsWith("'") && text.endsWith("'")) {
     return text.slice(1, -1);
@@ -1866,37 +1916,37 @@ function parseComparison2(text, ctx) {
   const atLeastMatch = text.match(/^(.+?)\s+is\s+at\s+least\s+(.+)$/i);
   if (atLeastMatch) {
     const field = parseFieldRef(atLeastMatch[1]);
-    const value = parseValue3(atLeastMatch[2]);
+    const value = parseValue2(atLeastMatch[2]);
     return [">=", field, value];
   }
   const atMostMatch = text.match(/^(.+?)\s+is\s+at\s+most\s+(.+)$/i);
   if (atMostMatch) {
     const field = parseFieldRef(atMostMatch[1]);
-    const value = parseValue3(atMostMatch[2]);
+    const value = parseValue2(atMostMatch[2]);
     return ["<=", field, value];
   }
   const greaterThanMatch = text.match(/^(.+?)\s+is\s+greater\s+than\s+(.+)$/i);
   if (greaterThanMatch) {
     const field = parseFieldRef(greaterThanMatch[1]);
-    const value = parseValue3(greaterThanMatch[2]);
+    const value = parseValue2(greaterThanMatch[2]);
     return [">", field, value];
   }
   const lessThanMatch = text.match(/^(.+?)\s+is\s+less\s+than\s+(.+)$/i);
   if (lessThanMatch) {
     const field = parseFieldRef(lessThanMatch[1]);
-    const value = parseValue3(lessThanMatch[2]);
+    const value = parseValue2(lessThanMatch[2]);
     return ["<", field, value];
   }
   const isNotMatch = text.match(/^(.+?)\s+is\s+not\s+(.+)$/i);
   if (isNotMatch) {
     const field = parseFieldRef(isNotMatch[1]);
-    const value = parseValue3(isNotMatch[2]);
+    const value = parseValue2(isNotMatch[2]);
     return ["!=", field, value];
   }
   const isMatch = text.match(/^(.+?)\s+is\s+(.+)$/i);
   if (isMatch) {
     const field = parseFieldRef(isMatch[1]);
-    const value = parseValue3(isMatch[2]);
+    const value = parseValue2(isMatch[2]);
     return ["=", field, value];
   }
   const opPatterns = [
@@ -1911,7 +1961,7 @@ function parseComparison2(text, ctx) {
     const match = text.match(pattern);
     if (match) {
       const left = parseFieldRef(match[1]);
-      const right = parseValue3(match[2]);
+      const right = parseValue2(match[2]);
       return [op, left, right];
     }
   }
@@ -2072,7 +2122,7 @@ function parseFieldRef(text, ctx) {
   const fieldName = toCamelCase3(text);
   return `@entity.${fieldName}`;
 }
-function parseValue3(text) {
+function parseValue2(text) {
   text = text.trim();
   if (text.startsWith('"') && text.endsWith('"') || text.startsWith("'") && text.endsWith("'")) {
     return text.slice(1, -1);
@@ -2120,7 +2170,7 @@ function parseEffectValue(text, ctx) {
   if (text.includes(".") || text.toLowerCase().startsWith("incoming ") || text.match(/^\w+'s\s+/) || /^[a-z]/.test(text)) {
     return parseFieldRef(text);
   }
-  return parseValue3(text);
+  return parseValue2(text);
 }
 function processBindingsInObject(obj) {
   if (obj === null || obj === void 0) {
@@ -2378,6 +2428,18 @@ function parseBehavior(text, entityName) {
       }
       return true;
     }
+    if (token.type === "IDENTIFIER" /* IDENTIFIER */ && token.value.toLowerCase() === "scope") {
+      advance();
+      skip("COLON" /* COLON */);
+      if (current().type === "IDENTIFIER" /* IDENTIFIER */) {
+        const val = current().value.toLowerCase();
+        if (val === "instance" || val === "collection") {
+          behavior2.scope = val;
+          advance();
+        }
+      }
+      return true;
+    }
     if (token.type === "STATES" /* STATES */) {
       advance();
       skip("COLON" /* COLON */);
@@ -2869,6 +2931,9 @@ function formatBehaviorToSchema(behavior) {
     name: behavior.name.replace(/\s+/g, ""),
     description: behavior.name
   };
+  if (behavior.scope !== void 0) {
+    trait.scope = behavior.scope;
+  }
   if (behavior.states.length > 0) {
     trait.stateMachine = {
       states: behavior.states.map((state, index) => ({
@@ -2883,21 +2948,30 @@ function formatBehaviorToSchema(behavior) {
           event: t.event
         };
         if (t.guards.length > 0) {
-          const guardExprs = t.guards.map((g) => {
-            if (g.raw) {
-              return parseDomainGuard(g.raw, behavior.entityName);
+          const guardExprs = [];
+          for (const g of t.guards) {
+            const raw = g.raw ?? formatGuardToCondition(g);
+            try {
+              guardExprs.push(parseDomainGuard(raw, behavior.entityName));
+            } catch {
             }
-            return parseDomainGuard(formatGuardToCondition(g), behavior.entityName);
-          });
-          transition.guard = guardExprs.length === 1 ? guardExprs[0] : ["and", ...guardExprs];
+          }
+          if (guardExprs.length === 1) transition.guard = guardExprs[0];
+          else if (guardExprs.length > 1) transition.guard = ["and", ...guardExprs];
         }
         if (t.effects.length > 0) {
-          transition.effects = t.effects.map((e) => {
+          const effectExprs = [];
+          for (const e of t.effects) {
             if (e.config && "_rawSExpr" in e.config && Array.isArray(e.config._rawSExpr)) {
-              return e.config._rawSExpr;
+              effectExprs.push(e.config._rawSExpr);
+              continue;
             }
-            return parseDomainEffect(e.description, behavior.entityName);
-          });
+            try {
+              effectExprs.push(parseDomainEffect(e.description, behavior.entityName));
+            } catch {
+            }
+          }
+          if (effectExprs.length > 0) transition.effects = effectExprs;
         }
         return transition;
       })
@@ -3018,11 +3092,13 @@ function schemaEntityToDomainEntity(entity) {
       unique: field.unique || false,
       auto: field.auto || false
     };
-    if (fieldType === "enum") {
-      const enumValues = field.enumValues || field.values;
-      if (enumValues && enumValues.length > 0) {
-        domainField.enumValues = enumValues;
-      }
+    const enumValues = field.enumValues ?? field.values;
+    if (enumValues && enumValues.length > 0) {
+      domainField.enumValues = enumValues;
+    }
+    const items = field.items;
+    if (items && typeof items.type === "string") {
+      domainField.items = { type: mapSchemaTypeToDomain(items.type) };
     }
     if (field.default !== void 0) {
       domainField.default = field.default;
@@ -3031,6 +3107,7 @@ function schemaEntityToDomainEntity(entity) {
   }
   const states = entity.states;
   const initialState = entity.initialState;
+  const persistence = entity.persistence;
   return {
     type: "entity",
     name,
@@ -3038,13 +3115,17 @@ function schemaEntityToDomainEntity(entity) {
     fields,
     relationships,
     states,
-    initialState
+    initialState,
+    persistence
   };
 }
 function formatEntityText(entity) {
   const lines = [];
   const article = startsWithVowel2(entity.name) ? "An" : "A";
   lines.push(`${article} ${entity.name} is ${entity.description}`);
+  if (entity.persistence !== void 0 && entity.persistence !== "persistent") {
+    lines.push(`Persistence: ${entity.persistence}`);
+  }
   if (entity.fields.length > 0) {
     lines.push("");
     lines.push("It has:");
@@ -3091,6 +3172,8 @@ function formatFieldType2(field) {
   const parts = [];
   if (field.enumValues && field.enumValues.length > 0) {
     parts.push(field.enumValues.join(" | "));
+  } else if (field.fieldType === "list" && field.items) {
+    parts.push(`list of ${field.items.type}`);
   } else {
     parts.push(field.fieldType);
   }
@@ -3098,11 +3181,17 @@ function formatFieldType2(field) {
   if (field.unique) parts.push("unique");
   if (field.auto) parts.push("auto");
   if (field.default !== void 0) {
-    const defaultStr = typeof field.default === "string" ? `"${field.default}"` : String(field.default);
-    parts.push(`default ${defaultStr}`);
+    parts.push(`default ${formatDefaultValue(field.default)}`);
   }
   return parts.join(", ");
 }
+function formatDefaultValue(value) {
+  if (typeof value === "string") return `"${value}"`;
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
 function toSpaceSeparated3(text) {
   return text.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
 }
@@ -5069,6 +5158,7 @@ function schemaTraitToDomainBehavior(trait, entityName) {
       effects
     });
   }
+  const scope = trait.scope;
   return {
     type: "behavior",
     name: formatBehaviorName(name),
@@ -5077,13 +5167,18 @@ function schemaTraitToDomainBehavior(trait, entityName) {
     initialState,
     transitions,
     ticks,
-    rules: []
+    rules: [],
+    scope
   };
 }
 function formatBehaviorText(behavior) {
   const lines = [];
   lines.push(behavior.name);
   lines.push("");
+  if (behavior.scope !== void 0 && behavior.scope !== "instance") {
+    lines.push(`Scope: ${behavior.scope}`);
+    lines.push("");
+  }
   if (behavior.states.length > 0) {
     lines.push(`States: ${behavior.states.join(", ")}`);
     lines.push("");
@@ -5394,7 +5489,7 @@ function parseSchemaCondition(condition, defaultEntityName) {
         type: "comparison",
         field: fieldRef,
         operator: comparisonMatch[2],
-        value: parseValue4(comparisonMatch[3])
+        value: parseValue3(comparisonMatch[3])
       };
     }
   }
@@ -5422,7 +5517,7 @@ function parseFieldReference2(text, defaultEntityName) {
   }
   return null;
 }
-function parseValue4(text) {
+function parseValue3(text) {
   text = text.trim();
   if (text.startsWith('"') && text.endsWith('"') || text.startsWith("'") && text.endsWith("'")) {
     return text.slice(1, -1);
@@ -5796,7 +5891,7 @@ function convertDomainToSchema(domainText, baseSchema) {
       const entity = {
         name: entityRecord.name,
         fields: entityRecord.fields || [],
-        persistence: "persistent"
+        persistence: entityRecord.persistence ?? "persistent"
       };
       parsedEntities.push({
         name: result.data.name,