Method updateMultipleInFile

src/metaController.ts:673–739

(properties: Property[], file: TFile)

    }

    private async updateMultipleInFile(properties: Property[], file: TFile): Promise<void> {
        // Refuse a batch with ANY reserved YAML key BEFORE the write starts. This
        // method splices body tags before writing frontmatter, so validating up
        // front keeps the batch atomic: a reserved key never lets the tag/text
        // edits land while the frontmatter write is the part that fails. A nested
        // property carries its key in `path`, so every string segment is checked -
        // not just `prop.key` - otherwise `setYamlPath` would only throw later,
        // inside `processFrontMatter`, after the tag splice already wrote.
        for (const prop of properties) {
            if (prop.type !== MetaType.YAML) continue;
            if (prop.path && prop.path.length > 0) {
                for (const segment of prop.path) {
                    if (typeof segment === "string") this.assertWritableKey(segment);
                }
            } else {
                this.assertWritableKey(prop.key);
            }
        }

        await this.enqueueFileWrite(file, async () => {
            const yamlProperties = properties.filter(prop => prop.type === MetaType.YAML && !prop.path);
            const yamlPathProperties = properties.filter(prop => prop.type === MetaType.YAML && prop.path);
            const tagProperties = properties.filter(prop => prop.type === MetaType.Tag);
            const textProperties = properties.filter(prop => prop.type === MetaType.Dataview && prop.key);

            // Splice body tags FIRST, while their parsed offsets still match the
            // file. A later processFrontMatter write only touches the frontmatter,
            // so it preserves these body edits; doing it the other way round would
            // shift every body offset and stale the tag spans. Highest-offset-first
            // keeps earlier spans valid as later ones change length; a stale span
            // is skipped, never forced, so a batch never corrupts prose.
            if (tagProperties.length > 0) {
                let content = await this.app.vault.read(file);
                for (const prop of [...tagProperties].sort((a, b) => (b.position?.start ?? 0) - (a.position?.start ?? 0))) {
                    const token = normalizeTagToken(String(prop.content));
                    if (!isValidTagToken(token)) {
                        log.logMessage(`MetaEdit skipped tag '${prop.key}': '${String(prop.content)}' is not a valid tag.`);
                        continue;
                    }
                    const updated = spliceTag(content, prop.position, prop.key, token);
                    if (updated === null) {
                        log.logMessage(`MetaEdit skipped tag '${prop.key}': its position no longer matches the note.`);
                        continue;
                    }
                    content = updated;
                }
                await this.app.vault.modify(file, content);
            }

            if (yamlProperties.length > 0 || yamlPathProperties.length > 0) {
                await this.processFrontMatter(file, (frontmatter) => {
                    for (const prop of yamlProperties) {
                        frontmatter[prop.key] = prop.content;
                    }
                    for (const prop of yamlPathProperties) {
                        setYamlPath(frontmatter, prop.path, prop.content, {createParents: false, createLeaf: false});
                    }
                });