@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/mode/watch.js

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `watch` for either mode. `mach watch` rebuilds front-end files as the
+ * engine changes; what the engine is built from outside itself (a
+ * source-mode project's owned files and override records, and the
+ * components of either mode) is followed here and brought into the engine
+ * when it changes, which `mach watch` then picks up.
+ */
+import { join } from 'node:path';
+import { watch as watchEngine } from '../engine/index.js';
+import { toError } from '../kernel/errors.js';
+import { pathInfo, walkFiles } from '../kernel/fs.js';
+import { hash } from '../kernel/hash.js';
+import { info, warn } from '../kernel/log.js';
+import { sleep } from '../kernel/time.js';
+import { deployComponents, materializeIn } from './workspace.js';
+/** The directories and files outside the engine that the workspace's engine is made from. */
+function inputs(project) {
+    return [
+        ...(project.mode === 'source' ? [project.paths.source, project.paths.sourceMetadata] : []),
+        project.paths.components,
+        project.paths.furnace,
+    ];
+}
+/** A digest of every input file's path, size and modification time. */
+async function signature(project) {
+    const rows = [];
+    for (const input of inputs(project)) {
+        const files = (await pathInfo(input))?.kind === 'directory'
+            ? (await walkFiles(input)).map((file) => join(input, file))
+            : [input];
+        for (const file of files) {
+            const stat = await pathInfo(file);
+            if (stat !== undefined)
+                rows.push(`${file}\0${stat.size}\0${stat.mtimeMs}`);
+        }
+    }
+    return hash(rows.join('\n'));
+}
+/** Brings the workspace's engine to the project's inputs as they are now. */
+async function refresh(workspace) {
+    const changed = await materializeIn(workspace);
+    if (changed > 0)
+        info(`Brought ${changed} changed file(s) into workspace "${workspace.name}".`);
+    await deployComponents(workspace);
+}
+/**
+ * Watches the workspace and rebuilds front-end files as the project changes,
+ * until interrupted. A change that cannot be brought into the engine is
+ * reported and tried again at the next change; the watch goes on.
+ *
+ * @param workspace - A workspace holding a completed build, held by the caller
+ * @param options - See {@link WatchOptions}
+ * @throws What the engine module's `watch` throws
+ */
+export async function watch(workspace, options = {}) {
+    const { project } = workspace;
+    const state = { stopped: false };
+    const stopped = () => state.stopped;
+    const follow = async () => {
+        let seen = await signature(project);
+        for (;;) {
+            await sleep(options.pollMs ?? 1_000, { unref: true });
+            if (stopped())
+                return;
+            const now = await signature(project);
+            if (now === seen)
+                continue;
+            seen = now;
+            await refresh(workspace).catch((error) => {
+                warn(`The workspace was not updated: ${toError(error).message}`);
+            });
+        }
+    };
+    const following = follow();
+    try {
+        await watchEngine(workspace, options.env === undefined ? {} : { env: options.env });
+    }
+    finally {
+        state.stopped = true;
+        await following.catch(() => undefined);
+    }
+}

package/dist/src/mode/workspace.js

