@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/mode/changes.js

@@ -0,0 +1,264 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Either storage as the owned-change model, and what the judging modules
+ * read beside it: the engine files around the changes and the design-token
+ * policy. Group waivers and tiers the configuration declares are merged in
+ * here, so they apply whichever mode produced the groups.
+ */
+import { join, relative } from 'node:path';
+import { listPristineTree, readPristineFiles } from '../engine/index.js';
+import { componentFiles, componentHostFiles, loadFurnaceConfig } from '../furnace/index.js';
+import { ExitCode, FireForgeError } from '../kernel/errors.js';
+import { exists, readBytesIfExists, toPosixPath } from '../kernel/fs.js';
+import { createChangeSet, textContent, } from '../project/index.js';
+import { engineChanges, queueChanges } from '../queue/index.js';
+import { readSourceFile, sourceChanges } from '../source/index.js';
+import { pinnedPristine, requireEngine } from './pristine.js';
+import { trackedFiles } from './tracked.js';
+/**
+ * What a waiver's `group` may spell to mean a group: its ID, and for a patch
+ * also the patch's name (`ui-sidebar` of `012-ui-sidebar.patch`), which a
+ * reorder does not change.
+ */
+function waiverNames(mode, group) {
+    return mode === 'patches'
+        ? [group.id, group.id.replace(/^\d+-/, '').replace(/\.patch$/, '')]
+        : [group.id];
+}
+function configuredWaivers(project, group) {
+    const names = waiverNames(project.mode, group);
+    return (project.config.patchLint.waivers ?? [])
+        .filter((waiver) => names.includes(waiver.group))
+        .map((waiver) => waiver.max === undefined
+        ? waiver.rule
+        : {
+            rule: waiver.rule,
+            max: waiver.max,
+            reason: waiver.reason,
+            ...(waiver.share === undefined ? {} : { share: waiver.share }),
+        });
+}
+function configuredTier(config, group) {
+    return group.meta['kind'] === 'created'
+        ? config.exportQueue.groups?.find((entry) => entry.name === group.id)?.tier
+        : config.exportQueue.componentTiers?.[group.id];
+}
+/** The change set with the configuration's waivers and tiers merged into its groups. */
+function withConfiguredGroups(project, changes) {
+    const groups = changes.groups.map((group) => {
+        const lintIgnore = [...(group.lintIgnore ?? []), ...configuredWaivers(project, group)];
+        const tier = group.tier ?? configuredTier(project.config, group);
+        return {
+            ...group,
+            ...(tier === undefined ? {} : { tier }),
+            ...(lintIgnore.length === 0 ? {} : { lintIgnore }),
+        };
+    });
+    return createChangeSet({
+        groups,
+        changes: changes.changes,
+        ...(changes.diff === undefined ? {} : { diff: changes.diff }),
+    });
+}
+/**
+ * The project's owned changes. Patch mode reads the engine's current state
+ * (or, with `scope: 'queue'`, the stored queue patch by patch); source mode
+ * reads the owned files against the pinned pristine repository and needs no
+ * engine.
+ *
+ * @param project - The project
+ * @param options - See {@link OwnedScope}
+ * @throws `pristine-missing` or `engine-missing` before `download`,
+ *   `queue-does-not-apply` for a stored queue that does not replay
+ */
+export async function ownedChanges(project, options = {}) {
+    if (project.mode === 'source') {
+        const changes = await sourceChanges(project, await pinnedPristine(project));
+        return withConfiguredGroups(project, changes);
+    }
+    await requireEngine(project);
+    const changes = options.scope === 'queue' ? await queueChanges(project) : await engineChanges(project);
+    return withConfiguredGroups(project, changes);
+}
+/** The files each Furnace component of a source-mode project deploys, read from `components/`. */
+async function deployedComponents(project) {
+    if (!(await exists(project.paths.furnace)))
+        return [];
+    return componentFiles(project, await loadFurnaceConfig(project));
+}
+/**
+ * The groups of files a source-mode project's Furnace components deploy.
+ *
+ * @param project - A source-mode project
+ */
+export async function componentGroups(project) {
+    return (await deployedComponents(project)).map(({ name, files }) => ({
+        id: name,
+        paths: [...files.keys()].sort(),
+    }));
+}
+/**
+ * The checkout directories whose files an engine holds, for a mutation
+ * written against the checkout: a source-mode project's source root, and
+ * each Furnace component's directory, whose modules and stylesheets deploy
+ * into the component's engine directory.
+ *
+ * @param project - The project
+ */
+export async function mutationRoots(project) {
+    const roots = project.mode === 'source' ? [{ directory: project.config.source.root, engine: '' }] : [];
+    if (!(await exists(project.paths.furnace)))
+        return roots;
+    const furnace = await loadFurnaceConfig(project);
+    const components = toPosixPath(relative(project.root, project.paths.components));
+    return [
+        ...roots,
+        ...Object.entries(furnace.custom).map(([name, entry]) => ({
+            directory: `${components}/custom/${name}`,
+            engine: entry.targetPath,
+        })),
+        ...Object.entries(furnace.overrides).map(([name, entry]) => ({
+            directory: `${components}/overrides/${name}`,
+            engine: entry.basePath,
+        })),
+    ];
+}
+/**
+ * A source-mode change set with the files the project's Furnace components
+ * deploy: they are engine files the project supplies, kept under
+ * `components/` instead of the source root, and a build holds them like any
+ * owned file. Each component is one group, named after it. A path the
+ * source root also owns stays the source root's.
+ */
+async function withComponentFiles(project, changes) {
+    const components = await deployedComponents(project);
+    if (components.length === 0)
+        return changes;
+    const pristine = await pinnedPristine(project);
+    const taken = new Set(changes.groups.map((group) => group.id));
+    const groups = [];
+    const added = [];
+    for (const { name, files } of components) {
+        if (taken.has(name)) {
+            throw new FireForgeError('source-group-name-collision', `Group "${name}" would hold both owned files and the files of Furnace component ${name}.`, {
+                exitCode: ExitCode.CONFIG_ERROR,
+                hint: "Give the exportQueue group or the override records' component another name.",
+            });
+        }
+        const paths = [...files.keys()].filter((path) => changes.at(path).length === 0);
+        const upstream = new Map((paths.length === 0 ? [] : await listPristineTree(pristine, paths)).map((entry) => [
+            entry.path,
+            entry,
+        ]));
+        const group = {
+            id: name,
+            sized: false,
+            meta: { kind: 'furnace', description: `Files of Furnace component ${name}` },
+        };
+        const lintIgnore = configuredWaivers(project, group);
+        groups.push(lintIgnore.length === 0 ? group : { ...group, lintIgnore });
+        for (const path of paths) {
+            const content = files.get(path) ?? Buffer.alloc(0);
+            const base = {
+                path,
+                group: name,
+                binary: textContent(content) === undefined,
+                meta: { furnace: name },
+                after: () => Promise.resolve(content),
+                mode: '100644',
+            };
+            const entry = upstream.get(path);
+            if (entry === undefined) {
+                added.push({ ...base, kind: 'create' });
+            }
+            else {
+                added.push({
+                    ...base,
+                    kind: 'modify',
+                    previousMode: entry.mode === '100755' ? '100755' : '100644',
+                    before: async () => (await readPristineFiles(pristine, [path])).get(path) ?? Buffer.alloc(0),
+                });
+            }
+        }
+    }
+    return createChangeSet({
+        groups: [...changes.groups, ...groups],
+        changes: [...changes.changes, ...added],
+        ...(changes.diff === undefined ? {} : { diff: changes.diff }),
+    });
+}
+/**
+ * Reads engine files as the project builds them: a patch-mode project's
+ * `engine/`, a leased workspace's engine, or (source mode without a
+ * workspace) the owned files and the files Furnace deploys, over the
+ * pristine blobs.
+ *
+ * @param project - The project
+ * @param workspace - A workspace already holding the project's source, when the caller has one
+ */
+async function engineReader(project, workspace) {
+    const onDisk = (engineDir) => ({
+        read: (path) => readBytesIfExists(join(engineDir, path)),
+    });
+    if (project.mode === 'patches')
+        return onDisk(project.paths.engine);
+    if (workspace !== undefined)
+        return onDisk(workspace.engineDir);
+    const pristine = await pinnedPristine(project);
+    const deployed = new Map((await deployedComponents(project)).flatMap(({ files }) => [...files]));
+    return {
+        read: async (path) => (await readSourceFile(project, pristine, path)) ?? deployed.get(path),
+    };
+}
+/**
+ * Where a project keeps the TypeScript result cache `lint` and `typecheck` share.
+ *
+ * @param project - The project
+ */
+export function typeCacheDir(project) {
+    return join(project.paths.stateDir, 'cache', 'typescript');
+}
+/**
+ * The owned changes with everything a lint run reads beside them.
+ *
+ * @param project - The project
+ * @param options - See {@link OwnedScope}; `workspace` reads the engine there
+ */
+export async function lintSubject(project, options = {}) {
+    const furnace = (await exists(project.paths.furnace))
+        ? await loadFurnaceConfig(project)
+        : undefined;
+    const owned = await ownedChanges(project, options);
+    return {
+        changes: project.mode === 'source' ? await withComponentFiles(project, owned) : owned,
+        engine: await engineReader(project, options.workspace),
+        sequential: project.mode === 'patches',
+        components: furnace === undefined ? [] : componentHostFiles(furnace),
+        ...(furnace?.tokenPrefix === undefined
+            ? {}
+            : {
+                tokens: {
+                    prefix: furnace.tokenPrefix,
+                    allowlist: furnace.tokenAllowlist ?? [],
+                    runtimeVariables: furnace.runtimeVariables ?? [],
+                },
+            }),
+    };
+}
+/**
+ * The engine files the project owns and still holds: what token coverage
+ * and token lint judge. In patch mode the caller holds the engine still
+ * (`withOwnedRead`) while it reads them.
+ *
+ * @param project - The project
+ */
+export async function ownedFiles(project) {
+    const files = await trackedFiles(project);
+    return {
+        paths: (await ownedChanges(project))
+            .net()
+            .filter((change) => change.kind !== 'delete')
+            .map((change) => change.path),
+        read: (path) => files.read(path),
+    };
+}

