collabmd 0.1.32 → 0.1.34

package/src/server/domain/backlink-index.js

@@ -11,7 +11,7 @@
  */
 
 import { createWikiTargetIndex, resolveWikiTargetWithIndex } from '../../domain/wiki-link-resolver.js';
-import { isMarkdownFilePath } from '../../domain/file-kind.js';
+import { getVaultFileExtension, isMarkdownFilePath } from '../../domain/file-kind.js';
 import { mapWithConcurrency } from '../shared/async-utils.js';
 
 const WIKI_LINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
@@ -27,6 +27,39 @@ function createDeferred() {
   return { promise, reject, resolve };
 }
 
+function normalizeWikiTargetKey(target = '') {
+  const normalizedTarget = String(target ?? '').trim();
+  if (!normalizedTarget) {
+    return '';
+  }
+
+  return getVaultFileExtension(normalizedTarget)
+    ? normalizedTarget
+    : `${normalizedTarget}.md`;
+}
+
+function collectWikiTargetKeysForFilePath(filePath = '') {
+  const normalizedPath = String(filePath ?? '').trim();
+  if (!normalizedPath) {
+    return [];
+  }
+
+  const segments = normalizedPath.split('/').filter(Boolean);
+  const keys = [];
+  for (let index = 0; index < segments.length; index += 1) {
+    keys.push(segments.slice(index).join('/'));
+  }
+
+  if (isMarkdownFilePath(normalizedPath)) {
+    const rawSegments = normalizedPath.replace(/\.md$/i, '').split('/').filter(Boolean);
+    for (let index = 0; index < rawSegments.length; index += 1) {
+      keys.push(rawSegments.slice(index).join('/'));
+    }
+  }
+
+  return [...new Set(keys)];
+}
+
 export class BacklinkIndex {
   constructor({
     rebuildDelayMs = 150,
@@ -44,6 +77,10 @@ export class BacklinkIndex {
     this.reverse = new Map();
     /** @type {Map<string, Map<string, string[]>>} sourcePath → targetPath → contexts[] */
     this.contextsBySource = new Map();
+    /** @type {Map<string, Set<string>>} sourcePath → normalized raw target keys */
+    this.rawTargetKeysBySource = new Map();
+    /** @type {Map<string, Set<string>>} normalized raw target key → source paths */
+    this.rawTargetSources = new Map();
     /** @type {string[]} cached flat target file list for link resolution */
     this._fileList = [];
     /** @type {string[]} cached markdown source file list for content scans */
@@ -140,13 +177,16 @@ export class BacklinkIndex {
     this.forward.clear();
     this.reverse.clear();
     this.contextsBySource.clear();
+    this.rawTargetKeysBySource.clear();
+    this.rawTargetSources.clear();
 
     const snapshot = workspaceState ?? await this._resolveWorkspaceState();
     this._fileList = Array.from(snapshot?.filePaths ?? snapshot?.markdownPaths ?? []);
-    this._sourceFileList = Array.from(
-      snapshot?.markdownPaths ?? this._fileList.filter((filePath) => isMarkdownFilePath(filePath)),
-    ).filter((filePath) => this._fileList.includes(filePath));
     this._fileSet = new Set(this._fileList);
+    this._sourceFileList = Array.from(
+      snapshot?.markdownPaths
+        ?? this._fileList.filter((filePath) => isMarkdownFilePath(filePath)),
+    ).filter((filePath) => this._fileSet.has(filePath));
     this._refreshWikiTargetIndex();
 
     const fileContents = await mapWithConcurrency(
@@ -256,6 +296,21 @@ export class BacklinkIndex {
       this.contextsBySource.set(newPath, sourceContexts);
     }
 
+    if (this.rawTargetKeysBySource.has(oldPath)) {
+      const rawTargetKeys = this.rawTargetKeysBySource.get(oldPath);
+      this.rawTargetKeysBySource.delete(oldPath);
+      this.rawTargetKeysBySource.set(newPath, rawTargetKeys);
+      rawTargetKeys.forEach((rawTargetKey) => {
+        const sources = this.rawTargetSources.get(rawTargetKey);
+        if (!sources) {
+          return;
+        }
+
+        sources.delete(oldPath);
+        sources.add(newPath);
+      });
+    }
+
     // Move forward links
     const oldForward = this.forward.get(oldPath);
     if (oldForward) {
@@ -316,22 +371,64 @@ export class BacklinkIndex {
     previousState = null,
     nextState = null,
   } = {}) {
-    let refreshIndex = false;
     const previousEntries = previousState?.entries ?? new Map();
     const nextEntries = nextState?.entries ?? new Map();
+    const changedPaths = Array.from(new Set(workspaceChange.changedPaths ?? []));
+    const { impactedSources, renameMap } = this._computeWorkspaceChangeMeta(workspaceChange, changedPaths, previousEntries, nextEntries);
+
+    let refreshIndex = this._applyDeletedPaths(workspaceChange.deletedPaths);
+    refreshIndex = this._applyRenamedPaths(workspaceChange.renamedPaths, refreshIndex);
+    refreshIndex = await this._applyChangedPaths(changedPaths, previousEntries, nextEntries, refreshIndex);
 
-    for (const pathValue of workspaceChange.deletedPaths ?? []) {
+    if (refreshIndex) {
+      const sourcesToRefresh = this._collectRefreshSources(impactedSources, changedPaths, workspaceChange.renamedPaths, nextEntries);
+      this._refreshWikiTargetIndex();
+      await this._refreshImpactedSources(sourcesToRefresh, { nextEntries, renameMap });
+    }
+  }
+
+  _computeWorkspaceChangeMeta(workspaceChange, changedPaths, previousEntries, nextEntries) {
+    const createdPaths = changedPaths.filter((pathValue) => (
+      nextEntries.has(pathValue) && !previousEntries.has(pathValue)
+    ));
+    const removedChangedPaths = changedPaths.filter((pathValue) => (
+      !nextEntries.has(pathValue) && previousEntries.has(pathValue)
+    ));
+    const membershipAffectedPaths = [
+      ...(workspaceChange.deletedPaths ?? []),
+      ...removedChangedPaths,
+      ...createdPaths,
+      ...(workspaceChange.renamedPaths ?? []).flatMap((entry) => [entry?.oldPath, entry?.newPath]).filter(Boolean),
+    ];
+    const impactedSources = this._collectImpactedSourcesForMembershipChanges(membershipAffectedPaths);
+    const renameMap = new Map(
+      (workspaceChange.renamedPaths ?? [])
+        .filter((entry) => entry?.oldPath && entry?.newPath)
+        .map((entry) => [entry.oldPath, entry.newPath]),
+    );
+    return { impactedSources, renameMap };
+  }
+
+  _applyDeletedPaths(deletedPaths) {
+    let refreshIndex = false;
+    for (const pathValue of deletedPaths ?? []) {
       refreshIndex = this.onFileDeleted(pathValue, { refreshIndex: false }) || refreshIndex;
     }
+    return refreshIndex;
+  }
 
-    for (const entry of workspaceChange.renamedPaths ?? []) {
+  _applyRenamedPaths(renamedPaths, refreshIndex) {
+    for (const entry of renamedPaths ?? []) {
       if (!entry?.oldPath || !entry?.newPath) {
         continue;
       }
       refreshIndex = this.onFileRenamed(entry.oldPath, entry.newPath, { refreshIndex: false }) || refreshIndex;
     }
+    return refreshIndex;
+  }
 
-    for (const pathValue of new Set(workspaceChange.changedPaths ?? [])) {
+  async _applyChangedPaths(changedPaths, previousEntries, nextEntries, refreshIndex) {
+    for (const pathValue of changedPaths) {
       const existsNow = nextEntries.has(pathValue);
       const existedBefore = previousEntries.has(pathValue);
       if (!existsNow) {
@@ -359,10 +456,22 @@ export class BacklinkIndex {
         refreshIndex = this.onFileCreated(pathValue, content, { refreshIndex: false }) || refreshIndex;
       }
     }
+    return refreshIndex;
+  }
 
-    if (refreshIndex) {
-      this._refreshWikiTargetIndex();
-    }
+  _collectRefreshSources(impactedSources, changedPaths, renamedPaths, nextEntries) {
+    const sourcesToRefresh = new Set(impactedSources);
+    changedPaths.forEach((pathValue) => {
+      if (nextEntries.has(pathValue) && isMarkdownFilePath(pathValue)) {
+        sourcesToRefresh.add(pathValue);
+      }
+    });
+    (renamedPaths ?? []).forEach((entry) => {
+      if (entry?.newPath && isMarkdownFilePath(entry.newPath)) {
+        sourcesToRefresh.add(entry.newPath);
+      }
+    });
+    return sourcesToRefresh;
   }
 
   /**
@@ -408,6 +517,7 @@ export class BacklinkIndex {
   _indexFile(filePath, content) {
     const resolvedTargets = new Set();
     const contextsByTarget = new Map();
+    const rawTargetKeys = new Set();
     const lines = content.split('\n');
 
     for (const line of lines) {
@@ -419,6 +529,11 @@ export class BacklinkIndex {
           continue;
         }
 
+        const rawTargetKey = normalizeWikiTargetKey(target);
+        if (rawTargetKey) {
+          rawTargetKeys.add(rawTargetKey);
+        }
+
         const resolved = this._resolveTarget(target);
         if (!resolved || resolved === filePath) {
           continue;
@@ -434,6 +549,17 @@ export class BacklinkIndex {
     }
 
     this.contextsBySource.delete(filePath);
+    this._removeRawTargetSourceContributions(filePath);
+
+    if (rawTargetKeys.size > 0) {
+      this.rawTargetKeysBySource.set(filePath, rawTargetKeys);
+      rawTargetKeys.forEach((rawTargetKey) => {
+        if (!this.rawTargetSources.has(rawTargetKey)) {
+          this.rawTargetSources.set(rawTargetKey, new Set());
+        }
+        this.rawTargetSources.get(rawTargetKey).add(filePath);
+      });
+    }
 
     if (resolvedTargets.size > 0) {
       this.contextsBySource.set(filePath, contextsByTarget);
@@ -450,6 +576,7 @@ export class BacklinkIndex {
 
   _removeForwardLinks(filePath) {
     this.contextsBySource.delete(filePath);
+    this._removeRawTargetSourceContributions(filePath);
 
     const oldTargets = this.forward.get(filePath);
     if (!oldTargets) return;
@@ -478,6 +605,70 @@ export class BacklinkIndex {
   _refreshWikiTargetIndex() {
     this._wikiTargetIndex = createWikiTargetIndex(this._fileList);
   }
+
+  _removeRawTargetSourceContributions(filePath) {
+    const rawTargetKeys = this.rawTargetKeysBySource.get(filePath);
+    if (!rawTargetKeys) {
+      return;
+    }
+
+    rawTargetKeys.forEach((rawTargetKey) => {
+      const sources = this.rawTargetSources.get(rawTargetKey);
+      if (!sources) {
+        return;
+      }
+
+      sources.delete(filePath);
+      if (sources.size === 0) {
+        this.rawTargetSources.delete(rawTargetKey);
+      }
+    });
+    this.rawTargetKeysBySource.delete(filePath);
+  }
+
+  _collectImpactedSourcesForMembershipChanges(pathValues = []) {
+    const affectedTargetKeys = new Set();
+    pathValues.forEach((pathValue) => {
+      collectWikiTargetKeysForFilePath(pathValue).forEach((targetKey) => {
+        affectedTargetKeys.add(targetKey);
+      });
+    });
+
+    const impactedSources = new Set();
+    affectedTargetKeys.forEach((targetKey) => {
+      this.rawTargetSources.get(targetKey)?.forEach((sourcePath) => {
+        impactedSources.add(sourcePath);
+      });
+    });
+    return impactedSources;
+  }
+
+  async _refreshImpactedSources(impactedSources = new Set(), {
+    nextEntries = new Map(),
+    renameMap = new Map(),
+  } = {}) {
+    const refreshedSources = new Set();
+
+    for (const sourcePath of impactedSources) {
+      const livePath = renameMap.get(sourcePath) ?? sourcePath;
+      if (
+        refreshedSources.has(livePath)
+        || !livePath
+        || !isMarkdownFilePath(livePath)
+        || !nextEntries.has(livePath)
+      ) {
+        continue;
+      }
+
+      const content = await this.vaultFileStore.readMarkdownFile(livePath);
+      if (content === null) {
+        continue;
+      }
+
+      refreshedSources.add(livePath);
+      this.updateFile(livePath, content, { refreshIndex: false });
+    }
+  }
 }
 
 /** Flatten a vault tree into an array of file paths. */

package/src/server/domain/bases/base-definition.js

@@ -15,6 +15,25 @@ function capitalize(value = '') {
   return `${normalized.charAt(0).toUpperCase()}${normalized.slice(1)}`;
 }
 
+function normalizeDirection(value, fallback = 'asc') {
+  return String(value ?? fallback).toLowerCase() === 'desc' ? 'desc' : 'asc';
+}
+
+function normalizeFormulaPropertyId(value = '') {
+  const normalized = String(value ?? '').trim();
+  if (!normalized) {
+    return '';
+  }
+
+  return normalized.startsWith('formula.')
+    ? normalized
+    : `formula.${normalized}`;
+}
+
+function bareFormulaName(value = '') {
+  return normalizeFormulaPropertyId(value).replace(/^formula\./u, '');
+}
+
 function normalizeBaseView(rawView, index) {
   const view = isPlainObject(rawView) ? rawView : {};
   const type = typeof view.type === 'string' ? view.type : 'table';
@@ -43,9 +62,7 @@ function normalizeBaseView(rawView, index) {
       return acc;
     }, {}),
     filters: view.filters ?? null,
-    groupBy: typeof view.groupBy === 'string'
-      ? view.groupBy
-      : (typeof view.group_by === 'string' ? view.group_by : null),
+    groupBy: normalizeViewGroupBy(view.groupBy ?? view.group_by),
     id: `view-${index}`,
     image: typeof view.image === 'string' ? view.image : null,
     limit: Number.isFinite(Number(view.limit)) ? Math.max(0, Number(view.limit)) : null,
@@ -80,6 +97,31 @@ function normalizeViewOrder(value) {
   return [];
 }
 
+function normalizeViewGroupBy(value) {
+  if (typeof value === 'string' && value.trim()) {
+    return {
+      direction: 'asc',
+      explicitDirection: false,
+      property: value.trim(),
+    };
+  }
+
+  if (!isPlainObject(value)) {
+    return null;
+  }
+
+  const property = value.property ?? value.id ?? value.name ?? null;
+  if (typeof property !== 'string' || !property.trim()) {
+    return null;
+  }
+
+  return {
+    direction: normalizeDirection(value.direction ?? value.order, 'asc'),
+    explicitDirection: Object.hasOwn(value, 'direction') || Object.hasOwn(value, 'order'),
+    property: property.trim(),
+  };
+}
+
 function normalizeViewSort(value) {
   if (typeof value === 'string' && value.trim()) {
     return [{ direction: 'asc', property: value.trim() }];
@@ -103,9 +145,7 @@ function normalizeViewSort(value) {
         return null;
       }
 
-      const direction = String(entry.direction ?? entry.order ?? 'asc').toLowerCase() === 'desc'
-        ? 'desc'
-        : 'asc';
+      const direction = normalizeDirection(entry.direction ?? entry.order, 'asc');
       return { direction, property: property.trim() };
     })
     .filter(Boolean);
@@ -183,20 +223,70 @@ function resolvePropertyLabel(propertyId, definition) {
   if (config?.displayName) {
     return config.displayName;
   }
+
+  if (propertyId.startsWith('formula.')) {
+    return bareFormulaName(propertyId);
+  }
+
   return propertyId.startsWith('file.')
     ? propertyId.slice(5)
     : propertyId.replace(/^note\./u, '');
 }
 
+function normalizeFormulaEntries(rawFormulas, rawProperties) {
+  const formulas = {};
+  const appendFormula = (propertyId, formula, { legacy = false } = {}) => {
+    const normalizedId = normalizeFormulaPropertyId(propertyId);
+    if (!normalizedId || typeof formula !== 'string') {
+      return;
+    }
+
+    formulas[normalizedId] = {
+      formula,
+      id: normalizedId,
+      legacy,
+      name: bareFormulaName(normalizedId),
+    };
+  };
+
+  if (isPlainObject(rawFormulas)) {
+    Object.entries(rawFormulas).forEach(([name, formula]) => {
+      appendFormula(name, formula);
+    });
+  }
+
+  Object.entries(rawProperties).forEach(([id, config]) => {
+    if (typeof config?.formula === 'string') {
+      appendFormula(id, config.formula, { legacy: true });
+    }
+  });
+
+  return formulas;
+}
+
+function createFormulaLookup(formulas = {}) {
+  const lookup = new Map();
+
+  Object.keys(formulas).forEach((propertyId) => {
+    const bareName = bareFormulaName(propertyId);
+    if (bareName) {
+      lookup.set(bareName, propertyId);
+    }
+    lookup.set(propertyId, propertyId);
+  });
+
+  return lookup;
+}
+
 export function normalizeBaseDefinition(source = '') {
   const raw = yaml.load(String(source ?? '')) ?? {};
   const rawObject = isPlainObject(raw) ? raw : {};
   const rawProperties = isPlainObject(rawObject.properties) ? rawObject.properties : {};
+  const formulas = normalizeFormulaEntries(rawObject.formulas, rawProperties);
   const properties = Object.entries(rawProperties).reduce((acc, [id, config]) => {
     const normalizedConfig = isPlainObject(config) ? { ...config } : {};
     acc[id] = {
       displayName: typeof normalizedConfig.displayName === 'string' ? normalizedConfig.displayName : null,
-      formula: typeof normalizedConfig.formula === 'string' ? normalizedConfig.formula : null,
       id,
       raw: normalizedConfig,
     };
@@ -211,6 +301,8 @@ export function normalizeBaseDefinition(source = '') {
 
   return {
     filters: rawObject.filters ?? null,
+    formulas,
+    formulaLookup: createFormulaLookup(formulas),
     properties,
     raw: rawObject,
     views,
@@ -220,7 +312,10 @@ export function normalizeBaseDefinition(source = '') {
 export function buildColumns(definition, view) {
   const order = view.order.length > 0
     ? view.order
-    : ['file.name', ...Object.keys(definition.properties)];
+    : ['file.name', ...new Set([
+      ...Object.keys(definition.properties),
+      ...Object.keys(definition.formulas),
+    ])];
   return order.map((propertyId) => ({
     id: propertyId,
     label: resolvePropertyLabel(propertyId, definition),
@@ -230,8 +325,8 @@ export function buildColumns(definition, view) {
 export function collectEvaluatedPropertyIds(columns, view) {
   const propertyIds = new Set(columns.map((column) => column.id));
 
-  if (view.groupBy) {
-    propertyIds.add(view.groupBy);
+  if (view.groupBy?.property) {
+    propertyIds.add(view.groupBy.property);
   }
 
   view.sort.forEach((sortConfig) => {
@@ -249,7 +344,39 @@ export function collectEvaluatedPropertyIds(columns, view) {
   return [...propertyIds];
 }
 
+export function findView(definition, requestedView = '') {
+  return definition.views.find((entry) => entry.name === requestedView || entry.id === requestedView) ?? definition.views[0];
+}
+
+export function normalizeRawDefinitionForWrite(definition) {
+  const rawDefinition = isPlainObject(definition?.raw)
+    ? structuredClone(definition.raw)
+    : structuredClone(isPlainObject(definition) ? definition : {});
+  const rawProperties = isPlainObject(rawDefinition.properties) ? rawDefinition.properties : {};
+  const formulas = isPlainObject(rawDefinition.formulas)
+    ? { ...rawDefinition.formulas }
+    : {};
+
+  Object.entries(rawProperties).forEach(([propertyId, config]) => {
+    if (!isPlainObject(config) || typeof config.formula !== 'string') {
+      return;
+    }
+
+    formulas[bareFormulaName(propertyId)] = config.formula;
+    delete config.formula;
+  });
+
+  rawDefinition.properties = rawProperties;
+  if (Object.keys(formulas).length > 0) {
+    rawDefinition.formulas = formulas;
+  } else {
+    delete rawDefinition.formulas;
+  }
+
+  return rawDefinition;
+}
+
 export function serializeBaseDefinition(definition) {
-  const raw = definition?.raw ?? definition ?? {};
+  const raw = normalizeRawDefinitionForWrite(definition);
   return `${yaml.dump(raw, { lineWidth: -1, noRefs: true }).trim()}\n`;
 }

package/src/server/domain/bases/base-expression-runtime.js

@@ -111,6 +111,10 @@ function normalizeDuration(duration) {
   return Number.isFinite(amount) && multiplier ? amount * multiplier : null;
 }
 
+function hasFormulaDefinition(definition, propertyId = '') {
+  return Boolean(definition?.formulas?.[propertyId]);
+}
+
 export function parseDateValue(value) {
   if (value instanceof Date) {
     return Number.isFinite(value.getTime()) ? value : null;
@@ -476,6 +480,26 @@ function invokeMethod(target, name, argNodes, scope, evaluate, rootContext) {
     return rootContext.resolveFormulaValue(name, target.row, target.evaluationState);
   }
 
+  if (target == null) {
+    switch (name) {
+      case 'contains':
+      case 'containsAll':
+      case 'containsAny':
+      case 'endsWith':
+      case 'hasLink':
+      case 'hasProperty':
+      case 'hasTag':
+      case 'inFolder':
+      case 'linksTo':
+      case 'startsWith':
+        return false;
+      case 'isEmpty':
+        return true;
+      default:
+        break;
+    }
+  }
+
   if (Array.isArray(target)) {
     if (name === 'contains') {
       const needle = evaluate(argNodes[0], scope);
@@ -1031,6 +1055,9 @@ export function evaluateFilterNode(filterNode, rootContext) {
     return filterNode.or.some((entry) => evaluateFilterNode(entry, rootContext));
   }
   if (filterNode.not != null) {
+    if (Array.isArray(filterNode.not)) {
+      return !filterNode.not.some((entry) => evaluateFilterNode(entry, rootContext));
+    }
     return !evaluateFilterNode(filterNode.not, rootContext);
   }
 
@@ -1041,6 +1068,22 @@ function normalizeFormulaLookupName(name = '') {
   return String(name ?? '').replace(/^formula\./u, '');
 }
 
+function resolveFormulaPropertyId(definition, name = '') {
+  const formulaName = normalizeFormulaLookupName(name);
+  if (!formulaName) {
+    return null;
+  }
+
+  const precomputedLookup = definition?.formulaLookup;
+  if (precomputedLookup instanceof Map) {
+    return precomputedLookup.get(formulaName) ?? precomputedLookup.get(`formula.${formulaName}`) ?? null;
+  }
+
+  return Object.keys(definition?.formulas ?? {}).find((propertyId) => (
+    normalizeFormulaLookupName(propertyId) === formulaName
+  )) ?? null;
+}
+
 export function createEvaluationRootContext({
   astCache = new Map(),
   currentRow,
@@ -1061,11 +1104,7 @@ export function createEvaluationRootContext({
     definition,
     evaluationState: nextEvaluationState,
     resolveFormulaValue: (name, row, state = nextEvaluationState) => {
-      const formulaName = normalizeFormulaLookupName(name);
-      const formulaPropertyId = Object.keys(definition.properties).find((propertyId) => {
-        const config = definition.properties[propertyId];
-        return config?.formula && normalizeFormulaLookupName(propertyId) === formulaName;
-      });
+      const formulaPropertyId = resolveFormulaPropertyId(definition, name);
       if (!formulaPropertyId) {
         return null;
       }
@@ -1087,7 +1126,7 @@ export function createEvaluationRootContext({
         snapshot,
         thisFile,
       });
-      const result = evaluateExpression(definition.properties[formulaPropertyId].formula, nextContext);
+      const result = evaluateExpression(definition.formulas[formulaPropertyId].formula, nextContext);
       state.stack.delete(cacheKey);
       state.cache.set(cacheKey, result);
       return result;
@@ -1124,18 +1163,13 @@ export function createEvaluationRootContext({
   };
 }
 
-export function getPropertyValue(propertyId, row, definition, snapshot, thisFile) {
+export function getPropertyValue(propertyId, row, definition, snapshot, thisFile, rootContext = null) {
   if (propertyId.startsWith('file.')) {
     return propertyId.split('.').slice(1).reduce((acc, segment) => acc?.[segment], row.file);
   }
 
-  if (propertyId.startsWith('note.')) {
-    return row.noteProperties[propertyId.slice(5)] ?? null;
-  }
-
-  const propertyConfig = definition.properties[propertyId];
-  if (propertyConfig?.formula) {
-    const context = createEvaluationRootContext({
+  if (hasFormulaDefinition(definition, propertyId)) {
+    const context = rootContext ?? createEvaluationRootContext({
       currentRow: row,
       definition,
       snapshot,
@@ -1144,9 +1178,12 @@ export function getPropertyValue(propertyId, row, definition, snapshot, thisFile
     return context.resolveFormulaValue(propertyId, row, context.evaluationState);
   }
 
-  const formulaConfig = definition.properties[`formula.${propertyId}`];
-  if (formulaConfig?.formula) {
-    const context = createEvaluationRootContext({
+  if (propertyId.startsWith('note.')) {
+    return row.noteProperties[propertyId.slice(5)] ?? null;
+  }
+
+  if (hasFormulaDefinition(definition, `formula.${propertyId}`)) {
+    const context = rootContext ?? createEvaluationRootContext({
       currentRow: row,
       definition,
       snapshot,