@wendoo/bridge-app 0.2.2

package/dist/extension-install-log.d.ts

@@ -0,0 +1,54 @@
+import type { ExtensionResolutionWarning } from "./embedded-extensions.js";
+/** App-data key holding a project's extension install log. */
+export declare const EXTENSION_INSTALL_LOG_APP_DATA_KEY = "extension-install-log";
+/**
+ * One entry of a project's install log. The log is a record: nothing in it
+ * requires action, and where an application surfaces it is the application's
+ * choice.
+ */
+export type ExtensionInstallLogEvent = {
+    /** An origin entered the project's resolved closure. */
+    readonly kind: "install";
+    /** Unix epoch milliseconds. */
+    readonly at: number;
+    /** The origin's `<owner>/<repo>` coordinate. */
+    readonly origin: string;
+    /** The winning reference the origin resolved through. */
+    readonly reference: string;
+    /** The immutable routing specifier a fetched origin was installed at; absent for other transports. */
+    readonly specifier?: string;
+} | {
+    /** An origin left the project's resolved closure. */
+    readonly kind: "remove";
+    /** Unix epoch milliseconds. */
+    readonly at: number;
+    /** The origin's `<owner>/<repo>` coordinate. */
+    readonly origin: string;
+} | {
+    /** An install transaction was refused because a reference's fetch failed; the project was left unchanged. */
+    readonly kind: "fetch-refusal";
+    /** Unix epoch milliseconds. */
+    readonly at: number;
+    /** The reference whose fetch failed, as written. */
+    readonly reference: string;
+    /** Stable failure code of the fetch attempt. */
+    readonly code: string;
+    /** Human-readable failure message. */
+    readonly message: string;
+} | {
+    /** Resolution selected between conflicting requesters (take-newer or reference tie-break). */
+    readonly kind: "resolution-warning";
+    /** Unix epoch milliseconds. */
+    readonly at: number;
+    /** The structured resolution warning. */
+    readonly warning: ExtensionResolutionWarning;
+};
+/**
+ * Parse a project's install log from its app-data text. Returns an empty log
+ * when the text is absent or malformed. Entries with event kinds no longer
+ * produced (historical logs) parse and round-trip unchanged.
+ */
+export declare function parseExtensionInstallLog(raw: string | undefined): readonly ExtensionInstallLogEvent[];
+/** Append events to a log's app-data text, returning the updated text. */
+export declare function appendExtensionInstallLog(raw: string | undefined, events: readonly ExtensionInstallLogEvent[]): string;
+//# sourceMappingURL=extension-install-log.d.ts.map

package/dist/extension-install-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-install-log.d.ts","sourceRoot":"","sources":["../src/extension-install-log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAE3E,8DAA8D;AAC9D,eAAO,MAAM,kCAAkC,0BAA0B,CAAC;AAE1E;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAChC;IACE,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,sGAAsG;IACtG,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,GACD;IACE,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,GACD;IACE,6GAA6G;IAC7G,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,GACD;IACE,8FAA8F;IAC9F,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,CAAC,OAAO,EAAE,0BAA0B,CAAC;CAC9C,CAAC;AAEN;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,wBAAwB,EAAE,CAQrG;AAED,0EAA0E;AAC1E,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,MAAM,EAAE,SAAS,wBAAwB,EAAE,GAC1C,MAAM,CAER"}

package/dist/extension-install-log.js

