summer-engine 2.8.2 → 3.1.0

package/dist/lib/cloud/checkpoint.js

@@ -1,142 +0,0 @@
-import { execFile } from "child_process";
-import { mkdir, readFile, rm, writeFile } from "fs/promises";
-import { existsSync } from "fs";
-import { join } from "path";
-import { promisify } from "util";
-import { localCloudDir } from "./paths.js";
-const execFileAsync = promisify(execFile);
-/** Timestamped refs (spec 11): refs/gitsummer/<projectId>/cloud-sync-<utcstamp>. */
-const KEEP_CHECKPOINTS = 20;
-export function summerGitDir(projectRoot) {
-    return join(projectRoot, ".summer", "local", "git");
-}
-export async function isGitAvailable() {
-    try {
-        await execFileAsync("git", ["--version"]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function git(projectRoot, args, env = {}) {
-    const gitDir = summerGitDir(projectRoot);
-    const { stdout } = await execFileAsync("git", ["--git-dir", gitDir, "--work-tree", projectRoot, "-c", "core.quotepath=false", "-c", "core.bare=false", ...args], {
-        cwd: projectRoot,
-        maxBuffer: 64 * 1024 * 1024,
-        env: {
-            ...process.env,
-            GIT_AUTHOR_NAME: "Summer Cloud",
-            GIT_AUTHOR_EMAIL: "cloud@summerengine.com",
-            GIT_COMMITTER_NAME: "Summer Cloud",
-            GIT_COMMITTER_EMAIL: "cloud@summerengine.com",
-            ...env,
-        },
-    });
-    return stdout.trim();
-}
-async function ensureBareRepo(projectRoot) {
-    const gitDir = summerGitDir(projectRoot);
-    if (!existsSync(join(gitDir, "HEAD"))) {
-        await mkdir(join(projectRoot, ".summer", "local"), { recursive: true });
-        await execFileAsync("git", ["init", "--bare", gitDir], { cwd: projectRoot });
-    }
-    await ensureExclude(gitDir);
-}
-/** Mirrors GitOps::_ensure_summergit_exclude so checkpoints skip SummerGit's own state. */
-async function ensureExclude(gitDir) {
-    const excludePath = join(gitDir, "info", "exclude");
-    const sentinelBegin = "# >>> Summer Engine BEGIN (do not edit between sentinels)";
-    let existing = "";
-    try {
-        existing = await readFile(excludePath, "utf8");
-        if (existing.includes(sentinelBegin))
-            return;
-    }
-    catch {
-        // info/ exists after git init --bare; file may not.
-    }
-    if (existing && !existing.endsWith("\n"))
-        existing += "\n";
-    existing += `${sentinelBegin}\n.summer/local/\n.godot/\n# <<< Summer Engine END\n`;
-    await mkdir(join(gitDir, "info"), { recursive: true });
-    await writeFile(excludePath, existing, "utf8");
-}
-function checkpointIndexFile(projectRoot) {
-    return join(localCloudDir(projectRoot), "checkpoint-index");
-}
-export function checkpointStamp(date = new Date()) {
-    return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-}
-/**
- * Full-tree SummerGit checkpoint before any destructive apply (spec 11).
- * Plumbing only: stage all into a private index, write-tree, commit-tree,
- * update-ref. Keeps the last KEEP_CHECKPOINTS refs.
- */
-export async function createCheckpoint(projectRoot, projectId) {
-    if (!(await isGitAvailable())) {
-        throw new Error("git is required for the pre-sync safety checkpoint and was not found on PATH. Install git (run summer doctor to verify), then retry.");
-    }
-    await ensureBareRepo(projectRoot);
-    await mkdir(localCloudDir(projectRoot), { recursive: true, mode: 0o700 });
-    // A private index file so checkpoints never fight the engine's own index.
-    const indexFile = checkpointIndexFile(projectRoot);
-    await rm(indexFile, { force: true });
-    const env = { GIT_INDEX_FILE: indexFile };
-    await git(projectRoot, ["add", "-A", "--", "."], env);
-    const tree = await git(projectRoot, ["write-tree"], env);
-    const stamp = checkpointStamp();
-    const commit = await git(projectRoot, ["commit-tree", tree, "-m", `Summer Cloud pre-sync checkpoint ${stamp}`], env);
-    const ref = `refs/gitsummer/${projectId}/cloud-sync-${stamp}`;
-    await git(projectRoot, ["update-ref", ref, commit]);
-    await rm(indexFile, { force: true });
-    await pruneCheckpoints(projectRoot, projectId);
-    return { ref, commit };
-}
-export async function listCheckpoints(projectRoot, projectId) {
-    try {
-        const out = await git(projectRoot, [
-            "for-each-ref",
-            "--format=%(refname)",
-            `refs/gitsummer/${projectId}/`,
-        ]);
-        return out
-            .split("\n")
-            .map((line) => line.trim())
-            .filter((ref) => ref.includes("/cloud-sync-"))
-            .sort();
-    }
-    catch {
-        return [];
-    }
-}
-async function pruneCheckpoints(projectRoot, projectId) {
-    const refs = await listCheckpoints(projectRoot, projectId);
-    const excess = refs.slice(0, Math.max(0, refs.length - KEEP_CHECKPOINTS));
-    for (const ref of excess) {
-        await git(projectRoot, ["update-ref", "-d", ref]).catch(() => { });
-    }
-}
-/**
- * Restores a checkpoint's bytes (spec 11). checkout-index restores bytes but
- * does not delete files a bad sync ADDED, so the result lists extraneous
- * files for the user or agent to remove.
- */
-export async function restoreCheckpoint(projectRoot, projectId, refOrStamp, currentTrackedFiles) {
-    if (!(await isGitAvailable())) {
-        throw new Error("git is required to restore checkpoints and was not found on PATH.");
-    }
-    const ref = refOrStamp.startsWith("refs/")
-        ? refOrStamp
-        : `refs/gitsummer/${projectId}/cloud-sync-${refOrStamp}`;
-    const indexFile = checkpointIndexFile(projectRoot);
-    await rm(indexFile, { force: true });
-    const env = { GIT_INDEX_FILE: indexFile };
-    await git(projectRoot, ["read-tree", ref], env);
-    await git(projectRoot, ["checkout-index", "-a", "-f"], env);
-    await rm(indexFile, { force: true });
-    const inCheckpoint = new Set((await git(projectRoot, ["ls-tree", "-r", "--name-only", ref])).split("\n").filter(Boolean));
-    const restoredFiles = [...inCheckpoint].sort();
-    const extraneousFiles = currentTrackedFiles.filter((path) => !inCheckpoint.has(path)).sort();
-    return { ref, restoredFiles, extraneousFiles };
-}

package/dist/lib/cloud/conflicts.d.ts

@@ -1,55 +0,0 @@
-/**
- * Conflict sets (spec 10.1). Losing bytes never enter the synced tree; they
- * live under .summer/local/cloud/conflicts/<utcstamp>/<original relative
- * path> plus meta.json, and the losing blob is also pushed to R2 (blob-only,
- * granted, unreferenced) so recovery survives the machine.
- */
-export interface ConflictEntry {
-    path: string;
-    localSha256?: string;
-    remoteSha256?: string;
-    winner: "remote" | "local";
-    /** True when this entry is sidecar bytes kept for reference inside the set. */
-    sidecar?: boolean;
-    note?: string;
-}
-export interface ConflictMeta {
-    schemaVersion: 1;
-    stamp: string;
-    projectId: string;
-    baseVersion: number | null;
-    targetVersion: number | null;
-    entries: ConflictEntry[];
-}
-export declare class ConflictSetWriter {
-    private readonly projectRoot;
-    readonly stamp: string;
-    private readonly projectId;
-    private readonly baseVersion;
-    private readonly targetVersion;
-    private entries;
-    private wrotePaths;
-    constructor(projectRoot: string, stamp: string, projectId: string, baseVersion: number | null, targetVersion: number | null);
-    get setDir(): string;
-    /** Preserves the current on-disk bytes of `path` into the conflict set. */
-    preserve(path: string, entry: Omit<ConflictEntry, "path">, sourcePath?: string): Promise<boolean>;
-    hasEntries(): boolean;
-    listEntries(): ConflictEntry[];
-    finalize(): Promise<void>;
-}
-export declare function conflictStamp(date?: Date): string;
-export declare function listConflictSets(projectRoot: string): Promise<Array<{
-    stamp: string;
-    meta: ConflictMeta | null;
-}>>;
-/** Retention (spec 6.2): last 20 conflict sets or 30 days, whichever is more. */
-export declare function pruneConflictSets(projectRoot: string): Promise<void>;
-export interface ConflictRestoreResult {
-    path: string;
-    stamp: string;
-}
-/**
- * `summer cloud conflicts restore <path>`: copies the preserved bytes back
- * into the project tree as a fresh edit (next push syncs it normally).
- */
-export declare function restoreConflictPath(projectRoot: string, path: string, stamp?: string): Promise<ConflictRestoreResult>;

package/dist/lib/cloud/conflicts.js

@@ -1,131 +0,0 @@
-import { copyFile, mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
-import { dirname, join } from "path";
-import { conflictsDir, writeJsonAtomic } from "./paths.js";
-import { containedProjectPath } from "./containment.js";
-const KEEP_SETS = 20;
-const KEEP_DAYS = 30;
-export class ConflictSetWriter {
-    projectRoot;
-    stamp;
-    projectId;
-    baseVersion;
-    targetVersion;
-    entries = [];
-    wrotePaths = new Set();
-    constructor(projectRoot, stamp, projectId, baseVersion, targetVersion) {
-        this.projectRoot = projectRoot;
-        this.stamp = stamp;
-        this.projectId = projectId;
-        this.baseVersion = baseVersion;
-        this.targetVersion = targetVersion;
-    }
-    get setDir() {
-        return join(conflictsDir(this.projectRoot), this.stamp);
-    }
-    /** Preserves the current on-disk bytes of `path` into the conflict set. */
-    async preserve(path, entry, sourcePath) {
-        const source = sourcePath ?? join(this.projectRoot, path);
-        const target = join(this.setDir, path);
-        try {
-            await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-            await copyFile(source, target);
-        }
-        catch {
-            return false; // Nothing local to preserve.
-        }
-        if (!this.wrotePaths.has(path)) {
-            this.wrotePaths.add(path);
-            this.entries.push({ path, ...entry });
-        }
-        return true;
-    }
-    hasEntries() {
-        return this.entries.length > 0;
-    }
-    listEntries() {
-        return [...this.entries];
-    }
-    async finalize() {
-        if (!this.entries.length)
-            return;
-        const meta = {
-            schemaVersion: 1,
-            stamp: this.stamp,
-            projectId: this.projectId,
-            baseVersion: this.baseVersion,
-            targetVersion: this.targetVersion,
-            entries: this.entries,
-        };
-        await writeJsonAtomic(join(this.setDir, "meta.json"), meta);
-        await pruneConflictSets(this.projectRoot);
-    }
-}
-export function conflictStamp(date = new Date()) {
-    return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-}
-export async function listConflictSets(projectRoot) {
-    let names = [];
-    try {
-        names = (await readdir(conflictsDir(projectRoot), { withFileTypes: true }))
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch {
-        return [];
-    }
-    const sets = [];
-    for (const stamp of names) {
-        let meta = null;
-        try {
-            meta = JSON.parse(await readFile(join(conflictsDir(projectRoot), stamp, "meta.json"), "utf8"));
-        }
-        catch {
-            meta = null;
-        }
-        sets.push({ stamp, meta });
-    }
-    return sets;
-}
-/** Retention (spec 6.2): last 20 conflict sets or 30 days, whichever is more. */
-export async function pruneConflictSets(projectRoot) {
-    const sets = await listConflictSets(projectRoot);
-    if (sets.length <= KEEP_SETS)
-        return;
-    const cutoffMs = Date.now() - KEEP_DAYS * 24 * 60 * 60 * 1000;
-    const excess = sets.slice(0, sets.length - KEEP_SETS);
-    for (const set of excess) {
-        const dir = join(conflictsDir(projectRoot), set.stamp);
-        try {
-            const info = await stat(dir);
-            if (info.mtimeMs >= cutoffMs)
-                continue; // Younger than 30 days: keep.
-            await rm(dir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore unreadable sets.
-        }
-    }
-}
-/**
- * `summer cloud conflicts restore <path>`: copies the preserved bytes back
- * into the project tree as a fresh edit (next push syncs it normally).
- */
-export async function restoreConflictPath(projectRoot, path, stamp) {
-    const sets = await listConflictSets(projectRoot);
-    const candidates = (stamp ? sets.filter((set) => set.stamp === stamp) : sets).reverse();
-    for (const set of candidates) {
-        const source = join(conflictsDir(projectRoot), set.stamp, path);
-        try {
-            const bytes = await readFile(source);
-            const target = await containedProjectPath(projectRoot, path);
-            await mkdir(dirname(target), { recursive: true });
-            await writeFile(target, bytes);
-            return { path, stamp: set.stamp };
-        }
-        catch {
-            continue;
-        }
-    }
-    throw new Error(stamp ? `No preserved bytes for ${path} in conflict set ${stamp}` : `No preserved bytes found for ${path} in any conflict set`);
-}

package/dist/lib/cloud/containment.d.ts

@@ -1,8 +0,0 @@
-/**
- * Write containment (spec 9): after joining a manifest key to the project
- * root, resolve the parent chain and assert the final absolute path is
- * strictly inside the realpath of the project root; refuse to write through
- * any symlinked directory component; create nested parents per component so
- * a hostile manifest can never escape the project.
- */
-export declare function containedProjectPath(projectRoot: string, key: string): Promise<string>;

package/dist/lib/cloud/containment.js

@@ -1,52 +0,0 @@
-import { lstat, mkdir, realpath } from "fs/promises";
-import { join, resolve, sep } from "path";
-import { validateCloudPath } from "./validate-path.js";
-/**
- * Write containment (spec 9): after joining a manifest key to the project
- * root, resolve the parent chain and assert the final absolute path is
- * strictly inside the realpath of the project root; refuse to write through
- * any symlinked directory component; create nested parents per component so
- * a hostile manifest can never escape the project.
- */
-export async function containedProjectPath(projectRoot, key) {
-    const valid = validateCloudPath(key);
-    if (!valid.ok) {
-        throw new Error(`Refusing unsafe path ${key}: ${valid.reason}`);
-    }
-    const rootReal = await realpath(projectRoot);
-    const segments = key.split("/");
-    let current = rootReal;
-    for (let i = 0; i < segments.length - 1; i += 1) {
-        current = join(current, segments[i]);
-        let info;
-        try {
-            info = await lstat(current);
-        }
-        catch {
-            await mkdir(current);
-            continue;
-        }
-        if (info.isSymbolicLink()) {
-            throw new Error(`Refusing to write through symlinked directory component: ${current}`);
-        }
-        if (!info.isDirectory()) {
-            throw new Error(`Path component is not a directory: ${current}`);
-        }
-    }
-    const target = join(current, segments[segments.length - 1]);
-    const normalizedRoot = rootReal.endsWith(sep) ? rootReal : rootReal + sep;
-    if (!resolve(target).startsWith(normalizedRoot)) {
-        throw new Error(`Path escapes project root: ${key}`);
-    }
-    try {
-        const info = await lstat(target);
-        if (info.isSymbolicLink()) {
-            throw new Error(`Refusing to replace a symlink: ${key}`);
-        }
-    }
-    catch (err) {
-        if (err.code !== "ENOENT")
-            throw err;
-    }
-    return target;
-}

package/dist/lib/cloud/diff.d.ts

@@ -1,39 +0,0 @@
-import type { CloudManifest, ManifestFile } from "./types.js";
-export type DecisionKind = "push" | "pull" | "delete-local" | "delete-remote" | "conflict-remote-wins" | "keep-local" | "converged";
-export interface PathDecision {
-    path: string;
-    kind: DecisionKind;
-    base?: ManifestFile;
-    local?: ManifestFile;
-    remote?: ManifestFile;
-}
-export interface DiffPlan {
-    decisions: PathDecision[];
-    pushPaths: string[];
-    pullPaths: string[];
-    deleteLocalPaths: string[];
-    deleteRemotePaths: string[];
-    conflictPaths: string[];
-    /** Row 14: local edit beat a remote delete; surfaced as a notice. */
-    keepLocalPaths: string[];
-    /** Row 15: remote edit beat a local delete; surfaced as a notice. */
-    restoredRemotePaths: string[];
-}
-export declare function diffManifests(base: CloudManifest, local: CloudManifest, remote: CloudManifest): DiffPlan;
-/**
- * Sidecar pairing (spec 8.4): foo.png + foo.png.import and foo.gd + foo.gd.uid
- * diff, transfer, delete, and conflict-resolve as one atomic unit. When the
- * primary and its sidecar disagree about which side wins, the primary's
- * direction wins and the sidecar decision is recomputed under that direction.
- */
-export declare function sidecarPrimary(path: string): string | null;
-/**
- * Mass-deletion guardrail (spec 8.5). Confirmation required when deletions
- * exceed 10 files, reach 20% of the base, or cover the entire base.
- */
-export declare function assertDeleteGuard(plan: DiffPlan, baseFileCount: number, confirmDeletes?: boolean): void;
-/**
- * Hard abort (spec 8.5): base non-empty and the local tree reads as completely
- * empty (unmounted volume, wrong directory). No confirmation can override this.
- */
-export declare function assertNotEmptyLocalTree(baseFileCount: number, localFileCount: number): void;

package/dist/lib/cloud/diff.js

@@ -1,138 +0,0 @@
-export function diffManifests(base, local, remote) {
-    const paths = new Set([...Object.keys(base.files), ...Object.keys(local.files), ...Object.keys(remote.files)]);
-    const decisions = [];
-    for (const path of [...paths].sort()) {
-        const b = base.files[path];
-        const l = local.files[path];
-        const r = remote.files[path];
-        const kind = decide(b, l, r);
-        decisions.push({ path, kind, base: b, local: l, remote: r });
-    }
-    pairSidecars(decisions);
-    return planFromDecisions(decisions);
-}
-function planFromDecisions(decisions) {
-    return {
-        decisions,
-        pushPaths: decisions.filter((d) => d.kind === "push").map((d) => d.path),
-        pullPaths: decisions.filter((d) => d.kind === "pull").map((d) => d.path),
-        deleteLocalPaths: decisions.filter((d) => d.kind === "delete-local").map((d) => d.path),
-        deleteRemotePaths: decisions.filter((d) => d.kind === "delete-remote").map((d) => d.path),
-        conflictPaths: decisions.filter((d) => d.kind === "conflict-remote-wins").map((d) => d.path),
-        keepLocalPaths: decisions.filter((d) => d.kind === "keep-local").map((d) => d.path),
-        restoredRemotePaths: decisions
-            .filter((d) => d.kind === "pull" && d.base && !d.local && d.remote && !same(d.remote, d.base))
-            .map((d) => d.path),
-    };
-}
-function decide(base, local, remote) {
-    if (same(local, remote))
-        return "converged";
-    if (!base && local && !remote)
-        return "push";
-    if (!base && !local && remote)
-        return "pull";
-    if (!base && local && remote)
-        return same(local, remote) ? "converged" : "conflict-remote-wins";
-    if (base && same(local, base) && remote && !same(remote, base))
-        return "pull";
-    if (base && local && !same(local, base) && same(remote, base))
-        return "push";
-    if (base && local && remote && same(local, remote))
-        return "converged";
-    if (base && local && remote && !same(local, base) && !same(remote, base))
-        return "conflict-remote-wins";
-    if (base && !local && same(remote, base))
-        return "delete-remote";
-    if (base && same(local, base) && !remote)
-        return "delete-local";
-    if (base && !local && remote && !same(remote, base))
-        return "pull";
-    if (base && local && !same(local, base) && !remote)
-        return "keep-local";
-    return "converged";
-}
-function same(a, b) {
-    if (!a && !b)
-        return true;
-    if (!a || !b)
-        return false;
-    return a.sha256 === b.sha256 && a.size === b.size;
-}
-/**
- * Sidecar pairing (spec 8.4): foo.png + foo.png.import and foo.gd + foo.gd.uid
- * diff, transfer, delete, and conflict-resolve as one atomic unit. When the
- * primary and its sidecar disagree about which side wins, the primary's
- * direction wins and the sidecar decision is recomputed under that direction.
- */
-export function sidecarPrimary(path) {
-    if (path.endsWith(".import"))
-        return path.slice(0, -".import".length);
-    if (path.endsWith(".uid"))
-        return path.slice(0, -".uid".length);
-    return null;
-}
-const REMOTE_WINS = new Set(["pull", "delete-local", "conflict-remote-wins"]);
-const LOCAL_WINS = new Set(["push", "delete-remote", "keep-local"]);
-function pairSidecars(decisions) {
-    const byPath = new Map(decisions.map((d) => [d.path, d]));
-    for (const sidecar of decisions) {
-        const primaryPath = sidecarPrimary(sidecar.path);
-        if (!primaryPath)
-            continue;
-        const primary = byPath.get(primaryPath);
-        if (!primary)
-            continue;
-        // A converged sidecar (L == R) is compatible with either side and a
-        // converged primary lets the sidecar act alone; only direction
-        // disagreement inside the pair is overridden, with the primary winning.
-        if (sidecar.kind === "converged" || primary.kind === "converged")
-            continue;
-        if (REMOTE_WINS.has(primary.kind) && !REMOTE_WINS.has(sidecar.kind)) {
-            sidecar.kind = forceRemoteSide(sidecar);
-        }
-        else if (LOCAL_WINS.has(primary.kind) && !LOCAL_WINS.has(sidecar.kind)) {
-            sidecar.kind = forceLocalSide(sidecar);
-        }
-    }
-}
-function forceRemoteSide(sidecar) {
-    if (sidecar.remote && sidecar.local && !same(sidecar.local, sidecar.remote))
-        return "conflict-remote-wins";
-    if (sidecar.remote && !sidecar.local)
-        return "pull";
-    if (!sidecar.remote && sidecar.local)
-        return "delete-local";
-    return "converged";
-}
-function forceLocalSide(sidecar) {
-    if (sidecar.local && !same(sidecar.local, sidecar.remote))
-        return "push";
-    if (!sidecar.local && sidecar.remote)
-        return "delete-remote";
-    return "converged";
-}
-/**
- * Mass-deletion guardrail (spec 8.5). Confirmation required when deletions
- * exceed 10 files, reach 20% of the base, or cover the entire base.
- */
-export function assertDeleteGuard(plan, baseFileCount, confirmDeletes) {
-    const deletes = plan.deleteRemotePaths.length;
-    if (!deletes)
-        return;
-    const tooMany = deletes > 10 ||
-        (baseFileCount > 0 && deletes >= Math.ceil(baseFileCount * 0.2)) ||
-        deletes === baseFileCount;
-    if (tooMany && !confirmDeletes) {
-        throw new Error(`Push would delete ${deletes} cloud files. Re-run with --confirm-deletes after verifying the project path.`);
-    }
-}
-/**
- * Hard abort (spec 8.5): base non-empty and the local tree reads as completely
- * empty (unmounted volume, wrong directory). No confirmation can override this.
- */
-export function assertNotEmptyLocalTree(baseFileCount, localFileCount) {
-    if (baseFileCount > 0 && localFileCount === 0) {
-        throw new Error("Local project tree is empty but the sync base is not. This looks like an unmounted volume or wrong directory. Aborting sync; no confirmation can push this.");
-    }
-}

package/dist/lib/cloud/engine-bridge.d.ts

@@ -1,34 +0,0 @@
-/**
- * Engine coordination (spec 8.6.1 and 8.7). All calls degrade gracefully: an
- * unreachable engine never blocks a sync; the stability check and conflict
- * routing cover the gaps.
- */
-/** sha256 hex of the stable .summer/local/.project_id (mirrors SummerEngineIdentity::project_id_hash). */
-export declare function readProjectIdHash(projectRoot: string): Promise<string | null>;
-export declare function readProjectPathMarker(projectRoot: string): Promise<string | null>;
-export declare function writeProjectPathMarker(projectRoot: string): Promise<void>;
-/**
- * Before hashing (spec 8.6.1): ask the running engine to flush dirty scenes
- * to disk so the walk hashes what the user actually sees.
- */
-export declare function saveDirtyScenesIfRunning(projectRoot: string): Promise<boolean>;
-/**
- * After apply (spec 8.7): tell the open editor that files changed underneath it.
- *
- * BOTH HALVES OF THIS ARE CURRENTLY DEAD, and the user-visible symptom is that
- * after a cloud pull the editor keeps showing the pre-pull bytes:
- *
- *  - `ScanChanges` is not an engine op. The dispatch ladder
- *    (modules/1summer_engine/editor/ops_executor.cpp:1060-1290) has 84 op kinds and
- *    no ScanChanges branch, so this fails on EVERY build, not just older ones. The
- *    engine-side capability exists as EditorFileSystem::scan_changes() but is
- *    exposed neither as an op nor to GDScript, so there is no caller-reachable
- *    rescan verb at all. O2 owns adding one.
- *  - The scene reload depends on `session.scene`, which /api/health never returns
- *    (see the note in lib/engine.ts), so it is always undefined and never fires.
- *
- * Until the engine exposes a rescan, say so out loud rather than swallowing it —
- * a stale editor that looks correct is exactly the failure this codebase is trying
- * to stop shipping.
- */
-export declare function notifyEngineAfterApply(projectRoot: string, appliedPaths: readonly string[]): Promise<void>;