package/dist/src/mode/diagnose.js

@@ -0,0 +1,173 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * What `doctor` asks about a project that depends on its mode: the git it
+ * needs, the pinned source on this host, the engine or the pool workspaces
+ * built from it, and the integrity of where the owned changes are stored.
+ */
+import { join } from 'node:path';
+import { listWorkspaces, pinKey } from '../engine/index.js';
+import { deploymentStatus } from '../furnace/index.js';
+import { getConfig, git, isRepository, resolveRevision } from '../git/index.js';
+import { FireForgeError, toError } from '../kernel/errors.js';
+import { exists } from '../kernel/fs.js';
+import { MERGE_DRIVER, mergeDriverCommand } from '../source/index.js';
+import { pinnedPristine } from './pristine.js';
+import { verify } from './report.js';
+const failed = (error) => ({
+    status: 'fail',
+    detail: toError(error).message,
+    ...(error instanceof FireForgeError && error.hint !== undefined ? { fix: error.hint } : {}),
+});
+/** Git old enough to lack the ancestor label breaks first-touch merges; older still lacks plumbing options. */
+async function gitVersion(project) {
+    const needed = project.mode === 'source' ? [2, 44] : [2, 35];
+    const text = (await git(['version'], { cwd: project.root })).trim();
+    const found = /(\d+)\.(\d+)/.exec(text);
+    const [major, minor] = [Number(found?.[1]), Number(found?.[2])];
+    const [needMajor = 0, needMinor = 0] = needed;
+    if (major > needMajor || (major === needMajor && minor >= needMinor)) {
+        return { status: 'ok', detail: text };
+    }
+    return {
+        status: 'fail',
+        detail: `${text}; this project needs git ${needed.join('.')} or later`,
+        fix: 'Upgrade git.',
+    };
+}
+async function patchEngine(project, pristine) {
+    const engine = project.paths.engine;
+    if (!(await exists(join(engine, 'mach'))) || !(await isRepository(engine))) {
+        return {
+            status: 'fail',
+            detail: `There is no Firefox source at ${engine}`,
+            fix: 'Run "fireforge download".',
+        };
+    }
+    const head = await resolveRevision(engine, 'HEAD', 'commit');
+    if (head !== pristine.commit) {
+        return {
+            status: 'fail',
+            detail: `engine/ is a checkout of ${head ?? 'nothing'}, and the pinned source is ${pristine.commit}`,
+            fix: 'Run "fireforge rebase" to move the queue onto what engine/ holds, or "fireforge download --force" to replace engine/ with the pin.',
+        };
+    }
+    return { status: 'ok', detail: `engine/ is a checkout of ${pinKey(project.config.firefox)}` };
+}
+async function deployment(project) {
+    const status = await deploymentStatus(project, {
+        engineDir: project.paths.engine,
+        stateDir: project.paths.stateDir,
+    });
+    const stale = status.components.filter((component) => component.status !== 'current');
+    return stale.length === 0
+        ? { status: 'ok', detail: `${status.components.length} component(s) deployed` }
+        : {
+            status: 'warn',
+            detail: `Not deployed as the project has them: ${stale.map((component) => component.name).join(', ')}`,
+            fix: 'Run "fireforge furnace apply"; every build, run and test does it first.',
+        };
+}
+async function mergeDriver(project) {
+    const { worktree } = project.checkout;
+    if (worktree === undefined) {
+        return {
+            status: 'fail',
+            detail: 'The project is not in a git repository',
+            fix: 'A source-mode project is tracked in git: run "git init" and commit it.',
+        };
+    }
+    const driver = await getConfig(worktree, `merge.${MERGE_DRIVER}.driver`);
+    if (driver === undefined) {
+        return {
+            status: 'fail',
+            detail: 'The merge driver for owned files is not configured in this repository',
+            fix: 'Run "fireforge merge-driver install".',
+        };
+    }
+    return driver === mergeDriverCommand(project)
+        ? { status: 'ok', detail: 'Configured' }
+        : {
+            status: 'warn',
+            detail: `merge.${MERGE_DRIVER}.driver is not the command this FireForge configures: ${driver}`,
+            fix: 'Run "fireforge merge-driver install".',
+        };
+}
+async function pool(project, pristine) {
+    const key = pinKey(project.config.firefox);
+    const workspaces = (await listWorkspaces(project.host)).filter((workspace) => workspace.pin === key);
+    if (workspaces.length === 0) {
+        return { status: 'ok', detail: `None on ${key} yet; the first build creates one` };
+    }
+    const broken = [];
+    for (const workspace of workspaces) {
+        if (!(await exists(join(workspace.engineDir, 'mach')))) {
+            broken.push(`"${workspace.name}" has no engine`);
+        }
+        else if (workspace.commit !== pristine.commit) {
+            broken.push(`"${workspace.name}" holds commit ${workspace.commit}, not the pinned source`);
+        }
+    }
+    if (broken.length > 0) {
+        return {
+            status: 'fail',
+            detail: broken.join('; '),
+            fix: 'Remove each with "fireforge workspace remove <name>"; the next build creates a fresh one.',
+        };
+    }
+    const rows = workspaces.map((workspace) => {
+        const lease = workspace.holders.length > 0
+            ? `leased by PID ${workspace.holders.map((holder) => holder.pid).join(', ')}`
+            : 'free';
+        return `${workspace.name} (${workspace.built ? 'built' : 'not built'}, ${lease})`;
+    });
+    return { status: 'ok', detail: rows.join(', ') };
+}
+async function storage(project) {
+    const { problems } = await verify(project);
+    if (problems.length === 0)
+        return { status: 'ok', detail: 'Sound' };
+    const first = problems[0];
+    const subject = first?.subject === undefined ? '' : `${first.subject}: `;
+    return {
+        status: 'fail',
+        detail: `${problems.length} problem(s), first: ${subject}${first?.message ?? ''}`,
+        fix: first?.hint ?? 'Run "fireforge verify" for all of them.',
+    };
+}
+/**
+ * The mode-dependent diagnostics of a project, in the order a broken one
+ * should be repaired. A check that cannot run because an earlier one failed
+ * is left out.
+ *
+ * @param project - The project
+ */
+export async function diagnose(project) {
+    const found = [];
+    const check = async (id, title, run) => {
+        const answer = await run().catch(failed);
+        found.push({ id, title, ...answer });
+        return answer.status !== 'fail';
+    };
+    await check('git', 'Git', () => gitVersion(project));
+    let pristine;
+    await check('pristine', 'Pinned Firefox source', async () => {
+        pristine = await pinnedPristine(project);
+        return { status: 'ok', detail: `${pinKey(project.config.firefox)} at ${pristine.commit}` };
+    });
+    const source = pristine;
+    if (source === undefined)
+        return found;
+    if (project.mode === 'source') {
+        await check('merge-driver', 'Merge driver', () => mergeDriver(project));
+        await check('workspaces', 'Workspace pool', () => pool(project, source));
+        await check('storage', 'Owned files and records', () => storage(project));
+        return found;
+    }
+    if (await check('engine', 'Engine', () => patchEngine(project, source))) {
+        await check('storage', 'Patch queue', () => storage(project));
+        if (await exists(project.paths.furnace)) {
+            await check('components', 'Deployed components', () => deployment(project));
+        }
+    }
+    return found;
+}

