@xfey/tutti 0.1.61 → 0.1.63

package/dist/server-shell/local-console/package-update-process.js

@@ -0,0 +1,252 @@
+import { spawn } from "node:child_process";
+import { releasePackageUpdateLockForCurrentProcess, releasePackageUpdateLockForExpectedPid, transferPackageUpdateLockFromCurrentProcess, } from "./package-update-lock.js";
+import { PackageUpdateLogger, withPackageUpdateLogDescriptor } from "./package-update-log.js";
+import { updatePackageUpdateRuntimeRecord, } from "./package-update-record.js";
+import { parsePackageUpdateWorkerInput, runPackageUpdateWorker, } from "./package-update-worker.js";
+import { runPackageUpdateCompletion } from "./package-update-completion.js";
+const HANDSHAKE_TIMEOUT_MS = 10_000;
+export function buildHiddenPackageUpdateProcessPlan(options) {
+    return {
+        executable: options.input.installation.nodeExecutable,
+        args: [
+            options.input.cli_entrypoint,
+            "internal",
+            options.role === "worker" ? "package-update-worker" : "package-update-complete",
+        ],
+        cwd: options.input.tutti_home,
+        env: {
+            ...options.input.completion_environment,
+            TUTTI_HOME: options.input.tutti_home,
+        },
+        shell: false,
+    };
+}
+function sendProcessMessage(message) {
+    return new Promise((resolveSend, rejectSend) => {
+        if (process.send === undefined) {
+            rejectSend(new Error("Package update process IPC is unavailable."));
+            return;
+        }
+        process.send(message, (error) => {
+            if (error === null) {
+                resolveSend();
+            }
+            else {
+                rejectSend(error);
+            }
+        });
+    });
+}
+function sendChildMessage(child, message) {
+    return new Promise((resolveSend, rejectSend) => {
+        if (!child.connected || child.send === undefined) {
+            rejectSend(new Error("Package update child IPC is unavailable."));
+            return;
+        }
+        child.send(message, (error) => {
+            if (error === null) {
+                resolveSend();
+            }
+            else {
+                rejectSend(error);
+            }
+        });
+    });
+}
+function waitForChildMessage(child) {
+    return new Promise((resolveMessage, rejectMessage) => {
+        const timeout = setTimeout(() => {
+            cleanup();
+            rejectMessage(new Error("Package update child handshake timed out."));
+        }, HANDSHAKE_TIMEOUT_MS);
+        const onMessage = (message) => {
+            cleanup();
+            resolveMessage(message);
+        };
+        const onError = (error) => {
+            cleanup();
+            rejectMessage(error);
+        };
+        const onExit = () => {
+            cleanup();
+            rejectMessage(new Error("Package update child exited during handshake."));
+        };
+        const cleanup = () => {
+            clearTimeout(timeout);
+            child.off("message", onMessage);
+            child.off("error", onError);
+            child.off("exit", onExit);
+        };
+        child.once("message", onMessage);
+        child.once("error", onError);
+        child.once("exit", onExit);
+    });
+}
+function waitForProcessMessage() {
+    return new Promise((resolveMessage, rejectMessage) => {
+        const timeout = setTimeout(() => {
+            cleanup();
+            rejectMessage(new Error("Package update parent handshake timed out."));
+        }, HANDSHAKE_TIMEOUT_MS);
+        const onMessage = (message) => {
+            cleanup();
+            resolveMessage(message);
+        };
+        const onDisconnect = () => {
+            cleanup();
+            rejectMessage(new Error("Package update parent disconnected during handshake."));
+        };
+        const cleanup = () => {
+            clearTimeout(timeout);
+            process.off("message", onMessage);
+            process.off("disconnect", onDisconnect);
+        };
+        process.once("message", onMessage);
+        process.once("disconnect", onDisconnect);
+    });
+}
+function spawnHiddenPackageUpdateProcess(options) {
+    const plan = buildHiddenPackageUpdateProcessPlan(options);
+    return withPackageUpdateLogDescriptor(options.input.tutti_home, (descriptor) => spawn(plan.executable, plan.args, {
+        cwd: plan.cwd,
+        detached: true,
+        env: plan.env,
+        shell: plan.shell,
+        stdio: ["ignore", descriptor, descriptor, "ipc"],
+    }));
+}
+function disconnectAndUnref(child) {
+    child.unref();
+    child.channel?.unref();
+    if (child.connected) {
+        child.disconnect();
+    }
+}
+export async function spawnPackageUpdateWorkerProcess(options) {
+    const child = spawnHiddenPackageUpdateProcess({ input: options.input, role: "worker" });
+    let handedOff = false;
+    try {
+        const ready = await waitForChildMessage(child);
+        if (ready.kind !== "ready" || ready.role !== "worker") {
+            throw new Error("Package update worker returned an invalid readiness message.");
+        }
+        await sendChildMessage(child, { kind: "input", input: options.input });
+        const accepted = await waitForChildMessage(child);
+        if (accepted.kind !== "accepted" || accepted.role !== "worker") {
+            throw new Error("Package update worker rejected its internal input.");
+        }
+        if (child.pid === undefined) {
+            throw new Error("Package update worker did not expose a process id.");
+        }
+        options.lease.handoffTo(child.pid);
+        handedOff = true;
+        await sendChildMessage(child, { kind: "start" });
+        options.lease.release();
+        disconnectAndUnref(child);
+        return { pid: child.pid };
+    }
+    catch (error) {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // The worker already exited.
+        }
+        if (handedOff) {
+            options.lease.cancel();
+        }
+        else {
+            options.lease.release();
+        }
+        throw error;
+    }
+}
+async function startInstalledCompletion(input, record) {
+    const child = spawnHiddenPackageUpdateProcess({ input, role: "completion" });
+    let transferred = false;
+    try {
+        const ready = await waitForChildMessage(child);
+        if (ready.kind !== "ready" || ready.role !== "completion" || child.pid === undefined) {
+            throw new Error("Installed package completion did not become ready.");
+        }
+        updatePackageUpdateRuntimeRecord({
+            tuttiHome: input.tutti_home,
+            current: record,
+            phase: "restarting",
+            updaterPid: child.pid,
+        });
+        if (!transferPackageUpdateLockFromCurrentProcess({
+            tuttiHome: input.tutti_home,
+            nextPid: child.pid,
+        })) {
+            throw new Error("Package update lock could not be handed to completion.");
+        }
+        transferred = true;
+        await sendChildMessage(child, { kind: "start" });
+        disconnectAndUnref(child);
+    }
+    catch (error) {
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            // The completion process already exited.
+        }
+        if (transferred && child.pid !== undefined) {
+            releasePackageUpdateLockForExpectedPid(input.tutti_home, child.pid);
+        }
+        throw error;
+    }
+}
+export async function runPackageUpdateWorkerProtocol() {
+    await sendProcessMessage({ kind: "ready", role: "worker" });
+    let input = null;
+    try {
+        const message = await waitForProcessMessage();
+        input = message.kind === "input" ? parsePackageUpdateWorkerInput(message.input) : null;
+        if (input === null) {
+            await sendProcessMessage({ kind: "rejected", role: "worker" });
+            return;
+        }
+        await sendProcessMessage({ kind: "accepted", role: "worker" });
+        const start = await waitForProcessMessage();
+        if (start.kind !== "start") {
+            throw new Error("Package update worker did not receive its start signal.");
+        }
+        await runPackageUpdateWorker(input, {
+            startCompletion: startInstalledCompletion,
+        });
+    }
+    catch (error) {
+        if (input !== null) {
+            new PackageUpdateLogger({
+                tuttiHome: input.tutti_home,
+                privatePaths: [input.tutti_home, input.installation.packageRoot],
+            }).append({
+                level: "error",
+                message: "Package update worker crashed.",
+                reasonCode: "worker_crashed",
+            });
+            releasePackageUpdateLockForCurrentProcess(input.tutti_home);
+        }
+        throw error;
+    }
+}
+export async function runPackageUpdateCompletionProtocol() {
+    await sendProcessMessage({ kind: "ready", role: "completion" });
+    const start = await waitForProcessMessage();
+    if (start.kind !== "start") {
+        throw new Error("Package update completion did not receive its start signal.");
+    }
+    const tuttiHome = process.env.TUTTI_HOME;
+    const cliEntrypoint = process.argv[1];
+    if (tuttiHome === undefined || cliEntrypoint === undefined) {
+        throw new Error("Package update completion environment is unavailable.");
+    }
+    await runPackageUpdateCompletion({
+        tuttiHome,
+        cliEntrypoint,
+        env: process.env,
+    });
+}
+//# sourceMappingURL=package-update-process.js.map