@@ -0,0 +1,22 @@
+/** App-data key holding a project's extension install log. */
+export const EXTENSION_INSTALL_LOG_APP_DATA_KEY = "extension-install-log";
+/**
+ * Parse a project's install log from its app-data text. Returns an empty log
+ * when the text is absent or malformed. Entries with event kinds no longer
+ * produced (historical logs) parse and round-trip unchanged.
+ */
+export function parseExtensionInstallLog(raw) {
+    if (raw === undefined)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Append events to a log's app-data text, returning the updated text. */
+export function appendExtensionInstallLog(raw, events) {
+    return JSON.stringify([...parseExtensionInstallLog(raw), ...events]);
+}

package/dist/extension-install.d.ts

@@ -0,0 +1,162 @@
+import type { AppHostErrorCode, ExtensionCatalogMoves, ExtensionFetchError, ExtensionFetchResult, ExtensionVersionListResult } from "@wendoo/app-host";
+import type { IBrainDef } from "@wendoo/core/app";
+import type { WorkspaceDiagnosticEntry } from "@wendoo/ts-compiler";
+import type { EmbeddedExtension, ExtensionResolutionWarning } from "./embedded-extensions.js";
+import type { InstalledExtensionSnapshot, InstalledExtensionSnapshots } from "./fetched-extension-snapshots.js";
+/**
+ * The diagnostic state of a project at one extension resolution: per-file
+ * compiler diagnostics keyed by workspace path, and per-brain typecheck
+ * problems keyed by brain key. Two states diff into an
+ * {@link ExtensionInstallOutcome} regardless of what mutation produced them.
+ */
+export interface ProjectDiagnosticsState {
+    /** Compiler diagnostics keyed by workspace path (host files and `.libraries/` files alike). */
+    readonly files: ReadonlyMap<string, readonly WorkspaceDiagnosticEntry[]>;
+    /** Brain typecheck problem renderings keyed by brain key. */
+    readonly brains: ReadonlyMap<string, readonly string[]>;
+}
+/** How an install transaction's end state compares to its baseline. */
+export type ExtensionInstallOutcomeKind = "improved" | "unchanged" | "worsened";
+/** One problem named by an install outcome. */
+export interface ExtensionInstallProblem {
+    /** Workspace path of the file, or the brain key, the problem is located at. */
+    readonly location: string;
+    /** Rendering of the problem. */
+    readonly description: string;
+}
+/** The outcome of one install transaction: the diagnostic difference against its baseline. */
+export interface ExtensionInstallOutcome {
+    /** `worsened` when new problems appeared; `improved` when none appeared and some resolved; `unchanged` otherwise. */
+    readonly kind: ExtensionInstallOutcomeKind;
+    /** Problems present after the transaction that were absent before. */
+    readonly newProblems: readonly ExtensionInstallProblem[];
+    /** Problems present before the transaction that are gone after. */
+    readonly resolvedProblems: readonly ExtensionInstallProblem[];
+}
+/**
+ * Diff two diagnostic states into an install outcome. Problems are compared as
+ * per-location multisets of severity, code, and message; a problem that only
+ * moved within its file is unchanged.
+ */
+export declare function diffProjectDiagnostics(before: ProjectDiagnosticsState, after: ProjectDiagnosticsState): ExtensionInstallOutcome;
+/**
+ * Re-typecheck a brain against the current catalogs and collect its problems,
+ * one rendering per diagnostic. Every rule is marked dirty first, so the
+ * typecheck recomputes each rule's result.
+ */
+export declare function typecheckBrainProblems(brain: IBrainDef): readonly string[];
+/**
+ * A mechanics failure that refuses an install transaction outright: no
+ * coherent state exists to commit, and the project is left unchanged.
+ */
+export type ExtensionInstallRefusal = {
+    /** A dependency's content could not be fetched. */
+    readonly kind: "fetch";
+    /** The failure, carrying its {@link ExtensionFetchError.code} and the reference it was for. */
+    readonly error: ExtensionFetchError;
+} | {
+    /** The extension graph contains a dependency cycle. */
+    readonly kind: "cycle";
+    /** The origins on the cycle, in traversal order, with the first origin repeated at the end. */
+    readonly cycle: readonly string[];
+    /** Human-readable refusal message. */
+    readonly message: string;
+} | {
+    /** The project's stored extension records could not be read, so no write may replace them. */
+    readonly kind: "store";
+    /** Stable code of the read failure. */
+    readonly code: AppHostErrorCode;
+    /** Human-readable refusal message. */
+    readonly message: string;
+};
+/** The result of one install transaction. */
+export type ExtensionInstallReport = {
+    /** True: the transaction committed (improved, unchanged, and worsened outcomes all commit). */
+    readonly committed: true;
+    /** The diagnostic difference against the pre-install baseline. */
+    readonly outcome: ExtensionInstallOutcome;
+    /** Non-fatal resolution conflicts encountered, in encounter order. */
+    readonly warnings: readonly ExtensionResolutionWarning[];
+} | {
+    /** False: a mechanics failure refused the transaction; nothing changed. */
+    readonly committed: false;
+    /** The refusal. */
+    readonly refusal: ExtensionInstallRefusal;
+};
+/** Result of {@link collectExtensionFetchClosure}. */
+export type ExtensionFetchClosureResult = {
+    /** True when content is available for every reachable, non-skipped `gh:` reference. */
+    readonly ok: true;
+    /** Snapshot record per reachable `gh:` reference: reused stored records and fresh fetches. */
+    readonly snapshotsByReference: ReadonlyMap<string, InstalledExtensionSnapshot>;
+    /** Non-fatal catalog-move findings: edges skipped this walk, retried on the next load. */
+    readonly warnings: readonly ExtensionResolutionWarning[];
+    /**
+     * Pinned `gh:` references for coordinates whose moves resolved through a
+     * floating destination during this walk, keyed by lowercased coordinate.
+     */
+    readonly floatingPins: ReadonlyMap<string, string>;
+} | {
+    /** False when a fetch of a reference as written failed; the transaction must refuse. */
+    readonly ok: false;
+    /** The failure. */
+    readonly error: ExtensionFetchError;
+};
+/**
+ * The stored snapshot records' pinned `gh:` references, keyed by lowercased
+ * coordinate. A floating catalog-move destination resolves through this map
+ * before any network lookup, so an already-migrated coordinate keeps its pin.
+ *
+ * @param stored - The project's stored snapshot records, keyed by coordinate.
+ */
+export declare function floatingPinsFromSnapshots(stored: InstalledExtensionSnapshots): Map<string, string>;
+/**
+ * Walk every reference reachable from an extensions map and ensure content is
+ * available for each reachable `gh:` reference: a usable stored record whose
+ * reference matches is reused, and anything else is fetched. Catalog moves
+ * apply at every dependency edge through the apply/fetch/re-apply loop of the
+ * shared walk; a moved edge that cannot complete this walk (fetch failure,
+ * unresolvable floating destination, undeterminable version) surfaces a
+ * stable-coded warning and is skipped, while a fetch failure for a reference
+ * as written fails the whole walk. A dependency set thus fetches as one unit
+ * before one resolution.
+ *
+ * @param options.extensions - The extensions map to walk; root references are walked as written.
+ * @param options.embedded - The host application's bundled embedded extensions.
+ * @param options.stored - The project's stored snapshot records, reused by matching reference when usable.
+ * @param options.refetch - References fetched fresh even when a stored record matches.
+ * @param options.moves - Curated catalog moves applied at every dependency edge.
+ * @param options.fetchSnapshot - Fetches a snapshot for a `gh:` reference.
+ * @param options.listVersions - Lists a repository's published versions, resolving floating move destinations.
+ */
+export declare function collectExtensionFetchClosure(options: {
+    extensions: Readonly<Record<string, string>>;
+    embedded: readonly EmbeddedExtension[];
+    stored: InstalledExtensionSnapshots;
+    refetch?: ReadonlySet<string>;
+    moves?: ExtensionCatalogMoves;
+    fetchSnapshot: (reference: string) => Promise<ExtensionFetchResult>;
+    listVersions?: (owner: string, repo: string) => Promise<ExtensionVersionListResult>;
+}): Promise<ExtensionFetchClosureResult>;
+/**
+ * Report whether the moved closure of an extensions map reaches a `gh:`
+ * reference whose content is not already available -- neither bundled as an
+ * embedded extension nor held in the stored snapshot records. Runs the shared
+ * closure walk in dry-run mode: moves apply at every edge with the versions
+ * the stored content determines, a floating destination with no stored pin
+ * counts as missing content, and nothing is fetched. It answers whether a
+ * load must run a fetch transaction to heal a moved dependency whose content
+ * the project never persisted, or persisted in an unusable record.
+ *
+ * @param options.extensions - The extensions map to walk, with any top-level moves already applied.
+ * @param options.embedded - The host application's bundled embedded extensions.
+ * @param options.stored - The project's stored snapshot records, matched by reference.
+ * @param options.moves - Curated catalog moves applied at every dependency edge.
+ */
+export declare function movedClosureHasMissingContent(options: {
+    extensions: Readonly<Record<string, string>>;
+    embedded: readonly EmbeddedExtension[];
+    stored: InstalledExtensionSnapshots;
+    moves?: ExtensionCatalogMoves;
+}): Promise<boolean>;
+//# sourceMappingURL=extension-install.d.ts.map

package/dist/extension-install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-install.d.ts","sourceRoot":"","sources":["../src/extension-install.ts"],"names":[],"mappings":"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"}

package/dist/extension-install.js

@@ -0,0 +1,412 @@
+import { applyCatalogMove, fileContentText, highestListedRelease, parseCatalogMoveReference, parseExtensionReference, parseProjectContentManifest, WENDOO_JSON_PATH, } from "@wendoo/app-host";
+import { BrainRuleDef } from "@wendoo/core/brain/model";
+import { CatalogMoveWarningCode, createCatalogMoveVersionLookup } from "./embedded-extensions.js";
+import { decodeInstalledSnapshotFiles, installedSnapshotFromFetched } from "./fetched-extension-snapshots.js";
+/** Render a compiler diagnostic as a location-independent problem key. */
+function diagnosticProblem(entry) {
+    return `${entry.severity} ${entry.code}: ${entry.message}`;
+}
+/** Count problem occurrences per location. */
+function problemCounts(state) {
+    const counts = new Map();
+    const add = (location, problem) => {
+        let atLocation = counts.get(location);
+        if (!atLocation) {
+            atLocation = new Map();
+            counts.set(location, atLocation);
+        }
+        atLocation.set(problem, (atLocation.get(problem) ?? 0) + 1);
+    };
+    for (const [path, entries] of state.files) {
+        for (const entry of entries) {
+            add(path, diagnosticProblem(entry));
+        }
+    }
+    for (const [key, problems] of state.brains) {
+        for (const problem of problems) {
+            add(key, problem);
+        }
+    }
+    return counts;
+}
+/** Problems whose per-location count grew from `from` to `to`, one entry per additional occurrence. */
+function grownProblems(from, to) {
+    const grown = [];
+    for (const [location, toCounts] of to) {
+        const fromCounts = from.get(location);
+        for (const [problem, count] of toCounts) {
+            const before = fromCounts?.get(problem) ?? 0;
+            for (let i = before; i < count; i++) {
+                grown.push({ location, description: problem });
+            }
+        }
+    }
+    return grown;
+}
+/**
+ * Diff two diagnostic states into an install outcome. Problems are compared as
+ * per-location multisets of severity, code, and message; a problem that only
+ * moved within its file is unchanged.
+ */
+export function diffProjectDiagnostics(before, after) {
+    const beforeCounts = problemCounts(before);
+    const afterCounts = problemCounts(after);
+    const newProblems = grownProblems(beforeCounts, afterCounts);
+    const resolvedProblems = grownProblems(afterCounts, beforeCounts);
+    const kind = newProblems.length > 0 ? "worsened" : resolvedProblems.length > 0 ? "improved" : "unchanged";
+    return { kind, newProblems, resolvedProblems };
+}
+// ---------------------------------------------------------------------------
+// Brain typecheck problems
+// ---------------------------------------------------------------------------
+function collectRuleProblems(rule, problems) {
+    if (rule instanceof BrainRuleDef) {
+        const result = rule.when().typecheckResult();
+        if (result) {
+            const path = rule.getLocationPath();
+            result.whenParseResult.diags.forEach((diag) => {
+                problems.push(`${path} when parse ${diag.code}: ${diag.message}`);
+            });
+            result.doParseResult.diags.forEach((diag) => {
+                problems.push(`${path} do parse ${diag.code}: ${diag.message}`);
+            });
+            result.typeInfo.diags.forEach((diag) => {
+                problems.push(`${path} type ${diag.code}: ${diag.message}`);
+            });
+        }
+    }
+    rule.children().forEach((child) => {
+        collectRuleProblems(child, problems);
+    });
+}
+/**
+ * Re-typecheck a brain against the current catalogs and collect its problems,
+ * one rendering per diagnostic. Every rule is marked dirty first, so the
+ * typecheck recomputes each rule's result.
+ */
+export function typecheckBrainProblems(brain) {
+    brain.pages().forEach((page) => {
+        page.children().forEach((rule) => {
+            rule.markDirty();
+        });
+    });
+    brain.typecheck();
+    const problems = [];
+    brain.pages().forEach((page) => {
+        page.children().forEach((rule) => {
+            collectRuleProblems(rule, problems);
+        });
+    });
+    return problems;
+}
+/** Read the extensions map an origin's own content manifest declares. */
+function ownExtensions(files) {
+    const manifestContent = manifestTextOf(files);
+    if (manifestContent === undefined)
+        return {};
+    const parsed = parseProjectContentManifest(manifestContent);
+    return parsed.ok ? parsed.manifest.extensions : {};
+}
+/**
+ * Report whether a stored snapshot record holds usable content: its decoded
+ * files carry a parseable `wendoo.json`. Every fetched snapshot is written
+ * with one, so a record without it is corrupt and its content must be treated
+ * as missing.
+ */
+function isUsableSnapshotRecord(record) {
+    const manifestContent = manifestTextOf(decodeInstalledSnapshotFiles(record));
+    if (manifestContent === undefined)
+        return false;
+    return parseProjectContentManifest(manifestContent).ok;
+}
+/** The text of an origin's own `wendoo.json`, at either path spelling. */
+function manifestTextOf(files) {
+    const entry = files.get(`/${WENDOO_JSON_PATH}`) ?? files.get(WENDOO_JSON_PATH);
+    return entry === undefined ? undefined : fileContentText(entry);
+}
+/** Build the leading-slash file map of an embedded extension. */
+function embeddedContent(extension) {
+    const files = new Map();
+    for (const file of extension.files) {
+        files.set(file.path.startsWith("/") ? file.path : `/${file.path}`, file.content);
+    }
+    return files;
+}
+/**
+ * The stored snapshot records' pinned `gh:` references, keyed by lowercased
+ * coordinate. A floating catalog-move destination resolves through this map
+ * before any network lookup, so an already-migrated coordinate keeps its pin.
+ *
+ * @param stored - The project's stored snapshot records, keyed by coordinate.
+ */
+export function floatingPinsFromSnapshots(stored) {
+    const pins = new Map();
+    for (const [coordinate, record] of Object.entries(stored)) {
+        const parsed = parseExtensionReference(record.reference);
+        if (parsed?.transport === "gh" && parsed.routing.kind === "pin") {
+            pins.set(coordinate.toLowerCase(), record.reference);
+        }
+    }
+    return pins;
+}
+/**
+ * Walk every reference reachable from an extensions map -- through embedded
+ * extensions' own manifests and through fetched snapshots' manifests alike --
+ * applying catalog moves at every dependency edge. The walk iterates
+ * apply/fetch/re-apply: content fetched during a pass can determine versions
+ * that let a `packageVersion` selector capture on the next pass, until no edge
+ * rewrite changes. Root references are walked as written.
+ *
+ * A stored record is reused only when it is usable (its files carry a
+ * parseable `wendoo.json`); an unusable record counts as missing content in
+ * both modes.
+ *
+ * In fetch mode (a `fetchSnapshot` callback present), content missing for a
+ * reference as written fails the walk; content missing for a move-rewritten
+ * edge, an unresolvable floating destination, and a permanently undeterminable
+ * version each surface a stable-coded `catalog-move-failed` warning, skipping
+ * that edge for this walk. In dry-run mode nothing is fetched and the walk
+ * reports whether any reachable content is missing.
+ */
+async function walkExtensionClosure(options) {
+    const moves = options.moves ?? {};
+    const dryRun = options.fetchSnapshot === undefined;
+    const embeddedByCoordinate = new Map(options.embedded.map((extension) => [extension.canonicalOrigin, extension]));
+    const storedByReference = new Map();
+    for (const record of Object.values(options.stored)) {
+        if (options.refetch?.has(record.reference))
+            continue;
+        // An unusable record is treated as missing content: a dry run reports it
+        // and a fetch walk refetches and replaces it.
+        if (!isUsableSnapshotRecord(record))
+            continue;
+        storedByReference.set(record.reference, record);
+    }
+    const fetchedRecords = new Map();
+    const floatingPins = floatingPinsFromSnapshots(options.stored);
+    const unresolvableFloating = new Set();
+    const versionLookup = createCatalogMoveVersionLookup({
+        embedded: options.embedded,
+        contentForReference: (reference) => {
+            const record = fetchedRecords.get(reference) ?? storedByReference.get(reference);
+            return record !== undefined ? decodeInstalledSnapshotFiles(record) : undefined;
+        },
+    });
+    const warnings = [];
+    const warned = new Set();
+    const warn = (reference, code, message) => {
+        const key = `${reference} ${code}`;
+        if (warned.has(key))
+            return;
+        warned.add(key);
+        warnings.push({
+            kind: "catalog-move-failed",
+            origin: parseCatalogMoveReference(reference)?.coordinate ?? reference,
+            reference,
+            code,
+            message,
+        });
+    };
+    /** Resolve a floating reference to a pinned one: a known pin, else the highest stable published version. */
+    const resolveFloating = async (coordinate) => {
+        const key = coordinate.toLowerCase();
+        const known = floatingPins.get(key);
+        if (known !== undefined) {
+            return known;
+        }
+        if (dryRun || options.listVersions === undefined || unresolvableFloating.has(key)) {
+            return undefined;
+        }
+        const slash = coordinate.indexOf("/");
+        const listed = await options.listVersions(coordinate.slice(0, slash), coordinate.slice(slash + 1));
+        const version = listed.ok ? highestListedRelease(listed.versions) : undefined;
+        if (version === undefined) {
+            unresolvableFloating.add(key);
+            return undefined;
+        }
+        const pin = `gh:${coordinate}@${version}`;
+        floatingPins.set(key, pin);
+        return pin;
+    };
+    /**
+     * Redirect one declared edge through the moves with the versions known so
+     * far. A floating result resolves to its pin, and the moves re-apply from
+     * the pin, until the reference is concrete and uncaptured. Returns the walk
+     * item, or `undefined` when the edge is skipped this walk. `pendingRefs`
+     * collects declared references whose version-range evaluation is still
+     * pending, and `outputs` records the edge's final reference for the fixpoint
+     * comparison.
+     */
+    const redirectEdge = async (declaredReference, pendingRefs, outputs) => {
+        let reference = declaredReference;
+        let movedByCatalog = false;
+        const seenPins = new Set();
+        while (true) {
+            const applied = applyCatalogMove(reference, moves, versionLookup);
+            if (!applied.ok) {
+                warn(declaredReference, applied.code, applied.message);
+                outputs.set(declaredReference, declaredReference);
+                return { reference: declaredReference, movedByCatalog: false };
+            }
+            if (applied.moved) {
+                reference = applied.reference;
+                movedByCatalog = true;
+            }
+            const parts = parseCatalogMoveReference(reference);
+            if (!parts?.floating) {
+                // Pending only counts at the edge's final concrete reference: a range
+                // blocked at an intermediate floating hop is resolved by the pin
+                // substitution and re-application.
+                if (applied.pendingVersion) {
+                    pendingRefs.add(declaredReference);
+                }
+                outputs.set(declaredReference, reference);
+                return { reference, movedByCatalog };
+            }
+            const pin = await resolveFloating(parts.coordinate);
+            if (pin === undefined) {
+                outputs.set(declaredReference, reference);
+                if (dryRun) {
+                    // A floating destination with no stored pin needs a fetch
+                    // transaction to resolve and persist one.
+                    missingContent = true;
+                }
+                else {
+                    warn(declaredReference, CatalogMoveWarningCode.FLOATING_UNRESOLVED, `Catalog move for "${declaredReference}" resolves to the floating "${reference}" and no stable ` +
+                        "published version could be pinned; the move is skipped this load.");
+                }
+                return undefined;
+            }
+            if (seenPins.has(pin)) {
+                warn(declaredReference, CatalogMoveWarningCode.CYCLE, `Catalog moves for "${declaredReference}" revisited the pinned "${pin}".`);
+                outputs.set(declaredReference, declaredReference);
+                return { reference: declaredReference, movedByCatalog: false };
+            }
+            seenPins.add(pin);
+            reference = pin;
+            movedByCatalog = true;
+        }
+    };
+    let previousOutputs;
+    let missingContent = false;
+    while (true) {
+        const outputs = new Map();
+        const pendingRefs = new Set();
+        const snapshotsByReference = new Map();
+        missingContent = false;
+        const visited = new Set();
+        const queue = Object.values(options.extensions).map((reference) => ({
+            reference,
+            movedByCatalog: false,
+        }));
+        while (queue.length > 0) {
+            const item = queue.shift();
+            if (visited.has(item.reference))
+                continue;
+            visited.add(item.reference);
+            const parsed = parseExtensionReference(item.reference);
+            if (parsed === undefined)
+                continue;
+            let files;
+            if (parsed.transport === "embedded") {
+                const extension = embeddedByCoordinate.get(parsed.coordinate);
+                if (extension === undefined)
+                    continue;
+                files = embeddedContent(extension);
+            }
+            else if (parsed.transport === "gh") {
+                let record = fetchedRecords.get(item.reference) ?? storedByReference.get(item.reference);
+                if (record === undefined) {
+                    if (dryRun) {
+                        missingContent = true;
+                        continue;
+                    }
+                    const fetched = await options.fetchSnapshot(item.reference);
+                    if (!fetched.ok) {
+                        if (item.movedByCatalog) {
+                            warn(item.reference, CatalogMoveWarningCode.FETCH_FAILED, `Moved content "${item.reference}" could not be fetched (${fetched.error.code}); ` +
+                                "the move is skipped this load.");
+                            continue;
+                        }
+                        return { ok: false, error: fetched.error };
+                    }
+                    record = installedSnapshotFromFetched(fetched.snapshot);
+                    fetchedRecords.set(item.reference, record);
+                }
+                snapshotsByReference.set(item.reference, record);
+                files = decodeInstalledSnapshotFiles(record);
+            }
+            if (files === undefined)
+                continue;
+            for (const declaredReference of Object.values(ownExtensions(files))) {
+                const child = await redirectEdge(declaredReference, pendingRefs, outputs);
+                if (child !== undefined) {
+                    queue.push(child);
+                }
+            }
+        }
+        const stable = previousOutputs !== undefined &&
+            outputs.size === previousOutputs.size &&
+            [...outputs].every(([key, value]) => previousOutputs?.get(key) === value);
+        if (stable) {
+            if (!dryRun) {
+                for (const declaredReference of pendingRefs) {
+                    warn(declaredReference, CatalogMoveWarningCode.VERSION_UNKNOWN, `The version of "${declaredReference}" could not be determined, so its version-scoped catalog move ` +
+                        "cannot be evaluated; the move is skipped this load.");
+                }
+            }
+            return { ok: true, snapshotsByReference, warnings, floatingPins, missingContent };
+        }
+        previousOutputs = outputs;
+    }
+}
+/**
+ * Walk every reference reachable from an extensions map and ensure content is
+ * available for each reachable `gh:` reference: a usable stored record whose
+ * reference matches is reused, and anything else is fetched. Catalog moves
+ * apply at every dependency edge through the apply/fetch/re-apply loop of the
+ * shared walk; a moved edge that cannot complete this walk (fetch failure,
+ * unresolvable floating destination, undeterminable version) surfaces a
+ * stable-coded warning and is skipped, while a fetch failure for a reference
+ * as written fails the whole walk. A dependency set thus fetches as one unit
+ * before one resolution.
+ *
+ * @param options.extensions - The extensions map to walk; root references are walked as written.
+ * @param options.embedded - The host application's bundled embedded extensions.
+ * @param options.stored - The project's stored snapshot records, reused by matching reference when usable.
+ * @param options.refetch - References fetched fresh even when a stored record matches.
+ * @param options.moves - Curated catalog moves applied at every dependency edge.
+ * @param options.fetchSnapshot - Fetches a snapshot for a `gh:` reference.
+ * @param options.listVersions - Lists a repository's published versions, resolving floating move destinations.
+ */
+export async function collectExtensionFetchClosure(options) {
+    const outcome = await walkExtensionClosure(options);
+    if (!outcome.ok) {
+        return outcome;
+    }
+    return {
+        ok: true,
+        snapshotsByReference: outcome.snapshotsByReference,
+        warnings: outcome.warnings,
+        floatingPins: outcome.floatingPins,
+    };
+}
+/**
+ * Report whether the moved closure of an extensions map reaches a `gh:`
+ * reference whose content is not already available -- neither bundled as an
+ * embedded extension nor held in the stored snapshot records. Runs the shared
+ * closure walk in dry-run mode: moves apply at every edge with the versions
+ * the stored content determines, a floating destination with no stored pin
+ * counts as missing content, and nothing is fetched. It answers whether a
+ * load must run a fetch transaction to heal a moved dependency whose content
+ * the project never persisted, or persisted in an unusable record.
+ *
+ * @param options.extensions - The extensions map to walk, with any top-level moves already applied.
+ * @param options.embedded - The host application's bundled embedded extensions.
+ * @param options.stored - The project's stored snapshot records, matched by reference.
+ * @param options.moves - Curated catalog moves applied at every dependency edge.
+ */
+export async function movedClosureHasMissingContent(options) {
+    const outcome = await walkExtensionClosure(options);
+    return outcome.ok ? outcome.missingContent : true;
+}