Template Attribute Inheritance#

Template attribute inheritance is a runtime resolution mechanism: when any code reads a note's attributes, Trilium dynamically walks the note's ~template and ~inherit relations and merges the template's attributes into the effective attribute set. Nothing is copied to the note at creation time — the inheritance is recomputed (and then cached) on every fresh read.

This is distinct from how templates are applied at note creation (see note_create.ts); that service sets up the initial ~template relation but does not copy any attributes.

How Resolution Works#

The core logic lives in two parallel implementations — one on the server, one on the client — but they follow the same algorithm.

Server side — BNote.__getAttributes() (bnote.ts)#

__getAttributes(path) is the authoritative implementation. It runs in three phases:

1. Collect owned + inheritable-parent attributes — starts with the note's own attributes, then walks every non-search parent and pulls in their inheritable attributes (skipping root and _hidden to avoid polluting the hidden subtree) 1.
2. Follow template/inherit relations — scans the accumulated attribute list for any relation attributes named template or inherit, then recursively calls __getAttributes on those target notes to pull in their full attribute set 2.
3. Deduplicate — builds the final cache using an addedAttributeIds Set so that the same attribute is included only once even if it is reachable via multiple inheritance paths 3.

Two labels are explicitly filtered out during step 2 to prevent the template marker from propagating to instances: #template and #workspacetemplate 4.

Cycle protection is handled by the path parameter — if a note ID already appears in the current traversal path, recursion returns [] immediately 5.

Client side — FNote.__getCachedAttributes() (fnote.ts)#

The frontend mirrors the same algorithm in __getCachedAttributes(path). The structure is identical: collect owned attributes, pull inheritable parent attributes, then recurse into template/inherit targets 6. The same exclusions (#template, #workspacetemplate) and cycle detection apply .

The helper getNotesToInheritAttributesFrom() surfaces the full list of template/inherit relation targets for a given note.

Caching and Invalidation#

Server (BNote)#

The server maintains two per-note caches populated in the same pass: __attributeCache (all resolved attributes) and __inheritableAttributeCache (only the inheritable subset), both stored directly on the BNote instance 9.

Invalidation is surgical:

• invalidateThisCache() 10 — clears caches only for the current note; used when a change does not affect descendants.
• invalidateSubTree() 11 — recursively clears caches down the entire child subtree and along template/inherit relations, because a template change propagates to all instances.

These are triggered by becca_loader.ts 12 whenever branches or attributes are created, updated, or removed — choosing between the two strategies based on whether the attribute is marked isAffectingSubtree or the note is used as an inherited source.

Client (noteAttributeCache)#

The client uses a single global cache (note_attribute_cache.ts) keyed by note ID. Its invalidate() method wipes the entire cache — a coarser strategy that trades precision for simplicity. Any write event (attribute, branch, or note change) triggers a full invalidation.

Key Behaviors#

Key Files#