package/dist/server-shell/local-console/package-update-record.d.ts

@@ -0,0 +1,53 @@
+import { type ProjectId } from "@tutti/shared/ids";
+export type PackageUpdateRuntimePhase = "preparing" | "stopping_hosts" | "installing" | "restarting" | "failed";
+export type PackageUpdateRuntimeRecord = {
+    schema_version: 1;
+    source_version: string;
+    target_version: string;
+    phase: PackageUpdateRuntimePhase;
+    restore_project_ids: ProjectId[];
+    updater_pid: number;
+    started_at: string;
+    updated_at: string;
+    failure_reason_code?: string;
+    restart_failure_count?: number;
+};
+export type PackageUpdateRuntimeRecordRead = {
+    status: "missing";
+} | {
+    status: "valid";
+    record: PackageUpdateRuntimeRecord;
+} | {
+    status: "invalid";
+};
+export type PackageUpdateCompletionResult = {
+    source_version: string;
+    target_version: string;
+    restart_failure_count: number;
+};
+export declare function packageUpdateRuntimeRecordPath(tuttiHome: string): string;
+export declare function readPackageUpdateRuntimeRecord(options: {
+    tuttiHome: string;
+    now?: () => number;
+    maxAgeMs?: number;
+}): PackageUpdateRuntimeRecordRead;
+export declare function writePackageUpdateRuntimeRecord(tuttiHome: string, record: PackageUpdateRuntimeRecord): void;
+export declare function deletePackageUpdateRuntimeRecord(options: {
+    tuttiHome: string;
+    expectedTargetVersion?: string;
+    expectedUpdaterPid?: number;
+}): boolean;
+export declare function updatePackageUpdateRuntimeRecord(options: {
+    tuttiHome: string;
+    current: PackageUpdateRuntimeRecord;
+    phase: PackageUpdateRuntimePhase;
+    now?: () => Date;
+    updaterPid?: number;
+    failureReasonCode?: string;
+    restartFailureCount?: number;
+}): PackageUpdateRuntimeRecord;
+export declare function consumePackageUpdateCompletion(options: {
+    tuttiHome: string;
+    currentVersion: string;
+}): PackageUpdateCompletionResult | undefined;
+//# sourceMappingURL=package-update-record.d.ts.map

