summer-engine 2.8.1 → 3.0.0

package/dist/lib/cloud/apply.js

@@ -1,294 +0,0 @@
-import { chmod, copyFile, lstat, readFile, rename, rm, stat, writeFile } from "fs/promises";
-import { basename, dirname, join } from "path";
-import { containedProjectPath } from "./containment.js";
-import { mergeProjectGodot } from "./project-godot-merge.js";
-import { casefoldKey } from "./validate-path.js";
-const RENAME_RETRIES = 7;
-const RENAME_BACKOFF_MS = 50;
-/**
- * Two-phase pull, phase 2 (spec 8.7). Fixed order: renames first (case-only
- * renames as two-step), then writes (project.godot and *.tscn last), then
- * deletes. Every write is an atomic rename from staging; every modify or
- * delete is preceded by exactly one full-tree checkpoint and a pre-image
- * stat check that routes drifted files to conflicts instead of overwriting.
- */
-export async function applyRemotePlan(projectRoot, plan, remote, context) {
-    const result = { appliedPaths: [], notices: [], preservedLocalHashes: new Map() };
-    const decisionByPath = new Map(plan.decisions.map((d) => [d.path, d]));
-    let writes = [...plan.pullPaths, ...plan.conflictPaths].filter((path) => remote.files[path]);
-    let deletes = [...plan.deleteLocalPaths];
-    if (!writes.length && !deletes.length)
-        return result;
-    // Checkpoint before ANY destructive apply (spec 11): a modify of an
-    // existing file or a delete.
-    let checkpointed = false;
-    const ensureCheckpoint = async () => {
-        if (checkpointed)
-            return;
-        checkpointed = true;
-        await context.onBeforeDestructive();
-    };
-    for (const path of writes) {
-        if (await pathExistsOnDisk(projectRoot, path, context)) {
-            await ensureCheckpoint();
-            break;
-        }
-    }
-    if (!checkpointed && deletes.length)
-        await ensureCheckpoint();
-    // Phase: renames. A delete-local plus pull pair with the same content hash
-    // and casefold-equal keys is a case-only rename, executed as a two-step
-    // rename so case-insensitive volumes never lose the file (spec 8.7).
-    const renamed = await applyCaseOnlyRenames(projectRoot, plan, remote, context, decisionByPath, result);
-    writes = writes.filter((path) => !renamed.has(path));
-    deletes = deletes.filter((path) => !renamed.has(path));
-    // Phase: writes, with project.godot and *.tscn last so a partially
-    // hydrated project is never scanned with dangling scene dependencies.
-    const stagedUseCount = new Map();
-    for (const path of writes) {
-        const hash = remote.files[path].sha256;
-        stagedUseCount.set(hash, (stagedUseCount.get(hash) ?? 0) + 1);
-    }
-    writes.sort((a, b) => writeOrderRank(a) - writeOrderRank(b) || (a < b ? -1 : a > b ? 1 : 0));
-    for (const path of writes) {
-        const decision = decisionByPath.get(path);
-        const remoteFile = remote.files[path];
-        const isConflict = plan.conflictPaths.includes(path);
-        // Pre-image stat check (spec 8.7): a file that changed between diff and
-        // apply is routed to conflicts instead of being blindly overwritten.
-        const drifted = await driftedSinceDiff(projectRoot, path, context);
-        if (isConflict || drifted) {
-            await preserveLoser(projectRoot, path, decision, remoteFile.sha256, context, result, drifted && !isConflict);
-        }
-        if (path === "project.godot" && isConflict) {
-            const merged = await mergeProjectGodotFromContext(projectRoot, path, decision, remote, context, result);
-            if (merged) {
-                result.appliedPaths.push(path);
-                continue;
-            }
-        }
-        const stagedPath = context.staged.get(remoteFile.sha256);
-        if (!stagedPath)
-            throw new Error(`Missing staged blob for ${path} (${remoteFile.sha256})`);
-        const remaining = stagedUseCount.get(remoteFile.sha256) - 1;
-        stagedUseCount.set(remoteFile.sha256, remaining);
-        await placeFromStaging(projectRoot, path, stagedPath, remaining > 0, context);
-        result.appliedPaths.push(path);
-    }
-    // Phase: deletes.
-    const survivingFold = new Map();
-    for (const key of Object.keys(remote.files))
-        survivingFold.set(casefoldKey(key), key);
-    for (const path of deletes) {
-        const decision = decisionByPath.get(path);
-        const onDisk = context.diskPathByKey.get(path) ?? join(projectRoot, path);
-        // Pre-image check: a delete target edited since the diff is row 14 now
-        // (edit beats delete); keep the local file and surface it.
-        if (await driftedSinceDiff(projectRoot, path, context)) {
-            result.notices.push(`${path}: changed during sync; kept local file (edit beats delete)`);
-            continue;
-        }
-        // Inode-gated casefold skip (spec 8.7): a delete whose casefolded path
-        // equals a surviving manifest key is skipped only when a samefile check
-        // proves both names map to one on-disk file.
-        const survivor = survivingFold.get(casefoldKey(path));
-        if (survivor && survivor !== path) {
-            if (await isSameFile(onDisk, join(projectRoot, survivor))) {
-                continue;
-            }
-        }
-        if (decision?.local?.sha256) {
-            result.preservedLocalHashes.set(decision.local.sha256, onDisk);
-        }
-        await rm(onDisk, { force: true });
-        result.appliedPaths.push(path);
-    }
-    for (const path of plan.keepLocalPaths) {
-        result.notices.push(`${path}: deleted in cloud but edited here; keeping local file (edit beats delete)`);
-    }
-    for (const path of plan.restoredRemotePaths) {
-        result.notices.push(`${path}: deleted here but edited in cloud; restored the cloud file (edit beats delete)`);
-    }
-    return result;
-}
-function writeOrderRank(path) {
-    if (path === "project.godot")
-        return 2;
-    if (path.endsWith(".tscn"))
-        return 1;
-    return 0;
-}
-async function pathExistsOnDisk(projectRoot, path, context) {
-    const onDisk = context.diskPathByKey.get(path) ?? join(projectRoot, path);
-    try {
-        await lstat(onDisk);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function driftedSinceDiff(projectRoot, path, context) {
-    const recorded = context.statByKey.get(path);
-    if (!recorded)
-        return false;
-    const onDisk = context.diskPathByKey.get(path) ?? join(projectRoot, path);
-    try {
-        const info = await lstat(onDisk, { bigint: true });
-        return Number(info.size) !== recorded.size || info.mtimeNs.toString() !== recorded.mtimeNs;
-    }
-    catch {
-        return false; // Gone since the diff; nothing to preserve.
-    }
-}
-async function preserveLoser(projectRoot, path, decision, remoteSha256, context, result, drifted) {
-    const onDisk = context.diskPathByKey.get(path) ?? join(projectRoot, path);
-    const localSha = decision?.local?.sha256;
-    const preserved = await context.conflicts.preserve(path, {
-        localSha256: localSha,
-        remoteSha256,
-        winner: "remote",
-        note: drifted ? "changed between diff and apply" : undefined,
-    }, onDisk);
-    if (preserved) {
-        if (localSha)
-            result.preservedLocalHashes.set(localSha, join(context.conflicts.setDir, path));
-        result.notices.push(`${path}: cloud version won; your bytes are preserved (summer cloud conflicts restore ${path})`);
-        // Sidecar bytes ride inside the conflict set for reference, never as a
-        // second conflict copy in the scanned tree (spec 8.4).
-        for (const suffix of [".import", ".uid"]) {
-            const sidecar = `${path}${suffix}`;
-            const sidecarOnDisk = context.diskPathByKey.get(sidecar) ?? join(projectRoot, sidecar);
-            await context.conflicts.preserve(sidecar, { winner: "remote", sidecar: true }, sidecarOnDisk);
-        }
-    }
-}
-async function mergeProjectGodotFromContext(projectRoot, path, decision, remote, context, result) {
-    const baseHash = context.base?.files[path]?.sha256;
-    const baseStaged = baseHash ? context.staged.get(baseHash) : undefined;
-    const remoteStaged = context.staged.get(remote.files[path].sha256);
-    const onDisk = context.diskPathByKey.get(path) ?? join(projectRoot, path);
-    if (!remoteStaged)
-        return false;
-    let baseText = "";
-    let localText = "";
-    let remoteText = "";
-    try {
-        baseText = baseStaged ? await readFile(baseStaged, "utf8") : "";
-        localText = await readFile(onDisk, "utf8");
-        remoteText = await readFile(remoteStaged, "utf8");
-    }
-    catch {
-        return false; // Fall through to whole-file remote-wins via the caller.
-    }
-    const merged = mergeProjectGodot(baseText, localText, remoteText);
-    if (merged.fallback) {
-        result.notices.push("project.godot: could not parse all three versions; cloud file won whole-file, local copy preserved");
-        return false;
-    }
-    for (const losing of merged.losingValues) {
-        const where = losing.section ? `[${losing.section}] ` : "";
-        result.notices.push(`project.godot: ${where}${losing.key}: cloud value won; local value was: ${losing.localValue}`);
-    }
-    const target = await containedProjectPath(projectRoot, path);
-    const tmp = join(dirname(target), `.${basename(target)}.summer-cloud-tmp`);
-    await writeFile(tmp, merged.merged, "utf8");
-    await renameWithRetry(tmp, target);
-    return true;
-}
-/**
- * Atomic placement from staging (spec 8.7): clear a read-only attribute on
- * the destination, then rename from staging into place (same volume). When
- * the same blob lands at several paths, all but the last use copy.
- */
-async function placeFromStaging(projectRoot, path, stagedPath, keepStaged, context) {
-    const target = await containedProjectPath(projectRoot, path);
-    await clearReadOnly(target);
-    // The walker's byte-name map may point at an NFD or different-case name for
-    // this key; replace that exact on-disk file so we never strand a twin.
-    const onDisk = context.diskPathByKey.get(path);
-    if (onDisk && onDisk !== target) {
-        await clearReadOnly(onDisk);
-        await rm(onDisk, { force: true });
-    }
-    if (keepStaged) {
-        const tmp = join(dirname(target), `.${basename(target)}.summer-cloud-tmp`);
-        await copyFile(stagedPath, tmp);
-        await renameWithRetry(tmp, target);
-    }
-    else {
-        await renameWithRetry(stagedPath, target);
-    }
-}
-async function clearReadOnly(path) {
-    try {
-        const info = await stat(path);
-        if ((info.mode & 0o200) === 0) {
-            await chmod(path, info.mode | 0o200);
-        }
-    }
-    catch {
-        // Missing file: nothing to clear.
-    }
-}
-/** Windows retry ladder (spec 8.7): EPERM/EBUSY/EACCES, 50 ms doubling, 7 tries. */
-async function renameWithRetry(from, to) {
-    let delay = RENAME_BACKOFF_MS;
-    for (let attempt = 0;; attempt += 1) {
-        try {
-            await rename(from, to);
-            return;
-        }
-        catch (err) {
-            const code = err.code;
-            const retryable = code === "EPERM" || code === "EBUSY" || code === "EACCES";
-            if (!retryable || attempt >= RENAME_RETRIES - 1)
-                throw err;
-            await sleep(delay);
-            delay *= 2;
-        }
-    }
-}
-async function applyCaseOnlyRenames(projectRoot, plan, remote, context, decisionByPath, result) {
-    const done = new Set();
-    const deleteByFold = new Map();
-    for (const path of plan.deleteLocalPaths)
-        deleteByFold.set(casefoldKey(path), path);
-    for (const pullPath of plan.pullPaths) {
-        const oldPath = deleteByFold.get(casefoldKey(pullPath));
-        if (!oldPath || oldPath === pullPath)
-            continue;
-        const oldDecision = decisionByPath.get(oldPath);
-        const remoteFile = remote.files[pullPath];
-        if (!remoteFile || oldDecision?.local?.sha256 !== remoteFile.sha256)
-            continue;
-        if (await driftedSinceDiff(projectRoot, oldPath, context))
-            continue;
-        const source = context.diskPathByKey.get(oldPath) ?? join(projectRoot, oldPath);
-        const target = await containedProjectPath(projectRoot, pullPath);
-        const tmp = join(dirname(target), `.${basename(target)}.summer-cloud-rename-tmp`);
-        try {
-            await renameWithRetry(source, tmp);
-            await renameWithRetry(tmp, target);
-        }
-        catch {
-            continue; // Fall back to download-and-delete handling for this pair.
-        }
-        done.add(pullPath);
-        done.add(oldPath);
-        result.appliedPaths.push(pullPath);
-    }
-    return done;
-}
-async function isSameFile(a, b) {
-    try {
-        const [ia, ib] = await Promise.all([stat(a, { bigint: true }), stat(b, { bigint: true })]);
-        return ia.dev === ib.dev && ia.ino === ib.ino;
-    }
-    catch {
-        return false;
-    }
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}

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

@@ -1,26 +0,0 @@
-export interface CheckpointResult {
-    ref: string;
-    commit: string;
-}
-export declare function summerGitDir(projectRoot: string): string;
-export declare function isGitAvailable(): Promise<boolean>;
-export declare function checkpointStamp(date?: Date): string;
-/**
- * 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 declare function createCheckpoint(projectRoot: string, projectId: string): Promise<CheckpointResult>;
-export declare function listCheckpoints(projectRoot: string, projectId: string): Promise<string[]>;
-export interface CheckpointRestoreResult {
-    ref: string;
-    restoredFiles: string[];
-    /** Files present on disk but not in the checkpoint; restore does not delete them. */
-    extraneousFiles: string[];
-}
-/**
- * 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 declare function restoreCheckpoint(projectRoot: string, projectId: string, refOrStamp: string, currentTrackedFiles: readonly string[]): Promise<CheckpointRestoreResult>;

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>;