package/dist/src/mode/export.js

@@ -0,0 +1,147 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * `export` in either mode. A source-mode project's owned changes are
+ * written as a patch queue, proven to replay to the tree the checkout
+ * builds. A patch-mode project captures engine edits no patch holds into a
+ * new patch of its queue.
+ */
+import { withEngineLock } from '../engine/index.js';
+import { changedPaths, writeTree } from '../git/index.js';
+import { ExitCode, FireForgeError } from '../kernel/errors.js';
+import { listDir, move, remove, tempPathFor } from '../kernel/fs.js';
+import { exportPatch, readQueue, replayQueue, writeQueue, } from '../queue/index.js';
+import { planQueueExport, requireSourceMode } from '../source/index.js';
+import { ownedChanges } from './changes.js';
+import { pinnedPristine } from './pristine.js';
+/**
+ * The tree an engine at the pristine commit holds with the owned changes
+ * applied, written into the pristine repository's object store.
+ *
+ * @param pristine - The pinned pristine repository
+ * @param changes - The owned changes, one step per path
+ */
+export async function ownedTree(pristine, changes) {
+    const edits = await Promise.all(changes.changes.map(async (change) => change.kind === 'delete'
+        ? { path: change.path, remove: true }
+        : { path: change.path, content: await change.after(), mode: change.mode }));
+    return writeTree(pristine.repo, edits, pristine.commit);
+}
+/** Refuses to replace a directory that holds anything but a generated queue. */
+async function assertReplaceable(out) {
+    if ((await listDir(out)).length === 0)
+        return;
+    const generated = await readQueue(out).then((queue) => queue.source !== undefined, () => false);
+    if (!generated) {
+        throw new FireForgeError('export-target-not-generated', `${out} holds something other than a generated patch queue.`, {
+            exitCode: ExitCode.INVALID_ARGUMENT,
+            hint: 'Export into an empty directory with --out, or remove it first.',
+        });
+    }
+}
+async function writeVerified(project, out) {
+    const pristine = await pinnedPristine(project);
+    const plan = await planQueueExport(project, pristine);
+    const changes = await ownedChanges(project);
+    const { product, version } = project.config.firefox;
+    const staging = tempPathFor(out);
+    try {
+        const queue = await writeQueue(staging, {
+            source: { snapshot: plan.manifestSource.digest },
+            patches: plan.patches.map((patch, index) => {
+                const group = changes.group(patch.group);
+                return {
+                    order: index + 1,
+                    name: patch.name,
+                    description: patch.description,
+                    firefox: { product, version },
+                    ...(group?.tier === undefined ? {} : { tier: group.tier }),
+                    ...(group?.lintIgnore === undefined
+                        ? {}
+                        : { lintIgnore: group.lintIgnore }),
+                    body: patch.body,
+                };
+            }),
+        });
+        const replayed = await replayQueue(pristine.repo, pristine.commit, staging);
+        const expected = await ownedTree(pristine, changes);
+        if (replayed !== expected) {
+            const differing = await changedPaths(pristine.repo, expected, replayed);
+            throw new FireForgeError('export-queue-mismatch', `The generated queue does not replay to the tree this checkout builds; ${differing.length} path(s) differ: ` +
+                `${differing.slice(0, 10).join(', ')}${differing.length > 10 ? ', ...' : ''}`, {
+                exitCode: ExitCode.PATCH_ERROR,
+                hint: 'Nothing was written. Report this: an export must reproduce the owned files.',
+            });
+        }
+        await assertReplaceable(out);
+        await remove(out);
+        await move(staging, out);
+        return {
+            out,
+            patches: queue.patches.map((patch) => ({
+                filename: patch.filename,
+                files: [...patch.files],
+            })),
+            digest: plan.manifestSource.digest,
+        };
+    }
+    finally {
+        await remove(staging);
+    }
+}
+function usage(message) {
+    return new FireForgeError('invalid-argument', message, { exitCode: ExitCode.INVALID_ARGUMENT });
+}
+/**
+ * `export`: a source-mode project writes its generated queue
+ * ({@link exportQueue}); a patch-mode project captures engine edits into a
+ * new patch, under the engine lock.
+ *
+ * @param project - The project
+ * @param request - See {@link ExportRequest}
+ * @throws `invalid-argument` for a field the project's mode does not take,
+ *   and what the mode's export throws
+ */
+export async function exportChanges(project, request) {
+    if (project.mode === 'source') {
+        if (request.paths.length > 0 || request.all || request.name !== undefined) {
+            throw usage('A source-mode export writes the whole queue; it takes no paths, --all or --name.');
+        }
+        return { kind: 'queue', queue: await exportQueue(project, { out: request.out }) };
+    }
+    if (request.out !== undefined)
+        throw usage('--out applies to a source-mode project.');
+    const { name } = request;
+    if (name === undefined)
+        throw usage('--name is required.');
+    if (request.paths.length === 0 && !request.all) {
+        throw usage('Name the paths to capture, or pass --all.');
+    }
+    const result = await withEngineLock(project, { command: 'export', waitMs: request.waitMs }, () => exportPatch(project, {
+        name,
+        ...(request.paths.length === 0 ? {} : { paths: [...request.paths] }),
+        ...(request.all ? { all: true } : {}),
+        ...(request.description === undefined ? {} : { description: request.description }),
+        ...(request.order === undefined ? {} : { order: request.order }),
+        ...(request.before === undefined ? {} : { before: request.before }),
+        ...(request.after === undefined ? {} : { after: request.after }),
+        ...(request.tier === undefined ? {} : { tier: request.tier }),
+    }));
+    return { kind: 'patch', patch: result.patch.filename, files: [...result.files] };
+}
+/**
+ * Writes the patch queue a source-mode checkout's owned changes export as:
+ * the planned patches with a manifest carrying each group's tier and
+ * waivers. The queue is first replayed onto the pristine commit and compared
+ * with the tree of pristine plus the owned files; a queue that would not
+ * reproduce them is refused and nothing is written. An earlier generated
+ * queue at `out` is replaced.
+ *
+ * @param project - A source-mode project
+ * @param options - `out`: the queue directory (default the project's `patches/`)
+ * @throws `source-mode-required`, `source-invalid` while `verify` reports a
+ *   problem, `export-queue-mismatch` (exit code 6), `export-target-not-generated`
+ */
+function exportQueue(project, options = {}) {
+    const source = requireSourceMode(project);
+    return writeVerified(source, options.out ?? source.paths.patches);
+}