package/dist/server-shell/local-console/package-update-record.js

@@ -0,0 +1,180 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
+import { compareExactSemver, parseExactSemver } from "../package-installation/index.js";
+const DEFAULT_MAX_RECORD_AGE_MS = 24 * 60 * 60 * 1_000;
+const RECORD_KEYS = [
+    "failure_reason_code",
+    "phase",
+    "restart_failure_count",
+    "restore_project_ids",
+    "schema_version",
+    "source_version",
+    "started_at",
+    "target_version",
+    "updated_at",
+    "updater_pid",
+];
+export function packageUpdateRuntimeRecordPath(tuttiHome) {
+    return join(tuttiHome, "runtime", "package-update.json");
+}
+function isIsoTimestamp(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function isStableReason(value) {
+    return typeof value === "string" && /^[a-z][a-z0-9_]{0,79}$/u.test(value);
+}
+function parseRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const candidate = value;
+    if (Object.keys(candidate).some((key) => !RECORD_KEYS.includes(key))) {
+        return null;
+    }
+    const source = parseExactSemver(candidate.source_version);
+    const target = parseExactSemver(candidate.target_version);
+    const phases = [
+        "preparing",
+        "stopping_hosts",
+        "installing",
+        "restarting",
+        "failed",
+    ];
+    if (candidate.schema_version !== 1 ||
+        source === null ||
+        target === null ||
+        compareExactSemver(target, source) <= 0 ||
+        !phases.includes(candidate.phase) ||
+        !Array.isArray(candidate.restore_project_ids) ||
+        !candidate.restore_project_ids.every((projectId) => typeof projectId === "string" && isPrefixedId(projectId, ID_PREFIXES.project)) ||
+        new Set(candidate.restore_project_ids).size !== candidate.restore_project_ids.length ||
+        !Number.isInteger(candidate.updater_pid) ||
+        candidate.updater_pid <= 0 ||
+        !isIsoTimestamp(candidate.started_at) ||
+        !isIsoTimestamp(candidate.updated_at) ||
+        Date.parse(candidate.updated_at) < Date.parse(candidate.started_at) ||
+        (candidate.failure_reason_code !== undefined &&
+            !isStableReason(candidate.failure_reason_code)) ||
+        (candidate.restart_failure_count !== undefined &&
+            (!Number.isInteger(candidate.restart_failure_count) ||
+                candidate.restart_failure_count < 0))) {
+        return null;
+    }
+    return {
+        schema_version: 1,
+        source_version: source,
+        target_version: target,
+        phase: candidate.phase,
+        restore_project_ids: [...candidate.restore_project_ids].sort(),
+        updater_pid: candidate.updater_pid,
+        started_at: candidate.started_at,
+        updated_at: candidate.updated_at,
+        ...(candidate.failure_reason_code === undefined
+            ? {}
+            : { failure_reason_code: candidate.failure_reason_code }),
+        ...(candidate.restart_failure_count === undefined
+            ? {}
+            : { restart_failure_count: candidate.restart_failure_count }),
+    };
+}
+export function readPackageUpdateRuntimeRecord(options) {
+    const path = packageUpdateRuntimeRecordPath(options.tuttiHome);
+    if (!existsSync(path)) {
+        return { status: "missing" };
+    }
+    try {
+        const record = parseRecord(JSON.parse(readFileSync(path, "utf8")));
+        if (record === null ||
+            (options.now ?? Date.now)() - Date.parse(record.updated_at) >
+                (options.maxAgeMs ?? DEFAULT_MAX_RECORD_AGE_MS)) {
+            return { status: "invalid" };
+        }
+        return { status: "valid", record };
+    }
+    catch {
+        return { status: "invalid" };
+    }
+}
+export function writePackageUpdateRuntimeRecord(tuttiHome, record) {
+    const parsed = parseRecord(record);
+    if (parsed === null) {
+        throw new Error("Package update runtime record is invalid.");
+    }
+    const path = packageUpdateRuntimeRecordPath(tuttiHome);
+    const directory = dirname(path);
+    const temporaryPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    chmodSync(directory, 0o700);
+    try {
+        writeFileSync(temporaryPath, `${JSON.stringify(parsed)}\n`, { encoding: "utf8", mode: 0o600 });
+        chmodSync(temporaryPath, 0o600);
+        renameSync(temporaryPath, path);
+        chmodSync(path, 0o600);
+    }
+    finally {
+        try {
+            unlinkSync(temporaryPath);
+        }
+        catch {
+            // Atomic rename normally removes the temporary path.
+        }
+    }
+}
+export function deletePackageUpdateRuntimeRecord(options) {
+    const read = readPackageUpdateRuntimeRecord({ tuttiHome: options.tuttiHome });
+    if (read.status === "missing") {
+        return true;
+    }
+    if (read.status !== "valid" ||
+        (options.expectedTargetVersion !== undefined &&
+            read.record.target_version !== options.expectedTargetVersion) ||
+        (options.expectedUpdaterPid !== undefined &&
+            read.record.updater_pid !== options.expectedUpdaterPid)) {
+        return false;
+    }
+    try {
+        unlinkSync(packageUpdateRuntimeRecordPath(options.tuttiHome));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function updatePackageUpdateRuntimeRecord(options) {
+    const updated = {
+        ...options.current,
+        phase: options.phase,
+        updater_pid: options.updaterPid ?? options.current.updater_pid,
+        updated_at: (options.now ?? (() => new Date()))().toISOString(),
+        ...(options.failureReasonCode === undefined
+            ? {}
+            : { failure_reason_code: options.failureReasonCode }),
+        ...(options.restartFailureCount === undefined
+            ? {}
+            : { restart_failure_count: options.restartFailureCount }),
+    };
+    writePackageUpdateRuntimeRecord(options.tuttiHome, updated);
+    return updated;
+}
+export function consumePackageUpdateCompletion(options) {
+    const read = readPackageUpdateRuntimeRecord({ tuttiHome: options.tuttiHome });
+    if (read.status !== "valid" ||
+        read.record.phase !== "restarting" ||
+        read.record.target_version !== options.currentVersion ||
+        read.record.restart_failure_count === undefined) {
+        return undefined;
+    }
+    if (!deletePackageUpdateRuntimeRecord({
+        tuttiHome: options.tuttiHome,
+        expectedTargetVersion: read.record.target_version,
+    })) {
+        return undefined;
+    }
+    return {
+        source_version: read.record.source_version,
+        target_version: read.record.target_version,
+        restart_failure_count: read.record.restart_failure_count,
+    };
+}
+//# sourceMappingURL=package-update-record.js.map

package/dist/server-shell/local-console/package-update-recovery.d.ts

@@ -0,0 +1,34 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type PackageUpdateLockAcquisition, type PackageUpdateLockInspection } from "./package-update-lock.js";
+import { type PackageUpdateRuntimeRecord, type PackageUpdateRuntimeRecordRead } from "./package-update-record.js";
+export type PackageUpdateStartupRecoveryResult = {
+    status: "continue";
+} | {
+    status: "completed";
+    url: string;
+    restart_failure_count: number;
+};
+type HostRestoreResult = {
+    restored_project_ids: ProjectId[];
+    failed_project_ids: ProjectId[];
+};
+export declare function recoverPackageUpdateForConsoleStartup(options: {
+    tuttiHome: string;
+    cliEntrypoint: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    source: "terminal" | "desktop";
+    currentVersion?: string;
+    readRecord?: () => PackageUpdateRuntimeRecordRead;
+    inspectLock?: () => PackageUpdateLockInspection;
+    removeRecoverableLock?: () => boolean;
+    acquireLock?: () => PackageUpdateLockAcquisition;
+    restoreHosts?: (record: PackageUpdateRuntimeRecord) => Promise<HostRestoreResult>;
+    deleteRecord?: (record: PackageUpdateRuntimeRecord) => boolean;
+    ensureConsole?: () => Promise<{
+        url: string;
+    }>;
+    now?: () => Date;
+}): Promise<PackageUpdateStartupRecoveryResult>;
+export {};
+//# sourceMappingURL=package-update-recovery.d.ts.map

package/dist/server-shell/local-console/package-update-recovery.js

@@ -0,0 +1,140 @@
+import { readCliVersion } from "../cli/version.js";
+import { ensureLocalConsole } from "./managed-console.js";
+import { runPackageUpdateCompletion } from "./package-update-completion.js";
+import { restorePackageUpdateHosts } from "./package-update-hosts.js";
+import { inspectPackageUpdateLock, removeRecoverablePackageUpdateLock, tryAcquirePackageUpdateLock, } from "./package-update-lock.js";
+import { PackageUpdateLogger } from "./package-update-log.js";
+import { deletePackageUpdateRuntimeRecord, readPackageUpdateRuntimeRecord, updatePackageUpdateRuntimeRecord, } from "./package-update-record.js";
+export async function recoverPackageUpdateForConsoleStartup(options) {
+    const currentVersion = options.currentVersion ?? readCliVersion();
+    const readRecord = options.readRecord ?? (() => readPackageUpdateRuntimeRecord({ tuttiHome: options.tuttiHome }));
+    const initialRecord = readRecord();
+    if (initialRecord.status !== "valid" || initialRecord.record.phase === "failed") {
+        return { status: "continue" };
+    }
+    const inspectLock = options.inspectLock ?? (() => inspectPackageUpdateLock({ tuttiHome: options.tuttiHome }));
+    const lockState = inspectLock();
+    if (lockState.status === "active") {
+        return { status: "continue" };
+    }
+    if (lockState.status === "recovery_required") {
+        const removed = (options.removeRecoverableLock ??
+            (() => removeRecoverablePackageUpdateLock({ tuttiHome: options.tuttiHome })))();
+        if (!removed) {
+            return { status: "continue" };
+        }
+    }
+    const acquisition = (options.acquireLock ?? (() => tryAcquirePackageUpdateLock({ tuttiHome: options.tuttiHome })))();
+    if (acquisition.status !== "acquired") {
+        return { status: "continue" };
+    }
+    const logger = new PackageUpdateLogger({
+        tuttiHome: options.tuttiHome,
+        privatePaths: [options.tuttiHome],
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    const log = (entry) => {
+        try {
+            logger.append(entry);
+        }
+        catch {
+            // Recovery correctness must not depend on the diagnostic log.
+        }
+    };
+    let lockReleased = false;
+    const releaseLock = () => {
+        if (!lockReleased) {
+            lockReleased = true;
+            acquisition.lease.release();
+        }
+        return true;
+    };
+    const current = readRecord();
+    if (current.status !== "valid" || current.record.phase === "failed") {
+        releaseLock();
+        return { status: "continue" };
+    }
+    const record = current.record;
+    const restoreHosts = options.restoreHosts ??
+        ((value) => restorePackageUpdateHosts({
+            tuttiHome: options.tuttiHome,
+            projectIds: value.restore_project_ids,
+            env: options.env,
+        }));
+    if (record.source_version === currentVersion) {
+        let restored;
+        try {
+            restored = await restoreHosts(record);
+        }
+        catch {
+            restored = {
+                restored_project_ids: [],
+                failed_project_ids: [...record.restore_project_ids],
+            };
+        }
+        const deleted = (options.deleteRecord ??
+            ((value) => deletePackageUpdateRuntimeRecord({
+                tuttiHome: options.tuttiHome,
+                expectedTargetVersion: value.target_version,
+                expectedUpdaterPid: value.updater_pid,
+            })))(record);
+        releaseLock();
+        const recoveryIncomplete = restored.failed_project_ids.length > 0 || !deleted;
+        log({
+            level: restored.failed_project_ids.length === 0 && deleted ? "info" : "warn",
+            message: restored.failed_project_ids.length === 0 && deleted
+                ? "Recovered an interrupted package update using the source CLI."
+                : "Package update source recovery requires follow-up.",
+            ...(recoveryIncomplete ? { reasonCode: "update_recovery_required" } : {}),
+        });
+        return { status: "continue" };
+    }
+    if (record.target_version !== currentVersion) {
+        releaseLock();
+        return { status: "continue" };
+    }
+    const completionRecord = updatePackageUpdateRuntimeRecord({
+        tuttiHome: options.tuttiHome,
+        current: record,
+        phase: "restarting",
+        updaterPid: process.pid,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    let consoleUrl;
+    try {
+        const completion = await runPackageUpdateCompletion({
+            tuttiHome: options.tuttiHome,
+            cliEntrypoint: options.cliEntrypoint,
+            env: options.env,
+            currentVersion,
+            logger,
+            restoreHosts: async () => await restoreHosts(completionRecord),
+            ensureConsole: async () => {
+                const result = await (options.ensureConsole ??
+                    (() => ensureLocalConsole({
+                        cwd: options.cwd,
+                        env: options.env,
+                        source: options.source,
+                    })))();
+                consoleUrl = result.url;
+                return result;
+            },
+            openBrowser: () => false,
+            releaseLock,
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+        if (consoleUrl === undefined) {
+            throw new Error("Recovered package update did not start a Local Console.");
+        }
+        return {
+            status: "completed",
+            url: consoleUrl,
+            restart_failure_count: completion.restart_failure_count,
+        };
+    }
+    catch {
+        releaseLock();
+        return { status: "continue" };
+    }
+}
+//# sourceMappingURL=package-update-recovery.js.map