@@ -0,0 +1,189 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Giving a command its workspace: the project's `engine/` under the engine
+ * lock in patch mode, a pool workspace leased and brought to the checkout's
+ * owned files in source mode.
+ */
+import { engineLockPath, leaseWorkspace, listWorkspaces, withEngineLock, withProjectWorkspace, } from '../engine/index.js';
+import { applyComponents, loadFurnaceConfig, typingDrift, } from '../furnace/index.js';
+import { ExitCode, FireForgeError } from '../kernel/errors.js';
+import { exists } from '../kernel/fs.js';
+import { readLockStatus } from '../kernel/lock.js';
+import { info, verbose } from '../kernel/log.js';
+import { materialize, recordDeployment } from '../source/index.js';
+import { pinnedPristine } from './pristine.js';
+import { trackedFiles } from './tracked.js';
+/**
+ * Runs `body` in the project's workspace, holding it for the duration.
+ * Whatever else must be current before the body's work (deployed
+ * components, the build) is the body's business.
+ *
+ * @param project - The project
+ * @param options - See {@link WorkspaceOptions}
+ * @param body - The command's work
+ * @throws `engine-missing` or `pristine-missing` before `download`,
+ *   `lock-timeout` (exit code 15), `materialize-drift` when the leased
+ *   engine was changed by something other than FireForge
+ */
+export async function withWorkspace(project, options, body) {
+    const wait = { command: options.command, waitMs: options.waitMs };
+    if (project.mode === 'patches') {
+        if (options.workspace !== undefined) {
+            throw new FireForgeError('invalid-argument', 'A patch-mode project builds in its own engine/; it has no pool workspace to select.', { exitCode: ExitCode.INVALID_ARGUMENT, hint: 'Leave out --workspace.' });
+        }
+        return withProjectWorkspace(project, { ...wait, mode: options.write === false ? 'shared' : 'exclusive' }, body);
+    }
+    return leaseWorkspace(project, { ...wait, name: options.workspace, prepare: bringToCheckout }, body);
+}
+/**
+ * Makes a leased pool workspace hold what the checkout builds: its owned
+ * files, then the files its components deploy. A pool workspace serves any
+ * checkout, so what an earlier lessee deployed says nothing about this one.
+ */
+async function bringToCheckout(workspace) {
+    await materializeIn(workspace);
+    await deployComponents(workspace);
+}
+/** States of a leased engine that only putting it back to pristine resolves. */
+const NEEDS_REPAIR = new Set(['materialize-drift', 'journal-conflict', 'materialize-pin-mismatch']);
+/**
+ * Brings a source-mode project's pool workspace to the checkout's owned
+ * files.
+ *
+ * @param workspace - A pool workspace of a source-mode project, held by the caller
+ * @returns How many engine files changed
+ * @throws What materialization throws, with the repair command for a
+ *   workspace only a repair can bring back
+ */
+export async function materializeIn(workspace) {
+    const { project } = workspace;
+    if (project.mode !== 'source')
+        return 0;
+    try {
+        const result = await materialize(project, await pinnedPristine(project), workspace);
+        const changed = result.written.length + result.restored.length + result.removed.length;
+        verbose(`Workspace "${workspace.name}": ${changed} file(s) brought to this checkout.`);
+        return changed;
+    }
+    catch (error) {
+        if (!(error instanceof FireForgeError) || !NEEDS_REPAIR.has(error.code))
+            throw error;
+        throw new FireForgeError(error.code, error.message, {
+            exitCode: error.exitCode,
+            hint: `Save anything you need from ${workspace.engineDir}, then run ` +
+                `"fireforge workspace repair ${workspace.name}" and retry.`,
+            cause: error,
+        });
+    }
+}
+/**
+ * The host pool, and for a patch-mode project its own engine, which is its
+ * one workspace.
+ *
+ * @param host - The host locations
+ * @param project - The project the command runs in, if any
+ */
+export async function listAllWorkspaces(host, project) {
+    const pool = await listWorkspaces(host);
+    if (project?.mode !== 'patches' || !(await exists(project.paths.engine)))
+        return { pool };
+    const { holders } = await readLockStatus(engineLockPath(project));
+    return {
+        engine: { path: project.paths.engine, holders: holders.map((holder) => holder.pid) },
+        pool,
+    };
+}
+/**
+ * Runs `body` for a command made of several steps of which only some work
+ * in the workspace. The workspace is taken when a step first asks for it
+ * and held until the body ends, so steps that read only the owned changes
+ * never wait for it; with `write: false` a patch-mode engine is held shared.
+ *
+ * @param project - The project
+ * @param options - See {@link WorkspaceOptions}
+ * @param body - The command's work; it calls its argument for the workspace
+ */
+export async function withWorkspaceOnDemand(project, options, body) {
+    let release;
+    let lease;
+    let leased;
+    const workspace = () => (leased ??= new Promise((resolve, reject) => {
+        const done = new Promise((finish) => {
+            release = finish;
+        });
+        lease = withWorkspace(project, options, (taken) => {
+            resolve(taken);
+            return done;
+        });
+        // A lease that never came is the asking step's failure.
+        lease.catch(reject);
+    }));
+    try {
+        return await body(workspace);
+    }
+    finally {
+        release?.();
+        await lease?.catch(() => undefined);
+    }
+}
+/**
+ * Runs `body` while nothing changes the project's owned changes underneath
+ * it: under the shared engine lock in patch mode. Source mode reads tracked
+ * files and needs no lock.
+ *
+ * @param project - The project
+ * @param options - The command and how long to wait
+ * @param body - The read
+ */
+export function withOwnedRead(project, options, body) {
+    return project.mode === 'patches'
+        ? withEngineLock(project, { ...options, mode: 'shared' }, body)
+        : body();
+}
+/**
+ * Brings the components deployed in a workspace's engine in line with the
+ * project's: what every build, run and test of the workspace starts with.
+ * A source-mode workspace's ledger records what the deployment wrote.
+ *
+ * @param workspace - The workspace
+ * @param options - `dryRun` plans without writing; `waitMs` is for another deployment into the workspace
+ * @returns What was deployed or removed; nothing for a project without components
+ */
+export async function deployComponents(workspace, options = {}) {
+    const { project } = workspace;
+    if (!(await exists(project.paths.furnace))) {
+        return { changed: false, components: [], written: [], removed: [] };
+    }
+    const result = await applyComponents(project, workspace, options);
+    if (options.dryRun === true)
+        return result;
+    // Deployment edits registration files a source-mode checkout may own.
+    if (project.mode === 'source' && workspace.kind === 'pool') {
+        await recordDeployment(await pinnedPristine(project), workspace, [
+            ...result.written,
+            ...result.removed,
+        ]);
+    }
+    const changed = result.components
+        .filter((component) => component.status !== 'current')
+        .map((component) => component.name);
+    if (changed.length > 0)
+        info(`Deployed components: ${changed.join(', ')}.`);
+    return result;
+}
+/**
+ * Refuses while a typing file Furnace generates (the jsconfig paths, the
+ * tag map) is out of date: a type check against stale typing files judges
+ * the wrong program.
+ *
+ * @param project - The project
+ * @throws `furnace-typing-drift` (exit code 9) naming the files
+ */
+export async function requireCurrentTyping(project) {
+    if (!(await exists(project.paths.furnace)))
+        return;
+    const drift = await typingDrift(project, await loadFurnaceConfig(project), await trackedFiles(project));
+    if (drift.length === 0)
+        return;
+    throw new FireForgeError('furnace-typing-drift', `Generated typing files are out of date: ${drift.map((file) => file.file).join(', ')}.`, { exitCode: ExitCode.FURNACE_ERROR, hint: 'Run "fireforge furnace types".' });
+}

