form0-core 0.7.0 → 0.8.0

package/README.md

@@ -289,3 +289,20 @@ ordinary validation failures. Persist the returned `freshness` companion separat
 and supply it to the host on reopening; do not clear stored pending status before persistence succeeds.
 `managedEvents: true` enables root and participating closed-row custom validation only. No save or
 closed-row lifecycle hooks are replayed. Renderer/worker/Native/CLI UI adoption is separate work.
+
+For an open editor, `await evaluator.evaluateScope(snapshot, { instancePath: [] })` evaluates only
+that record. Use complete ancestry to target a child. It reads current supplied ancestors and accepted
+other rows, returning the selected `state`, built-in validation summary, changes and separate
+execution issues/diagnostics without another complete tree. It leaves caller inputs and closed-row
+calculations unchanged. See [the record evaluation contract](analyses/RECORD_EVALUATION_CONTRACT.md).
+
+For accepted-snapshot viewing, supply `{ interactionMode: 'readonly' }` to `evaluateScope()`. It
+computes field state and intrinsic/submission findings from supplied values without running
+calculations or applying missing schema defaults. Editing is the default. Whole-tree evaluation and
+submission preparation retain their accepted/refresh policies.
+
+Scalar engines accept `mode: 'readonly' | 'edit'` (default `edit`) and expose `getMode()`/`setMode()`.
+Call `eval()` after a host mode change. Events receive authoritative `event.mode`; view-time data
+writes fail before host delegation. Load remains available for reads, alerts and scoped ON/OFF
+registration. Move writable initialization to new/edit handlers when it must run after View → Edit.
+See [the event contract](EVENT_CONTRACT.md) for permissions, lifecycle order and migration guidance.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "form0-core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
@@ -12,7 +12,7 @@
     "SECURITY.md"
   ],
   "scripts": {
-    "test": "node tests/form0-core.test.js && node tests/conditions.test.js && node tests/condition-scope.test.js && node tests/numeric-field-schema.test.js && node tests/dataset-descriptors.test.js && node tests/structured-record.test.js && node tests/title-fields.test.js && node tests/builtin-metadata.test.js && node tests/builtin-import-isolation.test.js && node tests/builtin-catalog-examples.test.js && node tests/date-builtins.test.js && node tests/calculation-expression-utils.test.js && node tests/calculation-editor.test.js && node tests/form-event-editor.test.js && node tests/form-authoring.test.js && node tests/calculation-dependency-engine.test.js && node tests/calculation-diagnostics.characterization.test.js && node tests/calculation-diagnostics.test.js && node tests/calculation-missing-result.test.js && node tests/evaluator-reentry.test.js && node tests/event-compatibility.characterization.test.js && node tests/event-hermes.test.js && node tests/event-async-isolation.test.js && node tests/managed-events.test.js && node tests/security-test.js && node tests/record-evaluator.test.js && node tests/complex-record-evaluator.test.js",
+    "test": "node tests/form0-core.test.js && node tests/conditions.test.js && node tests/condition-scope.test.js && node tests/numeric-field-schema.test.js && node tests/dataset-descriptors.test.js && node tests/structured-record.test.js && node tests/title-fields.test.js && node tests/builtin-metadata.test.js && node tests/builtin-import-isolation.test.js && node tests/builtin-catalog-examples.test.js && node tests/date-builtins.test.js && node tests/calculation-expression-utils.test.js && node tests/calculation-editor.test.js && node tests/form-event-editor.test.js && node tests/form-authoring.test.js && node tests/calculation-dependency-engine.test.js && node tests/calculation-diagnostics.characterization.test.js && node tests/calculation-diagnostics.test.js && node tests/calculation-missing-result.test.js && node tests/evaluator-reentry.test.js && node tests/expression-compilation.test.js && node tests/event-compatibility.characterization.test.js && node tests/event-hermes.test.js && node tests/event-async-isolation.test.js && node tests/managed-events.test.js && node tests/security-test.js && node tests/record-evaluator.test.js && node tests/complex-record-evaluator.test.js && node tests/record-scope.test.js",
     "format": "prettier --write \"src/**/*.{js,jsx}\" \"tests/**/*.{js,jsx}\" \"scripts/**/*.{js,mjs}\" package.json README.md EVENT_CONTRACT.md SECURITY.md SUPPORT.md CONTRIBUTING.md eslint.config.js .github/workflows/ci.yml .github/workflows/publish.yml",
     "format:check": "prettier --check \"src/**/*.{js,jsx}\" \"tests/**/*.{js,jsx}\" \"scripts/**/*.{js,mjs}\" package.json README.md EVENT_CONTRACT.md SECURITY.md SUPPORT.md CONTRIBUTING.md eslint.config.js .github/workflows/ci.yml .github/workflows/publish.yml",
     "lint:check": "eslint src tests",
@@ -52,6 +52,7 @@
     }
   ],
   "license": "MIT",