package/dist/src/mode/index.js

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * The one place that asks which mode a project is in. It turns either
+ * storage into the owned-change set, gives a command its workspace and its
+ * tracked-file writer, reports status and integrity in one shape, follows a
+ * project's inputs during a watch, answers the diagnostics that differ by
+ * mode, and holds the operations that cross the two storages or their
+ * formats: exporting a source-mode project as a patch queue, migrating a
+ * patch-mode project to source mode, upgrading a project of the previous
+ * format, and moving either to a new Firefox pin.
+ */
+export { lintSubject, mutationRoots, ownedChanges, ownedFiles, typeCacheDir, } from './changes.js';
+export { diagnose } from './diagnose.js';
+export { exportChanges } from './export.js';
+export { migrate } from './migrate.js';
+export { download, pinnedPristine } from './pristine.js';
+export { rebase } from './rebase.js';
+export { status, verify, verifyOutcome } from './report.js';
+export { createProject, refuseExistingProject } from './setup.js';
+export { editTracked, enginePathOf, trackedFiles } from './tracked.js';
+export { upgrade } from './upgrade.js';
+export { watch } from './watch.js';
+export { deployComponents, listAllWorkspaces, requireCurrentTyping, withOwnedRead, withWorkspace, withWorkspaceOnDemand, } from './workspace.js';