package/dist/src/mozbuild/index.js

@@ -0,0 +1,6 @@
+export { findJarEntries, insertJarEntry, parseJar, updateJarEntries } from './jar.js';
+export { addToMozBuildList, findMozBuildLists, mozBuildSortViolations, mozBuildTestManifests, parseMozBuild, removeFromMozBuildList, } from './mozbuild.js';
+export { manifestKind, resolveManifestPath, TEST_MANIFEST_VARIABLES, testManifestFlavor, } from './paths.js';
+export { manifestReferences, manifestReferencesFile } from './references.js';
+export { addTest, defaultValue, listTests, newTestManifest, removeTest, supportUsers, } from './testManifest.js';
+export { compareBytes } from './text.js';

package/dist/src/mozbuild/jar.js

@@ -0,0 +1,366 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `jar.mn` and `jar.inc.mn`: parsing, queries and edits.
+ *
+ * A jar manifest is a list of jar sections (`browser.jar:`, `@AB_CD@.jar:`,
+ * `[localization] @AB_CD@.jar:`), each holding `%` chrome-manifest lines and
+ * entries of the form `[flags] target (source)`. Preprocessor lines (`#ifdef`,
+ * `#include`, ...) are kept as they are and never evaluated; entries between
+ * a conditional and its `#endif` are marked `conditional`, and edits never
+ * place or anchor an entry inside one.
+ */
+import { posix } from 'node:path';
+import { resolveManifestPath } from './paths.js';
+import { joinSource, manifestError, sortedInsertIndex, spliceLines, splitSource, } from './text.js';
+const PP_OPEN = /^#(?:if|ifdef|ifndef)\b/;
+const PP_MIDDLE = /^#(?:else|elif\w*)\b/;
+const PP_CLOSE = /^#endif\b/;
+const PP_OTHER = /^#(?:define|undef|include|filter|unfilter|expand|literal|error)\b/;
+const HEADER = /^(?:\[([^\]]+)\]\s+)?(\S+?)\s*:\s*$/;
+const INLINE_JAR = /^(\S+\.jar):\s+(?=\S)/;
+const ENTRY = /^(\s*)([*+]*)\s*([^\s(]+)(?:\s*\((%?)(.*?)\))?\s*(?:#.*)?$/d;
+function parseEntryText(text, offset) {
+    const match = ENTRY.exec(text.slice(offset));
+    const target = match?.indices?.[3];
+    if (match === null || target === undefined)
+        return undefined;
+    const source = match.indices?.[5];
+    const localized = match[4] === '%';
+    return {
+        indent: match[1] ?? '',
+        flags: match[2] ?? '',
+        target: match[3] ?? '',
+        source: match[5],
+        localized,
+        column: source === undefined ? undefined : offset + source[0] - (localized ? 2 : 1),
+        spans: {
+            target: [offset + target[0], offset + target[1]],
+            ...(source === undefined ? {} : { source: [offset + source[0], offset + source[1]] }),
+        },
+    };
+}
+/**
+ * Parses a jar manifest. Never throws: a line it cannot read is `unknown`,
+ * and an unbalanced conditional only clears `balanced`. Fragments (the added
+ * lines of a diff) parse as well as whole files.
+ *
+ * @param text - Manifest text
+ */
+export function parseJar(text) {
+    const lines = splitSource(text);
+    const manifest = {
+        lines,
+        kinds: [],
+        entries: [],
+        headers: [],
+        chromeManifests: [],
+        balanced: true,
+    };
+    let depth = 0;
+    let section = 0;
+    let jar;
+    for (const [index, { text: line }] of lines.entries()) {
+        const trimmed = line.trim();
+        let kind = 'unknown';
+        if (trimmed === '') {
+            kind = 'blank';
+        }
+        else if (trimmed.startsWith('#')) {
+            kind = 'comment';
+            if (PP_OPEN.test(trimmed)) {
+                kind = 'preprocessor';
+                depth++;
+            }
+            else if (PP_CLOSE.test(trimmed)) {
+                kind = 'preprocessor';
+                if (depth === 0)
+                    manifest.balanced = false;
+                else
+                    depth--;
+            }
+            else if (PP_MIDDLE.test(trimmed)) {
+                kind = 'preprocessor';
+                if (depth === 0)
+                    manifest.balanced = false;
+            }
+            else if (PP_OTHER.test(trimmed)) {
+                kind = 'preprocessor';
+            }
+        }
+        else if (trimmed.startsWith('%')) {
+            kind = 'chrome-manifest';
+            manifest.chromeManifests.push({
+                line: index,
+                args: trimmed.slice(1).trim().split(/\s+/),
+                section,
+            });
+        }
+        else {
+            const header = /^\s/.test(line) ? null : HEADER.exec(line);
+            const inline = INLINE_JAR.exec(line);
+            if (header !== null) {
+                kind = 'header';
+                section++;
+                jar = header[2];
+                manifest.headers.push({ line: index, jar: header[2] ?? '', base: header[1], section });
+            }
+            else {
+                const offset = inline?.[0].length ?? 0;
+                const parsed = parseEntryText(line, offset);
+                if (parsed !== undefined) {
+                    kind = 'entry';
+                    manifest.entries.push({
+                        line: index,
+                        text: line,
+                        indent: parsed.indent,
+                        flags: parsed.flags,
+                        target: parsed.target,
+                        source: parsed.source,
+                        localized: parsed.localized,
+                        jar: inline?.[1] ?? jar,
+                        section,
+                        conditional: depth > 0,
+                        sourceColumn: parsed.column,
+                        spans: parsed.spans,
+                    });
+                }
+            }
+        }
+        manifest.kinds.push(kind);
+    }
+    if (depth !== 0)
+        manifest.balanced = false;
+    return manifest;
+}
+/**
+ * The entries whose target and source equal the query's, comments and
+ * longer names excluded.
+ *
+ * @param text - Manifest text
+ * @param query - Target (one or any of several) and source to match
+ */
+export function findJarEntries(text, query) {
+    const targets = query.target === undefined ? undefined : [query.target].flat();
+    return parseJar(text).entries.filter((entry) => (targets === undefined || targets.includes(entry.target)) &&
+        (query.source === undefined || entry.source === query.source));
+}
+/**
+ * The engine paths a jar manifest's sources name. An entry without
+ * parentheses packages the file named by its target's last segment, found
+ * beside the manifest, as Firefox's jar maker reads it. A source with `%`
+ * lives in the locale tree and is not listed. An included manifest
+ * (`*.inc.mn`) is read from the directory of the manifest that includes it,
+ * which the file does not name, so only its root-relative (`/…`) sources
+ * are listed.
+ *
+ * @param manifestPath - Engine-relative path of the manifest
+ * @param text - Manifest text
+ */
+export function jarReferences(manifestPath, text) {
+    const included = manifestPath.endsWith('.inc.mn');
+    const references = [];
+    for (const entry of parseJar(text).entries) {
+        if (entry.localized)
+            continue;
+        const token = entry.source ?? posix.basename(entry.target);
+        if (included && !token.startsWith('/'))
+            continue;
+        const matcher = resolveManifestPath(manifestPath, token);
+        if (matcher !== undefined)
+            references.push({
+                kind: 'jar-source',
+                token,
+                line: entry.line,
+                text: entry.text.trim(),
+                matcher,
+            });
+    }
+    return references;
+}
+const DEFAULT_INDENT = '    ';
+/** Lines of comment directly above `index`: a comment belongs to the entry below it. */
+function blockStart(manifest, index) {
+    let start = index;
+    while (start > 0 && manifest.kinds[start - 1] === 'comment')
+        start--;
+    return start;
+}
+/** Entries near `target`'s directory: the same directory, else the nearest ancestor with any. */
+function neighbourhood(entries, target) {
+    let dir = posix.dirname(target);
+    const same = entries.filter((entry) => posix.dirname(entry.target) === dir);
+    if (same.length > 0)
+        return same;
+    while (dir !== '.' && dir !== '/') {
+        const below = entries.filter((entry) => entry.target.startsWith(`${dir}/`));
+        if (below.length > 0)
+            return below;
+        dir = posix.dirname(dir);
+    }
+    return [];
+}
+/** A section header as written, without the colon: `browser.jar`, `[localization] @AB_CD@.jar`. */
+function headerName(header) {
+    return header.base === undefined ? header.jar : `[${header.base}] ${header.jar}`;
+}
+function chooseSection(manifest, near, jar) {
+    const sections = new Set(near.map((entry) => entry.section));
+    if (sections.size === 0) {
+        for (const header of manifest.headers)
+            if (jar === undefined || headerName(header) === jar)
+                sections.add(header.section);
+        if (manifest.headers.length === 0)
+            sections.add(0);
+    }
+    if (sections.size === 0)
+        throw manifestError(`The manifest has no jar section named ${jar ?? ''}.`);
+    if (sections.size > 1) {
+        throw jar === undefined
+            ? manifestError('The entry could belong to several jar sections.', 'Name the section with the jar option, as its header is written.')
+            : manifestError(`The manifest has several ${jar} sections that could hold the entry.`, 'Add the entry by hand in the section it belongs to.');
+    }
+    return [...sections][0] ?? 0;
+}
+function formatEntry(entry, indent, column, minGap) {
+    const flags = entry.flags ?? '';
+    const lead = flags === '' ? indent : flags + ' '.repeat(Math.max(1, indent.length - flags.length));
+    const head = lead + entry.target;
+    if (entry.source === undefined)
+        return head;
+    const width = Math.max(column ?? 0, head.length + minGap);
+    return `${head}${' '.repeat(width - head.length)}(${entry.localized === true ? '%' : ''}${entry.source})`;
+}
+/**
+ * Adds an entry to a jar manifest. The entry joins the entries of its own
+ * directory (or the nearest directory that has any) in one jar section, in
+ * sort order when those are sorted and after them when they are not, never
+ * inside a preprocessor conditional. It copies the neighbour's indentation
+ * and source column. A leading comment stays attached to its entry.
+ *
+ * An entry already present (same target, same source) changes nothing. The
+ * same target with another source, an unbalanced conditional, an anchor
+ * inside a conditional, or several candidate jar sections is refused.
+ *
+ * @param text - Manifest text
+ * @param entry - The entry to add
+ * @param options - Section, anchor, ordering and layout
+ */
+export function insertJarEntry(text, entry, options = {}) {
+    const manifest = parseJar(text);
+    if (!manifest.balanced)
+        throw manifestError('The manifest has an unbalanced preprocessor conditional.');
+    const present = manifest.entries.find((existing) => existing.target === entry.target);
+    if (present !== undefined) {
+        if (present.source === entry.source && present.localized === (entry.localized === true)) {
+            return { text, changed: false, line: present.line };
+        }
+        throw manifestError(`${entry.target} is already registered with a different source.`);
+    }
+    const named = new Set(manifest.headers
+        .filter((header) => headerName(header) === options.jar)
+        .map((header) => header.section));
+    const pool = manifest.entries.filter((existing) => options.jar === undefined ||
+        named.has(existing.section) ||
+        (named.size === 0 && existing.jar === options.jar));
+    const section = chooseSection(manifest, neighbourhood(pool, entry.target), options.jar);
+    const sectionEntries = pool.filter((existing) => existing.section === section);
+    const open = sectionEntries.filter((existing) => !existing.conditional);
+    const slots = neighbourhood(open, entry.target);
+    let at;
+    let previous;
+    let afterFallback = false;
+    if (options.after !== undefined) {
+        const name = options.after;
+        const named = (candidate) => [candidate.target, candidate.source ?? ''].some((path) => path === name || path.endsWith(`/${name}`));
+        const anchor = open.find(named);
+        if (anchor !== undefined) {
+            at = anchor.line + 1;
+            previous = anchor;
+        }
+        else if (sectionEntries.some(named)) {
+            throw manifestError('The requested anchor is inside a preprocessor conditional.', 'Choose an unconditional anchor.');
+        }
+        else {
+            afterFallback = true;
+        }
+    }
+    if (at === undefined) {
+        const key = options.sortKey ?? ((target) => target);
+        const index = slots.length === 0 || options.append === true
+            ? slots.length
+            : sortedInsertIndex(slots.map((slot) => key(slot.target)), key(entry.target));
+        const next = slots[index];
+        previous = slots[index - 1];
+        if (next !== undefined)
+            at = blockStart(manifest, next.line);
+        else if (previous !== undefined)
+            at = previous.line + 1;
+        else
+            at = headOfSection(manifest, section);
+    }
+    const around = previous ?? slots[0];
+    const withSource = [previous, ...slots].find((slot) => slot?.sourceColumn !== undefined);
+    const line = formatEntry(entry, around === undefined
+        ? (options.indent ?? DEFAULT_INDENT)
+        : around.text.slice(0, around.spans.target[0]).replace(/[*+]/g, ' '), withSource?.sourceColumn, options.minGap ?? 2);
+    const result = {
+        text: joinSource(spliceLines(manifest.lines, at, 0, [line])),
+        changed: true,
+        line: at,
+    };
+    if (previous !== undefined)
+        result.previous = previous.text.trim();
+    if (afterFallback)
+        result.afterFallback = true;
+    return result;
+}
+/** The line after a section's header and the `%` lines that follow it. */
+function headOfSection(manifest, section) {
+    const header = manifest.headers.find((candidate) => candidate.section === section);
+    let at = header === undefined ? 0 : header.line + 1;
+    while (manifest.kinds[at] === 'chrome-manifest')
+        at++;
+    return at;
+}
+/**
+ * Removes or retargets entries in place. A changed entry keeps its position,
+ * indentation, column spacing and trailing comment; everything else in the
+ * file is left as it is.
+ *
+ * @param text - Manifest text
+ * @param decide - Called for each entry in file order
+ */
+export function updateJarEntries(text, decide) {
+    const manifest = parseJar(text);
+    const removed = [];
+    const updated = [];
+    let lines = manifest.lines.map((line) => ({ ...line }));
+    for (const entry of manifest.entries) {
+        const change = decide(entry);
+        if (change === undefined)
+            continue;
+        if (change === null) {
+            removed.push(entry);
+            continue;
+        }
+        const edits = [];
+        if (change.target !== undefined)
+            edits.push([entry.spans.target, change.target]);
+        if (change.source !== undefined && entry.spans.source !== undefined) {
+            edits.push([entry.spans.source, change.source]);
+        }
+        let edited = entry.text;
+        for (const [[start, end], value] of edits.sort((a, b) => b[0][0] - a[0][0])) {
+            edited = edited.slice(0, start) + value + edited.slice(end);
+        }
+        const target = lines[entry.line];
+        if (target !== undefined && edited !== entry.text) {
+            target.text = edited;
+            updated.push(entry);
+        }
+    }
+    for (const entry of [...removed].reverse())
+        lines = spliceLines(lines, entry.line, 1, []);
+    const changed = removed.length > 0 || updated.length > 0;
+    return { text: changed ? joinSource(lines) : text, changed, removed, updated };
+}