+  "funding": "https://opencollective.com/form0",
   "bugs": {
     "url": "https://github.com/paqu-io/form0-core/issues"
   },

package/src/builtins/builtin-definitions.js

@@ -238,6 +238,7 @@ export const SETRESULT_METADATA = defineBuiltinMetadata({
 
 export const ALERT_METADATA = defineBuiltinMetadata({
   name: 'ALERT',
+  operation: { type: 'UI_OPERATION', effects: ['presentation'] },
   category: 'event',
   signature: "ALERT(title, message = '')",
   description: 'Display an alert from a form event handler.',
@@ -247,6 +248,7 @@ export const ALERT_METADATA = defineBuiltinMetadata({
 
 export const SETVALUE_METADATA = defineBuiltinMetadata({
   name: 'SETVALUE',
+  operation: { type: 'FIELD_OPERATION', effects: ['record-write'] },
   category: 'event',
   signature: 'SETVALUE(fieldDataName, valueToSet)',
   description: 'Set a field value from a form event handler.',
@@ -256,6 +258,7 @@ export const SETVALUE_METADATA = defineBuiltinMetadata({
 
 export const ON_METADATA = defineBuiltinMetadata({
   name: 'ON',
+  operation: { type: 'EVENT_OPERATION', effects: ['listeners'] },
   category: 'event',
   signature: 'ON(eventType, fieldKeyOrCallback, callback)',
   description: 'Register an event handler within form event code.',
@@ -265,6 +268,7 @@ export const ON_METADATA = defineBuiltinMetadata({
 
 export const OFF_METADATA = defineBuiltinMetadata({
   name: 'OFF',
+  operation: { type: 'EVENT_OPERATION', effects: ['listeners'] },
   category: 'event',
   signature: 'OFF(eventType, fieldKeyOrCallback, callback)',
   description: 'Remove event handlers within form event code.',
@@ -274,6 +278,7 @@ export const OFF_METADATA = defineBuiltinMetadata({
 
 export const INVALID_METADATA = defineBuiltinMetadata({
   name: 'INVALID',
+  operation: { type: 'VALIDATION_OPERATION', effects: ['validation'] },
   category: 'event',
   signature: 'INVALID(message)',
   description:

package/src/builtins/builtin-metadata.js

@@ -8,6 +8,7 @@
  * @property {string} description
  * @property {string[]} examples
  * @property {BuiltinContext[]} contexts
+ * @property {{type: string, effects: string[]}} [operation] Declared descriptor effects.
  */
 
 export const BUILTIN_CONTEXTS = Object.freeze({
@@ -26,6 +27,14 @@ export function defineBuiltinMetadata(definition) {
     ...definition,
     examples: Object.freeze([...(definition.examples ?? [])]),
     contexts: Object.freeze([...(definition.contexts ?? [])]),
+    ...(definition.operation
+      ? {
+          operation: Object.freeze({
+            ...definition.operation,
+            effects: Object.freeze([...definition.operation.effects]),
+          }),
+        }
+      : {}),
   });
 }
 
@@ -40,5 +49,8 @@ export function cloneBuiltinMetadata(definition) {
     ...definition,
     examples: [...definition.examples],
     contexts: [...definition.contexts],
+    ...(definition.operation
+      ? { operation: { ...definition.operation, effects: [...definition.operation.effects] } }
+      : {}),
   };
 }

package/src/engine/calculation-bindings.js

@@ -0,0 +1,76 @@
+// Private conservative fast path for scalar expressions in a schema-bound record evaluator.
+// Unknown calls, EVAL, arguments, member access and complex JavaScript retain full bindings.
+import { parse } from 'acorn';
+import { calculationBuiltins } from '../builtins/registry.js';
+// These two canonical operations never consult ambient field context or invoke author callbacks.
+// Other builtins keep full bindings, including math functions that can be overridden by a host.
+const pureCalls = new Set(['SETRESULT', 'IF']);
+export function prepareScalarBindings(code) {
+  const names = new Set(),
+    calls = new Set();
+  function visit(node) {
+    if (!node) return true;
+    switch (node.type) {
+      case 'Program':
+        return node.body.length === 1 && visit(node.body[0]);
+      case 'ExpressionStatement':
+        return visit(node.expression);
+      case 'Literal':
+        return !node.regex;
+      case 'Identifier':
+        if (!node.name.startsWith('$') && !['undefined', 'NaN', 'Infinity'].includes(node.name))
+          return false;
+        names.add(node.name);
+        return true;
+      case 'UnaryExpression':
+        return node.operator !== 'delete' && visit(node.argument);
+      case 'BinaryExpression':
+      case 'LogicalExpression':
+        return visit(node.left) && visit(node.right);
+      case 'ConditionalExpression':
+        return visit(node.test) && visit(node.consequent) && visit(node.alternate);
+      case 'CallExpression':
+        if (node.optional || node.callee.type !== 'Identifier' || !pureCalls.has(node.callee.name))
+          return false;
+        names.add(node.callee.name);
+        calls.add(node.callee.name);
+        return node.arguments.every(visit);
+      default:
+        return false;
+    }
+  }
+  try {
+    return visit(parse(code, { ecmaVersion: 'latest' }))
+      ? { names, calls, fieldCount: [...names].filter((name) => name.startsWith('$')).length }
+      : null;
+  } catch {
+    return null;
+  }
+}
+export function selectScalarBindings(preparation, values, helpers) {
+  const plan = preparation.scalar;
+  if (!plan) return null;
+  for (const name of plan.calls) if (helpers[name] !== calculationBuiltins[name]) return null;
+  const bindings = (preparation.scalarBindings ??= preparation.bindings.filter(([, identifier]) =>
+    plan.names.has(identifier)
+  ));
+  // Missing/restricted names can fall through to host globals in legacy JavaScript.
+  // Specialize only when every field identifier resolves to a captured primitive value.
+  if (bindings.length !== plan.fieldCount) return null;
+  for (const [name] of bindings)
+    if (
+      !Object.hasOwn(values, name) ||
+      (values[name] !== null &&
+        !['undefined', 'string', 'number', 'boolean', 'bigint'].includes(typeof values[name]))
+    )
+      return null;
+  for (const name of plan.names)
+    if (
+      Object.hasOwn(helpers, name) &&
+      helpers[name] !== calculationBuiltins[name] &&
+      helpers[name] !== null &&
+      !['undefined', 'string', 'number', 'boolean', 'bigint'].includes(typeof helpers[name])
+    )
+      return null;
+  return { names: plan.names, bindings };
+}

package/src/engine/calculation.js

@@ -1,3 +1,4 @@
+import { prepareScalarBindings, selectScalarBindings } from './calculation-bindings.js';
 import { analyzeRepeatableCollections } from '../utilities/repeatable-collections.js';
 import { runExpression } from './evaluator.js';
 import { ContextResolver } from './context-resolver.js';
@@ -111,7 +112,7 @@ function buildScopedContext(
   diagnostics,
   preparation = null
 ) {
-  const ctx = { ...helpers };
+  let ctx;
 
   const referencedFields = preparation?.references ?? extractStaticFieldReferences(expressionCode);
   const access = (fieldName) => {
@@ -136,9 +137,20 @@ function buildScopedContext(
     preparation.bindings ??= [...contextResolver.fieldOwnership.keys()]
       .filter((name) => access(name) === 'accessible')
       .map((name) => [name, `$${name}`]);
-    for (const [name, identifier] of preparation.bindings)
+    // Use fewer parameters only when syntax and current primitive bindings prove it safe.
+    // Keep the full context for dynamic expressions, helper overrides and object inputs.
+    const scalar = selectScalarBindings(preparation, values, helpers);
+    ctx = scalar
+      ? Object.fromEntries(
+          [...scalar.names]
+            .filter((name) => Object.hasOwn(helpers, name))
+            .map((name) => [name, helpers[name]])
+        )
+      : { ...helpers };
+    for (const [name, identifier] of scalar?.bindings ?? preparation.bindings)
       if (Object.hasOwn(values, name)) ctx[identifier] = values[name];
   } else {
+    ctx = { ...helpers };
     for (const [fieldName, value] of Object.entries(values)) {
       const accessLevel = access(fieldName);
 
@@ -308,6 +320,7 @@ export function evaluateCalculatedField(
         context: buildCalculationExecutionContext(schema, field.data_name, resolver),
         references: extractStaticFieldReferences(field.calculate),
         access: new Map(),
+        scalar: prepareScalarBindings(field.calculate),
       };
       execution.preparationCache.set(field.data_name, preparation);
     }

package/src/engine/evaluator.js

@@ -3,6 +3,7 @@ import { __setEvalContext } from '../builtins/control/eval.js';
 import { __setDataNamesContext } from '../builtins/schema/datanames.js';
 import { validateExpression, createSecureContext, withTimeout } from '../security/validation.js';
 import { DEFAULT_SECURITY_CONFIG } from '../security/config.js';
+import { compileExpression } from './expression-compilation.js';
 import {
   isMultilineCalculationExpression,
   normalizeInlineCalculationExpression,
@@ -54,10 +55,6 @@ export function runExpression(
 
     // Create secure context based on security mode
     const secureContext = createSecureContext(context, securityConfig);
-    const keys = options.compileCache
-      ? Object.keys(secureContext).sort()
-      : Object.keys(secureContext);
-    const values = keys.map((key) => secureContext[key]);
 
     // Execute expression
     const executeExpression = () => {
@@ -74,9 +71,8 @@ export function runExpression(
         if (isMultiLine) {
           // Reuse a factory-owned compilation cache when supplied; values stay per evaluation.
           phase = 'syntax';
-          const cacheKey = JSON.stringify(['body', keys, expr]);
-          const fn = options.compileCache?.get(cacheKey) ?? new Function(...keys, expr);
-          options.compileCache?.set(cacheKey, fn);
+          const { fn, keys } = compileExpression(expr, secureContext, 'body', options.compileCache);
+          const values = keys.map((key) => secureContext[key]);
           phase = 'runtime';
           const result = fn(...values);
           // Check for consumed result from SETRESULT() calls in multiline code
@@ -89,11 +85,13 @@ export function runExpression(
           // Execute as expression (existing behavior)
           const inlineExpression = normalizeInlineCalculationExpression(expr);
           phase = 'syntax';
-          const cacheKey = JSON.stringify(['expression', keys, inlineExpression]);
-          const fn =
-            options.compileCache?.get(cacheKey) ??
-            new Function(...keys, `return (${inlineExpression});`);
-          options.compileCache?.set(cacheKey, fn);
+          const { fn, keys } = compileExpression(
+            inlineExpression,
+            secureContext,
+            'expression',
+            options.compileCache
+          );
+          const values = keys.map((key) => secureContext[key]);
           phase = 'runtime';
           const result = fn(...values);
           const consumed = __consumeResult();

package/src/engine/event-operation-scope.js

@@ -2,8 +2,11 @@ import {
   __invokeBoundEventBuiltin,
   __runWithEventOperationScope,
 } from '../builtins/event/event-operations-collector.js';
+import { EVENT_BUILTIN_DEFINITIONS } from '../builtins/builtin-definitions.js';
 
-const EVENT_OPERATION_BUILTINS = ['ALERT', 'SETVALUE', 'ON', 'OFF', 'INVALID'];
+const EVENT_OPERATION_BUILTINS = EVENT_BUILTIN_DEFINITIONS.filter((entry) => entry.operation).map(
+  (entry) => entry.name
+);
 
 /**
  * Create an operation scope owned by one synchronous event execution.
@@ -36,9 +39,10 @@ export function createEventOperationScope(onLateOperation) {
 /**
  * Bind canonical event operation builtins to their originating scope.
  * Intentional helper overrides are left untouched.
+ * ownsContext is private: only a fresh context owned by this execution may be modified.
  */
-export function bindEventBuiltins(context, canonicalBuiltins, scope) {
-  const boundContext = { ...context };
+export function bindEventBuiltins(context, canonicalBuiltins, scope, ownsContext = false) {
+  const boundContext = ownsContext ? context : { ...context };
 
   for (const name of EVENT_OPERATION_BUILTINS) {
     const builtin = canonicalBuiltins[name];

package/src/engine/event-policy.js

@@ -0,0 +1,61 @@
+import { BUILTIN_DEFINITIONS } from '../builtins/builtin-definitions.js';
+
+const operations = new Map(
+  BUILTIN_DEFINITIONS.filter((entry) => entry.operation).map((entry) => [
+    entry.name,
+    entry.operation,
+  ])
+);
+const knownEffects = new Set(['record-write', 'presentation', 'listeners', 'validation']);
+
+export function validateInteractionMode(mode) {
+  if (mode !== 'edit' && mode !== 'readonly') throw new Error('mode must be "edit" or "readonly".');
+  return mode;
+}
+
+/** Shared descriptor policy; permission comes from the engine, never event metadata. */
+export function eventOperationIssue(operation, mode, eventType) {
+  const declaration = operations.get(operation?.operation);
+  if (
+    !declaration ||
+    declaration.type !== operation?.type ||
+    !declaration.effects.length ||
+    declaration.effects.some((effect) => !knownEffects.has(effect))
+  )
+    return {
+      code: 'invalid_operation',
+      message: 'Event operations require declared, supported effects.',
+    };
+  const validation = /^(validate)-/.test(eventType);
+  const closing = /^(cancel|unload)-/.test(eventType);
+  if (declaration.effects.includes('validation')) {
+    return validation
+      ? null
+      : {
+          code: 'invalid_context',
+          message: 'INVALID() is only available during managed validation.',
+        };
+  }
+  if (validation || closing)
+    return {
+      code: 'operation_not_allowed',
+      message: 'Validation and close handlers cannot perform value, listener or UI operations.',
+    };
+  if (mode === 'readonly' && declaration.effects.includes('record-write'))
+    return {
+      code: 'readonly_operation_not_allowed',
+      message:
+        'View-mode handlers cannot change record data. Guard SETVALUE() with event.mode or move writable initialization to a new/edit handler.',
+    };
+  return null;
+}
+
+export function reportEventOperationIssue(warningSystem, issue, eventType) {
+  warningSystem.emitWarning({
+    type: 'EVENT_OPERATION_WARNING',
+    reason: issue.code,
+    severity: 'error',
+    message: issue.message,
+    executionContext: { type: 'event', eventType, fieldName: null },
+  });
+}

package/src/engine/event-registration.js

@@ -0,0 +1,38 @@
+import { parse } from 'acorn';
+import { ON } from '../builtins/event/control/on.js';
+
+/**
+ * Canonical ON calls with literal routes only create handlers; their bodies are not executed.
+ * Anything else needs the complete initialization context. Do not restrict handler body syntax.
+ */
+export function isLiteralEventRegistration(code, on) {
+  if (on !== ON || typeof code !== 'string') return false;
+  try {
+    const tree = parse(code, { ecmaVersion: 'latest', sourceType: 'commonjs' });
+    return (
+      tree.body.length > 0 &&
+      tree.body.every((statement) => {
+        const call = statement.expression;
+        if (
+          statement.type !== 'ExpressionStatement' ||
+          call.type !== 'CallExpression' ||
+          call.optional ||
+          call.callee.type !== 'Identifier' ||
+          call.callee.name !== 'ON' ||
+          ![2, 3].includes(call.arguments.length)
+        )
+          return false;
+        const callback = call.arguments.at(-1);
+        return (
+          ['FunctionExpression', 'ArrowFunctionExpression'].includes(callback.type) &&
+          call.arguments
+            .slice(0, -1)
+            .every((argument) => argument.type === 'Literal' && typeof argument.value === 'string')
+        );
+      })
+    );
+  } catch {
+    // Existing validation/execution owns syntax diagnostics.
+    return false;
+  }
+}

package/src/engine/event-source.js

@@ -1,10 +1,10 @@
 import { parse } from 'acorn';
 
 /** Retains authored callback source without depending on engine-specific toString output. */
-export function createEventSourceRegistry(preparationCache = null) {
+export function createEventSourceRegistry(preparationCache = new Map()) {
   const sources = new WeakMap();
 
-  function bindPrepared(prepared, context) {
+  function bindPrepared(prepared, context, ownsContext) {
     const propertyNames = new Map();
     const capture = (callback, source, name) => {
       sources.set(callback, source);
@@ -26,18 +26,21 @@ export function createEventSourceRegistry(preparationCache = null) {
     };
     capture.nameFor = (id) => propertyNames.get(id);
 
-    return {
-      code: prepared.code,
-      context: {
-        ...context,
-        [prepared.captureName]: capture,
-      },
-    };
+    const captured = ownsContext ? context : { ...context };
+    Object.defineProperty(captured, prepared.captureName, {
+      value: capture,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+    return { code: prepared.code, context: captured };
   }
 
-  function prepare(code, context) {
+  // Metadata may be attached in place only to an execution-owned context, never host/engine state.
+  function prepare(code, context, ownsContext = false) {
     const cached = preparationCache?.get(code);
-    if (cached && !Object.hasOwn(context, cached.captureName)) return bindPrepared(cached, context);
+    if (cached && !Object.hasOwn(context, cached.captureName))
+      return bindPrepared(cached, context, ownsContext);
     let tree;
     try {
       // Event scripts are Function bodies, rather than modules or global scripts.
@@ -154,7 +157,7 @@ export function createEventSourceRegistry(preparationCache = null) {
 
     const result = { code: prepared, captureName };
     preparationCache?.set(code, result);
-    return bindPrepared(result, context);
+    return bindPrepared(result, context, ownsContext);
   }
 
   function getSource(callback) {

package/src/engine/events.js

@@ -3,6 +3,7 @@ import { eventBuiltins } from '../builtins/registry.js';
 import { ContextResolver } from './context-resolver.js';
 import { WarningSystem } from './warning-system.js';
 import { createEventSourceRegistry } from './event-source.js';
+import { eventOperationIssue, reportEventOperationIssue } from './event-policy.js';
 import {
   bindEventBuiltins,
   closeEventOperationScope,
@@ -63,7 +64,7 @@ export class EventManager {
 
     try {
       // Execute the code to register event listeners (same security as calculated fields).
-      const prepared = this.callbackSources.prepare(code, scopedContext);
+      const prepared = this.callbackSources.prepare(code, scopedContext, true);
       const result = runInEventOperationScope(scope, () =>
         runExpression(prepared.code, prepared.context, this.securityConfig, true, this.schema, {
           sourceExpression: code,
@@ -301,13 +302,17 @@ export class EventManager {
       };
     }
 
-    contextWithEvent = bindEventBuiltins(contextWithEvent, eventBuiltins, scope);
+    // Each branch above supplies a private execution context; the manager base stays untouched.
+    contextWithEvent = bindEventBuiltins(contextWithEvent, eventBuiltins, scope, true);
 
     // Execute the callback function with the scoped context
     // This ensures EVAL() and other builtins have access to field values
     const functionCall = `(${callbackCode})(event)`;
+    // Retain nested ON callbacks created during a handler without depending on toString (Hermes).
+    const prepared = this.callbackSources.prepare(functionCall, contextWithEvent, true);
     return runInEventOperationScope(scope, () =>
-      runExpression(functionCall, contextWithEvent, this.securityConfig, true, this.schema, {
+      runExpression(prepared.code, prepared.context, this.securityConfig, true, this.schema, {
+        sourceExpression: functionCall,
         compileCache: this.compilationCache,
         evaluateAsExpression: true,
         ...(managed?.reporting || {}),
@@ -487,8 +492,10 @@ export class EventManager {
    * @param {Object} eventMetadata - Additional event metadata
    * @returns {Array} Array of operation descriptors
    */
-  trigger(eventType, fieldKey, eventMetadata) {
+  trigger(eventType, fieldKey, eventMetadata, mode = 'edit') {
     const operations = [];
+    const registrations = [];
+    let rejectedBatch = false;
     const eventMap = this.listeners.get(eventType);
 
     if (!eventMap) return operations;
@@ -500,6 +507,7 @@ export class EventManager {
       timestamp: Date.now(),
       // TODO: Add more metadata as needed
       ...eventMetadata,
+      mode,
     };
 
     // Create execution context for operation validation
@@ -521,35 +529,51 @@ export class EventManager {
       try {
         // Execute the callback with current form context
         // This ensures EVAL() and other builtins have access to field values
-        result = this.executeHandlerWithContext(callback, event, scope);
+        result = this.executeHandlerWithContext(callback, { ...event, mode }, scope);
       } catch (error) {
         // Simple error message for now
         console.warn(`[form0] Event listener failed: ${error.message}`);
       } finally {
         collectedOps = closeEventOperationScope(scope);
-        const runtimeOps = collectedOps.filter(
-          (operation) => operation?.type !== 'EVENT_OPERATION'
-        );
+        const runtimeOps = [];
+        for (const operation of collectedOps) {
+          const rejected = eventOperationIssue(operation, mode, eventType);
+          if (rejected) {
+            rejectedBatch = true;
+            reportEventOperationIssue(this.warningSystem, rejected, eventType);
+          } else if (operation.type === 'EVENT_OPERATION') registrations.push(operation);
+          else runtimeOps.push(operation);
+        }
 
         // Validate operations against context restrictions before adding them
         const validOps = this.validateOperations(runtimeOps, executionContext);
         operations.push(...validOps);
 
-        // EVENT_OPERATION processing is initialization-only. ON/OFF calls inside a handler neither
-        // mutate the listener registry nor leak internal registration descriptors to the host.
+        // Listener updates are committed after the entire permitted dispatch, never sent to hosts.
       }
 
       try {
         this.reportAsyncHandlerResult(result, executionContext, handlerName);
         // For backward compatibility, still handle returned operations
-        if (result && result.type === 'UI_OPERATION' && !collectedOps.includes(result)) {
-          operations.push(result);
+        if (
+          typeof result?.type === 'string' &&
+          result.type.endsWith('_OPERATION') &&
+          !collectedOps.includes(result)
+        ) {
+          const rejected = eventOperationIssue(result, mode, eventType);
+          if (rejected) {
+            rejectedBatch = true;
+            reportEventOperationIssue(this.warningSystem, rejected, eventType);
+          } else if (result.type === 'EVENT_OPERATION') registrations.push(result);
+          else operations.push(...this.validateOperations([result], executionContext));
         }
       } catch (error) {
         console.warn(`[form0] Event listener failed: ${error.message}`);
       }
     });
 
+    if (rejectedBatch) return [];
+    this.processEventOperations(registrations);
     return operations;
   }
 

package/src/engine/expression-compilation.js

@@ -0,0 +1,39 @@
+// Owned by the supplied compilation cache. Keep parameter names and functions only;
+// never retain record values, helper closures, permissions or diagnostic callbacks.
+const layoutsByCache = new WeakMap();
+
+export function compileExpression(code, context, mode, cache) {
+  const incomingKeys = Object.keys(context);
+  const body = mode === 'body' ? code : `return (${code});`;
+  if (!cache) return { keys: incomingKeys, fn: new Function(...incomingKeys, body) };
+
+  let expressions = layoutsByCache.get(cache);
+  if (!expressions) {
+    expressions = new Map();
+    layoutsByCache.set(cache, expressions);
+  }
+  const expressionKey = JSON.stringify([mode, code]);
+  const layouts = expressions.get(expressionKey) || [];
+  const index = layouts.findIndex(
+    (layout) =>
+      layout.incomingKeys.length === incomingKeys.length &&
+      layout.incomingKeys.every((key, position) => key === incomingKeys[position])
+  );
+  const existing = layouts[index];
+  // Respect explicit clearing/replacement of the caller-owned compilation cache.
+  if (existing && cache.get(existing.cacheKey) === existing.fn) return existing;
+
+  const keys = [...incomingKeys].sort();
+  const cacheKey = JSON.stringify([mode, keys, code]);
+  const fn = cache.get(cacheKey) ?? new Function(...keys, body);
+  cache.set(cacheKey, fn);
+  const layout = { incomingKeys, keys, cacheKey, fn };
+  const replacement =
+    index >= 0 ? index : layouts.findIndex((entry) => entry.cacheKey === cacheKey);
+  if (replacement >= 0) layouts[replacement] = layout;
+  else {
+    layouts.push(layout);
+  }
+  expressions.set(expressionKey, layouts);
+  return layout;
+}