form0-core 0.5.1 → 0.7.0

package/src/engine/conditions.js

@@ -1,4 +1,4 @@
-import { flattenFields } from '../utilities/field-helpers.js';
+import { assertConditionReferences, createConditionContext } from './condition-context.js';
 
 const valuesEqual = (a, b) => {
   if (Array.isArray(a) && Array.isArray(b)) {
@@ -81,37 +81,50 @@ function normalizeConditionValue(field, value) {
   return value;
 }
 
-export function evaluateConditions(conditions, values, allFields) {
+export function evaluateConditions(conditions, values, allFields, scope = null) {
+  if (scope) {
+    assertConditionReferences(conditions, scope.owner, scope.property, scope.context);
+  }
+  return evaluateConditionExpression(conditions, values, allFields);
+}
+
+function evaluateConditionExpression(conditions, values, allFields) {
   if (Array.isArray(conditions)) {
-    return conditions.every((c) => evaluateConditions(c, values, allFields));
+    return conditions.every((c) => evaluateConditionExpression(c, values, allFields));
   }
 
   if (conditions.and) {
-    return conditions.and.every((c) => evaluateConditions(c, values, allFields));
+    return conditions.and.every((c) => evaluateConditionExpression(c, values, allFields));
   }
 
   if (conditions.or) {
-    return conditions.or.some((c) => evaluateConditions(c, values, allFields));
+    return conditions.or.some((c) => evaluateConditionExpression(c, values, allFields));
   }
 
   // Map field_id (key) to data_name for value lookup
   const field = allFields ? allFields[conditions.field_id] : undefined;
   const dataName = field ? field.data_name : undefined;
   const val = normalizeConditionValue(field, dataName ? values[dataName] : undefined);
-  // Debug log: show what is being checked
-  //console.log('[evaluateConditions] field_id:', conditions.field_id, 'data_name:', dataName, 'value in values:', val, 'expected:', conditions.value, 'operator:', conditions.operator);
   const fn = OPERATORS[conditions.operator];
   return fn ? fn(val, conditions.value) : false;
 }
 
+function evaluateElementCondition(owner, property, values, context) {
+  return evaluateConditions(owner[property], values, context.allFields, {
+    owner,
+    property,
+    context,
+  });
+}
+
 /**
  * Recursively evaluates visibility for both fields and sections in bottom-up order
  * @param {Array} elements - Form elements to evaluate
  * @param {Object} values - Current form values
  * @param {Object} visible - Visibility state object to populate
- * @param {Object} allFields - Map of all fields by key for condition evaluation
+ * @param {Object} context - Shared field index and ownership resolver
  */
-function evaluateVisibilityRecursive(elements, values, visible, allFields) {
+function evaluateVisibilityRecursive(elements, values, visible, context) {
   elements.forEach((element) => {
     if (
       element.type === 'Section' ||
@@ -120,7 +133,7 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
     ) {
       // First evaluate children (bottom-up approach)
       if (element.elements && element.elements.length > 0) {
-        evaluateVisibilityRecursive(element.elements, values, visible, allFields);
+        evaluateVisibilityRecursive(element.elements, values, visible, context);
 
         // Check if any child is visible
         const hasVisibleChild = element.elements.some(
@@ -133,7 +146,12 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
         } else {
           // At least one child visible → respect explicit section visibility settings
           if (element.visible_conditions) {
-            const isVisible = evaluateConditions(element.visible_conditions, values, allFields);
+            const isVisible = evaluateElementCondition(
+              element,
+              'visible_conditions',
+              values,
+              context
+            );
             visible[element.data_name] = isVisible;
           } else {
             visible[element.data_name] = element.visible === true;
@@ -142,7 +160,12 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
       } else {
         // Empty section fallback (though schema validation should prevent this)
         if (element.visible_conditions) {
-          const isVisible = evaluateConditions(element.visible_conditions, values, allFields);
+          const isVisible = evaluateElementCondition(
+            element,
+            'visible_conditions',
+            values,
+            context
+          );
           visible[element.data_name] = isVisible;
         } else {
           visible[element.data_name] = element.visible === true;
@@ -151,7 +174,7 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
     } else {
       // Regular field - existing logic
       if (element.visible_conditions) {
-        const isVisible = evaluateConditions(element.visible_conditions, values, allFields);
+        const isVisible = evaluateElementCondition(element, 'visible_conditions', values, context);
         visible[element.data_name] = isVisible;
       } else {
         visible[element.data_name] = element.visible === true;
@@ -160,34 +183,24 @@ function evaluateVisibilityRecursive(elements, values, visible, allFields) {
   });
 }
 
-export function evaluateVisibility(schema, values, visible) {
-  // Build allFields map by key using flattened fields for condition evaluation
-  // PERFORMANCE NOTE: For large/static schemas, consider caching/memoizing allFields per schema
-  // to avoid rebuilding on every evaluation. See #perf-caching-idea.
-  const fields = flattenFields(schema.elements);
-  const allFields = {};
-  fields.forEach((field) => {
-    if (field.key) allFields[field.key] = field;
-    if (field.data_name) allFields[field.data_name] = field;
-  });
-
-  // Use recursive approach for single-pass visibility evaluation
-  evaluateVisibilityRecursive(schema.elements, values, visible, allFields);
+export function evaluateVisibility(
+  schema,
+  values,
+  visible,
+  context = createConditionContext(schema)
+) {
+  evaluateVisibilityRecursive(schema.elements, values, visible, context);
 }
 
-export function evaluateRequirement(schema, values, required) {
-  const fields = flattenFields(schema.elements);
-  // Build allFields map by key
-  // PERFORMANCE NOTE: For large/static schemas, consider caching/memoizing allFields per schema
-  // to avoid rebuilding on every evaluation. See #perf-caching-idea.
-  const allFields = {};
-  fields.forEach((field) => {
-    if (field.key) allFields[field.key] = field;
-    if (field.data_name) allFields[field.data_name] = field;
-  });
-  fields.forEach((field) => {
+export function evaluateRequirement(
+  schema,
+  values,
+  required,
+  context = createConditionContext(schema)
+) {
+  context.fields.forEach((field) => {
     if (field.required_conditions) {
-      const isRequired = evaluateConditions(field.required_conditions, values, allFields);
+      const isRequired = evaluateElementCondition(field, 'required_conditions', values, context);
       required[field.data_name] = isRequired;
     } else {
       required[field.data_name] = field.required === true;
@@ -195,19 +208,15 @@ export function evaluateRequirement(schema, values, required) {
   });
 }
 
-export function evaluateReadOnly(schema, values, read_only) {
-  const fields = flattenFields(schema.elements);
-  // Build allFields map by key
-  // PERFORMANCE NOTE: For large/static schemas, consider caching/memoizing allFields per schema
-  // to avoid rebuilding on every evaluation. See #perf-caching-idea.
-  const allFields = {};
-  fields.forEach((field) => {
-    if (field.key) allFields[field.key] = field;
-    if (field.data_name) allFields[field.data_name] = field;
-  });
-  fields.forEach((field) => {
+export function evaluateReadOnly(
+  schema,
+  values,
+  read_only,
+  context = createConditionContext(schema)
+) {
+  context.fields.forEach((field) => {
     if (field.read_only_conditions) {
-      const isReadOnly = evaluateConditions(field.read_only_conditions, values, allFields);
+      const isReadOnly = evaluateElementCondition(field, 'read_only_conditions', values, context);
       read_only[field.data_name] = isReadOnly;
     } else {
       read_only[field.data_name] = field.read_only === true;

package/src/engine/context-resolver.js

@@ -1,5 +1,5 @@
 /**
- * Context-aware field resolution for calculations and events
+ * Context-aware field resolution for calculations, conditions and events
  * Determines which fields are accessible based on execution context
  * Reuses tree-building logic from record-transformer.js
  */
@@ -10,6 +10,7 @@ export class ContextResolver {
   constructor(schema) {
     // Maps to store field context information (similar to record-transformer.js)
     this.fieldOwnership = new Map(); // Field data_name -> { preferredKey, field, parentPath }
+    this.elementOwnership = new Map(); // Includes containers in their containing record context.
     this.repeatableSectionTree = new Map(); // RepeatableSection data_name -> tree info
     this.sectionFields = new Set(); // Section field names (organizational only)
 
@@ -26,6 +27,12 @@ export class ContextResolver {
     if (!Array.isArray(elements)) return;
 
     elements.forEach((element) => {
+      const preferredKey =
+        typeof element.key === 'string' && element.key.trim() !== ''
+          ? element.key
+          : element.data_name;
+      const ownership = { preferredKey, field: element, parentPath: [...parentPath] };
+      this.elementOwnership.set(element.data_name, ownership);
       if (element.type === 'Section' || element.type === 'BuildingPlanSection') {
         this.sectionFields.add(element.data_name);
         // Recursively process Section children with same parentPath
@@ -34,8 +41,6 @@ export class ContextResolver {
           this.buildFieldContext(element.elements, parentPath);
         }
       } else if (element.type === 'RepeatableSection') {
-        const preferredKey =
-          element.key && element.key.trim() !== '' ? element.key : element.data_name;
         const currentPath = [...parentPath, preferredKey];
 
         // Store this RepeatableSection in the tree
@@ -54,13 +59,7 @@ export class ContextResolver {
         }
       } else {
         // This is a regular field - determine its ownership
-        const preferredFieldKey =
-          element.key && element.key.trim() !== '' ? element.key : element.data_name;
-        this.fieldOwnership.set(element.data_name, {
-          preferredKey: preferredFieldKey,
-          field: element,
-          parentPath: [...parentPath], // Copy the current path
-        });
+        this.fieldOwnership.set(element.data_name, ownership);
       }
     });
   }
@@ -146,6 +145,19 @@ export class ContextResolver {
   checkRepeatableSectionAccessInfo(executionContext, fieldName, fieldInfo) {
     const { type: contextType, eventType, fieldName: contextFieldName } = executionContext;
 
+    if (contextType === 'condition') {
+      const owner = this.elementOwnership.get(contextFieldName);
+      if (owner) {
+        return this.resolveRepeatableSectionRelationship(
+          owner.parentPath,
+          fieldInfo.parentPath,
+          fieldName,
+          fieldInfo,
+          executionContext
+        );
+      }
+    }
+
     if (contextType === 'calculation') {
       // CalculatedField can only access fields in same RepeatableSection context
       const calculationFieldInfo = this.fieldOwnership.get(contextFieldName);
@@ -318,6 +330,10 @@ export class ContextResolver {
   buildRestrictedAccessSuggestion(executionContext, fieldName, fieldInfo, code) {
     const { type: contextType, eventType } = executionContext;
 
+    if (contextType === 'condition') {
+      return `Conditions can only reference fields in their containing record or its ancestors. Field '${fieldName}' belongs to: ${this.formatRepeatableSectionPath(fieldInfo.parentPath)}`;
+    }
+
     if (contextType === 'calculation') {
       if (code === 'different_repeatable_section') {
         return `CalculatedField can only access fields in the same RepeatableSection or ancestor contexts. Field '${fieldName}' is in RepeatableSection: ${this.formatRepeatableSectionPath(fieldInfo.parentPath)}`;

package/src/engine/evaluator.js

@@ -54,8 +54,10 @@ export function runExpression(
 
     // Create secure context based on security mode
     const secureContext = createSecureContext(context, securityConfig);
-    const keys = Object.keys(secureContext);
-    const values = Object.values(secureContext);
+    const keys = options.compileCache
+      ? Object.keys(secureContext).sort()
+      : Object.keys(secureContext);
+    const values = keys.map((key) => secureContext[key]);
 
     // Execute expression
     const executeExpression = () => {
@@ -70,9 +72,11 @@ export function runExpression(
           isMultilineCalculationExpression(sourceExpression);
 
         if (isMultiLine) {
-          // Execute as code block (recompile each time for now)
+          // Reuse a factory-owned compilation cache when supplied; values stay per evaluation.
           phase = 'syntax';
-          const fn = new Function(...keys, expr);
+          const cacheKey = JSON.stringify(['body', keys, expr]);
+          const fn = options.compileCache?.get(cacheKey) ?? new Function(...keys, expr);
+          options.compileCache?.set(cacheKey, fn);
           phase = 'runtime';
           const result = fn(...values);
           // Check for consumed result from SETRESULT() calls in multiline code
@@ -85,7 +89,11 @@ export function runExpression(
           // Execute as expression (existing behavior)
           const inlineExpression = normalizeInlineCalculationExpression(expr);
           phase = 'syntax';
-          const fn = new Function(...keys, `return (${inlineExpression});`);
+          const cacheKey = JSON.stringify(['expression', keys, inlineExpression]);
+          const fn =
+            options.compileCache?.get(cacheKey) ??
+            new Function(...keys, `return (${inlineExpression});`);
+          options.compileCache?.set(cacheKey, fn);
           phase = 'runtime';
           const result = fn(...values);
           const consumed = __consumeResult();

package/src/engine/event-source.js

@@ -1,10 +1,43 @@
 import { parse } from 'acorn';
 
 /** Retains authored callback source without depending on engine-specific toString output. */
-export function createEventSourceRegistry() {
+export function createEventSourceRegistry(preparationCache = null) {
   const sources = new WeakMap();
 
+  function bindPrepared(prepared, context) {
+    const propertyNames = new Map();
+    const capture = (callback, source, name) => {
+      sources.set(callback, source);
+      if (name && !callback.name)
+        Object.defineProperty(callback, 'name', { value: name, configurable: true });
+      return callback;
+    };
+    capture.key = (value, id) => {
+      const key = Reflect.ownKeys({ [value]: null })[0];
+      propertyNames.set(
+        id,
+        typeof key === 'symbol'
+          ? key.description === undefined
+            ? ''
+            : `[${key.description}]`
+          : key
+      );
+      return key;
+    };
+    capture.nameFor = (id) => propertyNames.get(id);
+
+    return {
+      code: prepared.code,
+      context: {
+        ...context,
+        [prepared.captureName]: capture,
+      },
+    };
+  }
+
   function prepare(code, context) {
+    const cached = preparationCache?.get(code);
+    if (cached && !Object.hasOwn(context, cached.captureName)) return bindPrepared(cached, context);
     let tree;
     try {
       // Event scripts are Function bodies, rather than modules or global scripts.
@@ -27,7 +60,6 @@ export function createEventSourceRegistry() {
     let captureName = '__form0CaptureEventSource';
     while (identifiers.has(captureName) || Object.hasOwn(context, captureName)) captureName += '_';
     const edits = [];
-    const propertyNames = new Map();
 
     function inferredName(node, parent) {
       if (node.id) return '';
@@ -120,33 +152,9 @@ export function createEventSourceRegistry() {
       prepared = prepared.slice(0, position) + text + prepared.slice(position);
     }
 
-    const capture = (callback, source, name) => {
-      sources.set(callback, source);
-      if (name && !callback.name)
-        Object.defineProperty(callback, 'name', { value: name, configurable: true });
-      return callback;
-    };
-    capture.key = (value, id) => {
-      const key = Reflect.ownKeys({ [value]: null })[0];
-      propertyNames.set(
-        id,
-        typeof key === 'symbol'
-          ? key.description === undefined
-            ? ''
-            : `[${key.description}]`
-          : key
-      );
-      return key;
-    };
-    capture.nameFor = (id) => propertyNames.get(id);
-
-    return {
-      code: prepared,
-      context: {
-        ...context,
-        [captureName]: capture,
-      },
-    };
+    const result = { code: prepared, captureName };
+    preparationCache?.set(code, result);
+    return bindPrepared(result, context);
   }
 
   function getSource(callback) {

package/src/engine/events.js

@@ -17,7 +17,7 @@ const _loggedHandlers = new Set();
  * EventManager handles form event registration and execution
  */
 export class EventManager {
-  constructor(schema = null, contextResolver = null, warningSystem = null) {
+  constructor(schema = null, contextResolver = null, warningSystem = null, preparation = {}) {
     this.listeners = new Map(); // eventType -> Map<fieldKey, callback[]>
     this.eventContext = null;
     this.securityConfig = null;
@@ -26,7 +26,9 @@ export class EventManager {
     this.contextResolver = contextResolver || (schema ? new ContextResolver(schema) : null);
     this.warningSystem = warningSystem || new WarningSystem();
     this.schema = schema;
-    this.callbackSources = createEventSourceRegistry();
+    this.callbackSources = createEventSourceRegistry(preparation.sourceCache);
+    this.compilationCache = preparation.compilationCache;
+    this.referenceSourceCache = preparation.referenceSourceCache;
     this.initializationIssues = [];
   }
 
@@ -65,6 +67,7 @@ export class EventManager {
       const result = runInEventOperationScope(scope, () =>
         runExpression(prepared.code, prepared.context, this.securityConfig, true, this.schema, {
           sourceExpression: code,
+          compileCache: this.compilationCache,
           onDiagnostic: (diagnostic) =>
             this.initializationIssues.push({
               code: 'initialization_failed',
@@ -305,6 +308,7 @@ export class EventManager {
     const functionCall = `(${callbackCode})(event)`;
     return runInEventOperationScope(scope, () =>
       runExpression(functionCall, contextWithEvent, this.securityConfig, true, this.schema, {
+        compileCache: this.compilationCache,
         evaluateAsExpression: true,
         ...(managed?.reporting || {}),
       })

package/src/engine/form-engine.js

@@ -4,7 +4,8 @@ import { evaluateRequirement } from './conditions.js';
 import { evaluateReadOnly } from './conditions.js';
 import { validateFields } from './field-validation.js';
 import { calculationBuiltins, eventBuiltins } from '../builtins/registry.js';
-import { validateSchema } from '../schema/schema-validator.js';
+import { validateSchemaWithContext } from '../schema/schema-validator.js';
+import { createConditionContext } from './condition-context.js';
 import { flattenFields } from '../utilities/field-helpers.js';
 import { DEFAULT_SECURITY_CONFIG } from '../security/config.js';
 import { EventManager } from './events.js';
@@ -77,7 +78,8 @@ export function createFormEngine({
 }) {
   const { schema: preparedSchema, buildingPlanMeta } = expandBuildingPlanSchema(schema);
 
-  validateSchema(preparedSchema.form);
+  const contextResolver = new ContextResolver(preparedSchema.form);
+  validateSchemaWithContext(preparedSchema.form, contextResolver);
 
   const { form } = preparedSchema;
   const values = { ...initialValues };
@@ -147,9 +149,9 @@ export function createFormEngine({
   const allHelpers = { ...calculationBuiltins, ...helpers };
 
   // Initialize context resolution system
-  const contextResolver = new ContextResolver(form);
   const calculationPlan = buildCalculationDependencyPlan(form, contextResolver);
   const sharedWarningSystem = warningSystem || new WarningSystem();
+  const conditionContext = createConditionContext(form, contextResolver, sharedWarningSystem);
   const calculationDiagnostics = createCalculationDiagnostics(
     diagnostics,
     onDiagnostics,
@@ -196,9 +198,9 @@ export function createFormEngine({
         calculationPlan,
         calculationDiagnostics
       );
-      evaluateRequirement(form, values, required);
-      evaluateVisibility(form, values, visible);
-      evaluateReadOnly(form, values, read_only);
+      evaluateRequirement(form, values, required, conditionContext);
+      evaluateVisibility(form, values, visible, conditionContext);
+      evaluateReadOnly(form, values, read_only, conditionContext);
       validateFields(form, values, errors);
     } catch (error) {
       calculationDiagnostics.abort(frame);
@@ -247,7 +249,7 @@ export function createFormEngine({
   };
 }
 
-function getDefaultValue(field) {
+export function getDefaultValue(field) {
   const spec = FIELD_SPECS[field.type];
   if (spec && spec.defaultProducer) {
     return spec.defaultProducer(field);

package/src/engine/managed-events.js

@@ -30,6 +30,10 @@ function copy(value, seen = new Map()) {
   return result;
 }
 
+const managedReferenceCaches = new WeakMap();
+const managedFieldCaches = new WeakMap();
+const managedRepeatableCaches = new WeakMap();
+
 /** Internal adapter; the public synchronous API is engine.triggerDetailed(). */
 export function createManagedEventDispatcher(manager, constructionScope) {
   const instancePath = copy(constructionScope?.instancePath);
@@ -37,18 +41,27 @@ export function createManagedEventDispatcher(manager, constructionScope) {
   if (scopeId !== undefined && (typeof scopeId !== 'string' || !scopeId.trim()))
     throw new Error('eventScope.scopeId must be a nonempty string when supplied.');
   const resolver = manager.contextResolver;
-  const fields = new Map(resolver.fieldOwnership);
+  if (!managedFieldCaches.has(resolver))
+    managedFieldCaches.set(resolver, new Map(resolver.fieldOwnership));
+  const fields = managedFieldCaches.get(resolver);
+  if (!managedRepeatableCaches.has(resolver))
+    managedRepeatableCaches.set(
+      resolver,
+      new Map(
+        [...resolver.repeatableSectionTree.values()].map((entry) => [
+          JSON.stringify([entry.parentPath, entry.preferredKey]),
+          entry,
+        ])
+      )
+    );
+  const repeatableIndex = managedRepeatableCaches.get(resolver);
   const statusField = manager.schema?.status_field;
   if (statusField?.enabled && typeof statusField.data_name === 'string')
     fields.set(statusField.data_name, { field: statusField, parentPath: [] });
   if (!Array.isArray(instancePath)) throw new Error('eventScope.instancePath must be an array.');
   const ownershipPath = [];
   for (const segment of instancePath) {
-    const repeatable = [...resolver.repeatableSectionTree.values()].find(
-      (entry) =>
-        entry.preferredKey === segment?.repeatableKey &&
-        JSON.stringify(entry.parentPath) === JSON.stringify(ownershipPath)
-    );
+    const repeatable = repeatableIndex.get(JSON.stringify([ownershipPath, segment?.repeatableKey]));
     if (
       !repeatable ||
       JSON.stringify(repeatable.parentPath) !== JSON.stringify(ownershipPath) ||
@@ -70,7 +83,8 @@ export function createManagedEventDispatcher(manager, constructionScope) {
   const readable = (path) =>
     path.length <= ownershipPath.length && path.every((key, index) => ownershipPath[index] === key);
   const ownedField = (name) => fields.get(name) || resolver.repeatableSectionTree.get(name);
-  const referenceCache = new WeakMap();
+  if (!managedReferenceCaches.has(manager)) managedReferenceCaches.set(manager, new WeakMap());
+  const referenceCache = managedReferenceCaches.get(manager);
   return function dispatch(eventType, fieldKey, metadata = {}) {
     const result = { operations: [], validationIssues: [], issues: [] };
     const issue = (code, message) =>
@@ -149,8 +163,12 @@ export function createManagedEventDispatcher(manager, constructionScope) {
       let collected;
       try {
         const source = manager.callbackSources.getSource(callback);
-        if (referenceCache.get(callback)?.source !== source)
-          referenceCache.set(callback, { source, references: getEventFieldReferences(source) });
+        if (referenceCache.get(callback)?.source !== source) {
+          const references =
+            manager.referenceSourceCache?.get(source) ?? getEventFieldReferences(source);
+          manager.referenceSourceCache?.set(source, references);
+          referenceCache.set(callback, { source, references });
+        }
         let rejectedReference = false;
         for (const name of referenceCache.get(callback).references) {
           const field = fields.get(name);