@nowcrew/daemon 0.6.89 → 0.6.91-beta.1

package/dist/storage-safe-fs.js

@@ -1,302 +0,0 @@
-import { createRequire } from "node:module";
-import { closeSync, constants, fchmodSync, fstatSync, openSync, readdirSync, realpathSync, } from "node:fs";
-import { open } from "node:fs/promises";
-import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
-const AT_REMOVEDIR = process.platform === "darwin" ? 0x80 : 0x200;
-const DIRECTORY_FLAGS = constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW;
-const ENTRY_FLAGS = constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK;
-const DARWIN_TRANSIENT_MKDIR_ERRNO = 316;
-const MAX_TRANSIENT_MKDIR_RETRIES = 3;
-let cachedApi = null;
-function nativeApi() {
-    if (cachedApi !== null)
-        return cachedApi;
-    if (process.platform !== "linux" && process.platform !== "darwin") {
-        throw new Error("anchored storage filesystem operations are unsupported on this platform");
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- koffi has no bundled TypeScript declarations.
-    const koffi = createRequire(import.meta.url)("koffi");
-    const library = koffi.load(process.platform === "darwin" ? "libSystem.B.dylib" : "libc.so.6");
-    cachedApi = Object.freeze({
-        openat: library.func("int openat(int dirfd, const char *pathname, int flags, ...)"),
-        mkdirat: library.func("int mkdirat(int dirfd, const char *pathname, unsigned int mode)"),
-        unlinkat: library.func("int unlinkat(int dirfd, const char *pathname, int flags)"),
-        symlinkat: library.func("int symlinkat(const char *target, int dirfd, const char *pathname)"),
-        readlinkat: library.func("long readlinkat(int dirfd, const char *pathname, void *buffer, unsigned long size)"),
-        dup: library.func("int dup(int fd)"),
-        ...(process.platform === "darwin" ? {
-            getdirentries: library.func("long getdirentries(int fd, void *buffer, unsigned long size, void *basep)"),
-        } : {}),
-        errno: () => koffi.errno(),
-        errnoNames: new Map(Object.entries(koffi.os.errno).map(([name, code]) => [code, name])),
-    });
-    return cachedApi;
-}
-function nativeError(operation, api) {
-    const errno = api.errno();
-    return Object.assign(new Error(`${operation} failed: ${api.errnoNames.get(errno) ?? errno}`), {
-        code: api.errnoNames.get(errno) ?? "EIO",
-        errno,
-    });
-}
-function safeSegment(segment) {
-    if (segment.length === 0 || segment === "." || segment === ".." || /[\/\0\r\n]/u.test(segment)) {
-        throw new Error(`unsafe anchored path segment: ${segment}`);
-    }
-    return segment;
-}
-function absoluteSegments(path) {
-    if (!isAbsolute(path) || /[\0\r\n]/u.test(path))
-        throw new Error(`anchored path must be absolute: ${path}`);
-    const segments = resolve(path).split(sep).filter(Boolean).map(safeSegment);
-    if (segments.length === 0)
-        return segments;
-    const topLevel = `${sep}${segments[0]}`;
-    const canonicalTopLevel = realpathSync.native(topLevel);
-    return [...canonicalTopLevel.split(sep).filter(Boolean).map(safeSegment), ...segments.slice(1)];
-}
-function assertContained(root, target) {
-    const child = relative(resolve(root), resolve(target));
-    if (child === "" || child.startsWith(`..${sep}`) || child === ".." || isAbsolute(child)) {
-        throw new Error(`anchored storage target escapes root: ${target}`);
-    }
-}
-function openAt(api, parentFd, name, flags, mode = 0) {
-    const fd = api.openat(parentFd, safeSegment(name), flags, "uint32_t", mode);
-    if (fd < 0)
-        throw nativeError(`openat(${name})`, api);
-    return fd;
-}
-export function isTransientDirectoryCreateError(error) {
-    return error?.errno === DARWIN_TRANSIENT_MKDIR_ERRNO;
-}
-function mkdirAt(api, parentFd, name, mode) {
-    for (let attempt = 0; attempt <= MAX_TRANSIENT_MKDIR_RETRIES; attempt += 1) {
-        if (api.mkdirat(parentFd, safeSegment(name), mode) === 0)
-            return;
-        const error = nativeError(`mkdirat(${name})`, api);
-        if (error.code === "EEXIST")
-            return;
-        if (!isTransientDirectoryCreateError(error) || attempt === MAX_TRANSIENT_MKDIR_RETRIES)
-            throw error;
-    }
-}
-function unlinkAt(api, parentFd, name, flags) {
-    if (api.unlinkat(parentFd, safeSegment(name), flags) !== 0)
-        throw nativeError(`unlinkat(${name})`, api);
-}
-function openAbsoluteDirectory(path, create) {
-    const api = nativeApi();
-    let current = openSync("/", DIRECTORY_FLAGS);
-    try {
-        for (const segment of absoluteSegments(path)) {
-            if (create)
-                mkdirAt(api, current, segment, 0o700);
-            const next = openAt(api, current, segment, DIRECTORY_FLAGS);
-            closeSync(current);
-            current = next;
-        }
-        return current;
-    }
-    catch (error) {
-        closeSync(current);
-        throw error;
-    }
-}
-function descriptorPath(fd) {
-    return process.platform === "linux" ? `/proc/self/fd/${fd}` : `/dev/fd/${fd}`;
-}
-async function duplicateFileHandle(fd, flags) {
-    try {
-        return await open(descriptorPath(fd), flags);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export async function openAnchoredFile(path, flags = constants.O_RDONLY) {
-    const api = nativeApi();
-    const parent = openAbsoluteDirectory(dirname(path), false);
-    try {
-        const fd = openAt(api, parent, basename(path), flags | constants.O_NOFOLLOW);
-        return await duplicateFileHandle(fd, flags & constants.O_WRONLY ? constants.O_WRONLY : constants.O_RDONLY);
-    }
-    finally {
-        closeSync(parent);
-    }
-}
-export async function createAnchoredFile(root, path, mode, afterParentOpen) {
-    assertContained(root, path);
-    const api = nativeApi();
-    const parent = openAbsoluteDirectory(dirname(path), true);
-    try {
-        await afterParentOpen?.(path);
-        const fd = openAt(api, parent, basename(path), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, mode);
-        return await duplicateFileHandle(fd, constants.O_WRONLY);
-    }
-    finally {
-        closeSync(parent);
-    }
-}
-export function ensureAnchoredDirectory(root, path, mode = 0o700) {
-    if (resolve(root) !== resolve(path))
-        assertContained(root, path);
-    const fd = openAbsoluteDirectory(path, true);
-    try {
-        fchmodSync(fd, mode);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export function chmodAnchoredDirectory(root, path, mode) {
-    if (resolve(root) !== resolve(path))
-        assertContained(root, path);
-    const fd = openAbsoluteDirectory(path, false);
-    try {
-        fchmodSync(fd, mode);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function readlinkAt(api, parentFd, name) {
-    const buffer = Buffer.alloc(32768);
-    const size = api.readlinkat(parentFd, safeSegment(name), buffer, buffer.length);
-    if (size < 0)
-        throw nativeError(`readlinkat(${name})`, api);
-    return buffer.subarray(0, size).toString("utf8");
-}
-export function inspectAnchoredEntry(root, path) {
-    assertContained(root, path);
-    const api = nativeApi();
-    const parent = openAbsoluteDirectory(dirname(path), false);
-    const name = basename(path);
-    try {
-        let fd;
-        try {
-            fd = openAt(api, parent, name, ENTRY_FLAGS);
-        }
-        catch (error) {
-            if (error.code === "ELOOP") {
-                return Object.freeze({ kind: "symlink", linkTarget: readlinkAt(api, parent, name) });
-            }
-            throw error;
-        }
-        try {
-            const stats = fstatSync(fd);
-            return Object.freeze({
-                kind: stats.isDirectory() ? "directory" : stats.isFile() ? "file" : "other",
-                stats,
-            });
-        }
-        finally {
-            closeSync(fd);
-        }
-    }
-    finally {
-        closeSync(parent);
-    }
-}
-function removeChild(api, parentFd, name) {
-    let fd;
-    try {
-        fd = openAt(api, parentFd, name, ENTRY_FLAGS);
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === "ENOENT")
-            return;
-        if (code === "ELOOP") {
-            unlinkAt(api, parentFd, name, 0);
-            return;
-        }
-        throw error;
-    }
-    const stats = fstatSync(fd);
-    if (!stats.isDirectory()) {
-        closeSync(fd);
-        unlinkAt(api, parentFd, name, 0);
-        return;
-    }
-    try {
-        for (const name of readDirectoryNames(fd))
-            removeChild(api, fd, name);
-    }
-    finally {
-        closeSync(fd);
-    }
-    unlinkAt(api, parentFd, name, AT_REMOVEDIR);
-}
-function readDirectoryNames(fd) {
-    if (process.platform === "linux")
-        return readdirSync(descriptorPath(fd));
-    const api = nativeApi();
-    const duplicate = api.dup(fd);
-    if (duplicate < 0)
-        throw nativeError("dup(directory)", api);
-    const names = [];
-    try {
-        const buffer = Buffer.alloc(64 * 1024);
-        const base = Buffer.alloc(8);
-        for (;;) {
-            const size = api.getdirentries?.(duplicate, buffer, buffer.length, base) ?? -1;
-            if (size < 0)
-                throw nativeError("getdirentries", api);
-            if (size === 0)
-                return names;
-            let offset = 0;
-            while (offset < size) {
-                const recordLength = buffer.readUInt16LE(offset + 4);
-                const nameLength = buffer[offset + 7] ?? 0;
-                if (recordLength < 8 || offset + recordLength > size || nameLength > recordLength - 8) {
-                    throw new Error("getdirentries returned an invalid record");
-                }
-                const name = buffer.subarray(offset + 8, offset + 8 + nameLength).toString("utf8");
-                if (name !== "." && name !== "..")
-                    names.push(safeSegment(name));
-                offset += recordLength;
-            }
-        }
-    }
-    finally {
-        closeSync(duplicate);
-    }
-}
-export function removeAnchoredEntry(root, path) {
-    assertContained(root, path);
-    const api = nativeApi();
-    const parent = openAbsoluteDirectory(dirname(path), false);
-    try {
-        removeChild(api, parent, basename(path));
-    }
-    finally {
-        closeSync(parent);
-    }
-}
-export function createAnchoredSymlink(root, path, target) {
-    assertContained(root, path);
-    if (target.includes("\0"))
-        throw new Error("anchored symlink target contains NUL");
-    const api = nativeApi();
-    const parent = openAbsoluteDirectory(dirname(path), true);
-    try {
-        if (api.symlinkat(target, parent, safeSegment(basename(path))) !== 0) {
-            throw nativeError("symlinkat", api);
-        }
-    }
-    finally {
-        closeSync(parent);
-    }
-}
-export async function readAnchoredDirectory(root, path) {
-    if (resolve(root) !== resolve(path))
-        assertContained(root, path);
-    const fd = openAbsoluteDirectory(path, false);
-    try {
-        return readDirectoryNames(fd);
-    }
-    finally {
-        closeSync(fd);
-    }
-}

package/dist/storage-status-delivery.js

@@ -1,224 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { chmodSync, closeSync, constants, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
-import { dirname, isAbsolute } from "node:path";
-import { z } from "zod";
-const EventIdSchema = z.string().regex(/^[0-9a-f]{64}$/u);
-const AckSchema = z.object({
-    type: z.literal("server:storage-migration-status-ack"),
-    eventId: EventIdSchema,
-}).strict();
-const DeliveredFrameSchema = z.object({
-    type: z.literal("daemon:storage-migration-status"),
-    migrationId: z.string().uuid(),
-    status: z.enum([
-        "preflight_running", "preflight_passed", "backing_up", "initial_sync", "quiescing", "final_sync", "verified",
-        "service_switched", "hello_confirmed", "completed", "failed", "rollback_pending", "rolled_back",
-        "rollback_failed",
-    ]),
-    environment: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,31}$/u),
-    workspaceId: z.string().uuid(),
-    profile: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/u),
-    ownerEpoch: z.number().int().positive().safe().optional(),
-    ownershipClaimFingerprint: z.string().regex(/^sha256:[0-9a-f]{64}$/u).optional(),
-    sourceStorageFingerprint: z.string().optional(),
-    targetStorageFingerprint: z.string().optional(),
-    manifestDigest: z.string().optional(),
-    finalManifestDigest: z.string().optional(),
-    progress: z.object({
-        state: z.enum(["running", "stale"]),
-        scannedEntries: z.number().int().min(0).max(10_000_000),
-        totalEntries: z.number().int().min(0).max(10_000_000).optional(),
-    }).strict().optional(),
-    retryable: z.literal(true).optional(),
-    reopenAdmission: z.literal(true).optional(),
-    errorCode: z.string().optional(),
-    errorMessage: z.string().optional(),
-    eventId: EventIdSchema,
-}).strict();
-const OutboxSchema = z.object({
-    version: z.literal(1),
-    events: z.array(DeliveredFrameSchema).max(256),
-}).strict();
-const deliveredFrame = (raw) => Object.freeze(DeliveredFrameSchema.parse(raw));
-export function storageStatusEventId(frame) {
-    return createHash("sha256").update(JSON.stringify([
-        frame.migrationId,
-        frame.status,
-        frame.environment,
-        frame.workspaceId,
-        frame.profile,
-        frame.ownerEpoch ?? null,
-        frame.ownershipClaimFingerprint ?? null,
-        frame.sourceStorageFingerprint ?? null,
-        frame.targetStorageFingerprint ?? null,
-        frame.manifestDigest ?? null,
-        frame.finalManifestDigest ?? null,
-        frame.progress ?? null,
-        frame.retryable ?? null,
-        frame.errorCode ?? null,
-        frame.reopenAdmission ?? null,
-    ])).digest("hex");
-}
-function syncDirectory(path) {
-    const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
-    try {
-        fsyncSync(fd);
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-function durableReplace(path, content) {
-    const directory = dirname(path);
-    mkdirSync(directory, { recursive: true, mode: 0o700 });
-    chmodSync(directory, 0o700);
-    const temporary = `${path}.${randomUUID()}.tmp`;
-    let fd = null;
-    try {
-        fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
-        writeFileSync(fd, content, "utf8");
-        fsyncSync(fd);
-        closeSync(fd);
-        fd = null;
-        renameSync(temporary, path);
-        chmodSync(path, 0o600);
-        syncDirectory(directory);
-    }
-    finally {
-        if (fd !== null)
-            closeSync(fd);
-        rmSync(temporary, { force: true });
-    }
-}
-function durableRemove(path) {
-    try {
-        unlinkSync(path);
-        syncDirectory(dirname(path));
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-}
-function loadOutbox(path) {
-    if (path === undefined)
-        return new Map();
-    if (!isAbsolute(path) || /[\0\r\n]/u.test(path))
-        throw new Error("storage status outbox path must be absolute");
-    let raw;
-    try {
-        const metadata = lstatSync(path);
-        if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > 1024 * 1024) {
-            throw new Error("storage status outbox is not a bounded regular file");
-        }
-        raw = readFileSync(path, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return new Map();
-        throw error;
-    }
-    const parsed = OutboxSchema.parse(JSON.parse(raw));
-    const pending = new Map();
-    for (const event of parsed.events) {
-        const delivered = deliveredFrame(event);
-        if (storageStatusEventId(delivered) !== delivered.eventId) {
-            throw new Error("storage status outbox event identity mismatch");
-        }
-        // Progress is telemetry, not a durable obligation. Older versions could
-        // leave hundreds of progress frames behind and starve terminal statuses.
-        if (delivered.status === "preflight_running")
-            continue;
-        pending.set(delivered.eventId, delivered);
-    }
-    return pending;
-}
-export function createStorageStatusDelivery(input) {
-    const retryMs = z.number().int().min(5).max(60_000).parse(input.retryMs ?? 1_000);
-    const pending = loadOutbox(input.outboxPath);
-    const timers = new Map();
-    let stopped = false;
-    const persist = (events) => {
-        if (input.outboxPath === undefined)
-            return;
-        if (events.length === 0) {
-            durableRemove(input.outboxPath);
-            return;
-        }
-        durableReplace(input.outboxPath, `${JSON.stringify(OutboxSchema.parse({ version: 1, events }), null, 2)}\n`);
-    };
-    const schedule = (eventId) => {
-        if (stopped || timers.has(eventId))
-            return;
-        const timer = setTimeout(() => {
-            timers.delete(eventId);
-            const frame = pending.get(eventId);
-            if (frame === undefined || stopped)
-                return;
-            input.transmit(frame);
-            schedule(eventId);
-        }, retryMs);
-        timer.unref?.();
-        timers.set(eventId, timer);
-    };
-    const send = (frame) => {
-        const eventId = frame.eventId ?? storageStatusEventId(frame);
-        EventIdSchema.parse(eventId);
-        const delivered = deliveredFrame({ ...frame, eventId });
-        // A large manifest can emit thousands of progress updates. Send the
-        // latest telemetry opportunistically without putting it in the bounded
-        // durable outbox; terminal states remain durable and replayable.
-        if (delivered.status === "preflight_running") {
-            input.transmit(delivered);
-            return;
-        }
-        const existing = pending.get(eventId);
-        if (existing === undefined && pending.size >= 256) {
-            throw new Error("storage migration status outbox limit exceeded");
-        }
-        if (existing !== undefined && JSON.stringify(existing) === JSON.stringify(delivered)) {
-            schedule(eventId);
-            return;
-        }
-        const next = [...pending.values()].filter((candidate) => candidate.eventId !== eventId);
-        next.push(delivered);
-        persist(next);
-        pending.set(eventId, delivered);
-        input.transmit(delivered);
-        schedule(eventId);
-    };
-    const replayPending = () => {
-        for (const [eventId, frame] of pending) {
-            input.transmit(frame);
-            schedule(eventId);
-        }
-    };
-    const acknowledge = (raw) => {
-        const parsed = AckSchema.safeParse(raw);
-        if (!parsed.success)
-            return false;
-        if (!pending.has(parsed.data.eventId))
-            return true;
-        try {
-            persist([...pending.values()].filter((frame) => frame.eventId !== parsed.data.eventId));
-        }
-        catch (error) {
-            input.onPersistenceError?.(error);
-            return true;
-        }
-        pending.delete(parsed.data.eventId);
-        const timer = timers.get(parsed.data.eventId);
-        if (timer !== undefined)
-            clearTimeout(timer);
-        timers.delete(parsed.data.eventId);
-        return true;
-    };
-    const stop = () => {
-        stopped = true;
-        for (const timer of timers.values())
-            clearTimeout(timer);
-        timers.clear();
-        pending.clear();
-    };
-    return Object.freeze({ send, replayPending, acknowledge, stop, pendingCount: () => pending.size });
-}

package/dist/storage-status-replay.js

@@ -1,140 +0,0 @@
-import { readdir } from "node:fs/promises";
-import { readStorageMigrationReceipt, storageMigrationReplayStatuses, } from "./storage-migration-controller.js";
-import { readStorageWorkerFailureStatus, readStorageWorkerHeartbeat, } from "./storage-worker-status.js";
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-export async function latestSourceStorageMigrationReceipt(backupsRoot, expected) {
-    let entries;
-    try {
-        entries = await readdir(backupsRoot, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-    if (entries.length > 10_000)
-        throw new Error("storage migration receipt directory limit exceeded");
-    let latest = null;
-    for (const entry of entries) {
-        if (!entry.isDirectory() || !UUID.test(entry.name))
-            continue;
-        const receipt = await readStorageMigrationReceipt(backupsRoot, entry.name);
-        if (receipt === null || receipt.environment !== expected.environment || receipt.profile !== expected.profile)
-            continue;
-        const safeTerminal = receipt.status === "rolled_back"
-            || (receipt.status === "failed" && receipt.sourceStopAttempted === false);
-        if (!safeTerminal)
-            continue;
-        const at = new Date(receipt.history.at(-1)?.at ?? 0).getTime();
-        if (latest === null || at > latest.at)
-            latest = { receipt, at };
-    }
-    return latest?.receipt ?? null;
-}
-export function storageMigrationStatusReplay(receipt, expected) {
-    if (expected !== undefined && (receipt.migrationId !== expected.migrationId
-        || receipt.environment !== expected.environment
-        || receipt.workspaceId !== expected.workspaceId
-        || receipt.profile !== expected.profile
-        || (expected.ownerEpoch !== undefined && receipt.ownerEpoch !== expected.ownerEpoch)
-        || (expected.ownershipClaimFingerprint !== undefined
-            && receipt.ownershipClaimFingerprint !== expected.ownershipClaimFingerprint))) {
-        throw new Error("storage migration receipt identity mismatch");
-    }
-    return Object.freeze(storageMigrationReplayStatuses(receipt).map((status) => Object.freeze({
-        type: "daemon:storage-migration-status",
-        migrationId: receipt.migrationId,
-        status,
-        environment: receipt.environment,
-        workspaceId: receipt.workspaceId,
-        profile: receipt.profile,
-        ...(receipt.ownerEpoch === undefined ? {} : { ownerEpoch: receipt.ownerEpoch }),
-        ...(receipt.ownershipClaimFingerprint === undefined ? {} : {
-            ownershipClaimFingerprint: receipt.ownershipClaimFingerprint,
-        }),
-        ...(status === "verified" ? { finalManifestDigest: receipt.manifestDigest } : {}),
-        ...(status === "failed"
-            ? {
-                errorCode: receipt.errorCode ?? "storage_migration_failed",
-                ...(receipt.errorMessage === undefined ? {} : { errorMessage: receipt.errorMessage }),
-                ...(receipt.sourceStopAttempted === false ? { reopenAdmission: true } : {}),
-            }
-            : {}),
-    })));
-}
-const wait = (milliseconds) => new Promise((resolvePromise) => {
-    setTimeout(resolvePromise, milliseconds);
-});
-export async function monitorStorageMigrationStatus(input, send, injected = {}) {
-    const readReceipt = injected.readReceipt ?? readStorageMigrationReceipt;
-    const readWorkerFailure = injected.readWorkerFailure ?? readStorageWorkerFailureStatus;
-    const readWorkerHeartbeatStatus = injected.readWorkerHeartbeat ?? readStorageWorkerHeartbeat;
-    const now = injected.now ?? (() => new Date());
-    const delay = injected.delay ?? wait;
-    const pollIntervalMs = input.pollIntervalMs ?? 250;
-    const heartbeatTimeoutMs = input.workerHeartbeatTimeoutMs ?? 30_000;
-    const monitorStartedAt = now().getTime();
-    let sentCount = 0;
-    for (;;) {
-        const [receipt, failure] = await Promise.all([
-            readReceipt(input.backupsRoot, input.migrationId),
-            readWorkerFailure(input.stateRoot, input.migrationId),
-        ]);
-        if (receipt !== null) {
-            const frames = storageMigrationStatusReplay(receipt, input);
-            for (const frame of frames.slice(sentCount))
-                send(frame);
-            sentCount = frames.length;
-            if (receipt.status === "service_switched" || receipt.status === "completed") {
-                return { status: receipt.status, reopenAdmission: false };
-            }
-            if (receipt.status === "rolled_back")
-                return { status: "rolled_back", reopenAdmission: true };
-            if (receipt.status === "rollback_failed")
-                return { status: "rollback_failed", reopenAdmission: false };
-            if (receipt.status === "failed" && receipt.sourceStopAttempted === false) {
-                return { status: "failed", reopenAdmission: true };
-            }
-        }
-        if (failure !== null) {
-            const workerFailure = failure;
-            send({
-                type: "daemon:storage-migration-status",
-                migrationId: input.migrationId,
-                status: "failed",
-                environment: input.environment,
-                workspaceId: input.workspaceId,
-                profile: input.profile,
-                ...(input.ownerEpoch === undefined ? {} : { ownerEpoch: input.ownerEpoch }),
-                ...(input.ownershipClaimFingerprint === undefined ? {} : {
-                    ownershipClaimFingerprint: input.ownershipClaimFingerprint,
-                }),
-                errorCode: workerFailure.errorCode,
-                errorMessage: workerFailure.errorMessage,
-                ...(receipt?.sourceStopAttempted === false || receipt === null ? { reopenAdmission: true } : {}),
-            });
-            return { status: "failed", reopenAdmission: receipt?.sourceStopAttempted === false || receipt === null };
-        }
-        const heartbeat = await readWorkerHeartbeatStatus(input.stateRoot, input.migrationId);
-        const heartbeatAt = heartbeat === null ? monitorStartedAt : new Date(heartbeat.at).getTime();
-        if (now().getTime() - heartbeatAt > heartbeatTimeoutMs) {
-            send({
-                type: "daemon:storage-migration-status",
-                migrationId: input.migrationId,
-                status: "failed",
-                environment: input.environment,
-                workspaceId: input.workspaceId,
-                profile: input.profile,
-                ...(input.ownerEpoch === undefined ? {} : { ownerEpoch: input.ownerEpoch }),
-                ...(input.ownershipClaimFingerprint === undefined ? {} : {
-                    ownershipClaimFingerprint: input.ownershipClaimFingerprint,
-                }),
-                errorCode: "worker_heartbeat_stale_recovery_required",
-                errorMessage: "storage migration worker heartbeat expired; explicit recovery is required",
-                ...(receipt?.sourceStopAttempted === false || receipt === null ? { reopenAdmission: true } : {}),
-            });
-            return { status: "failed", reopenAdmission: receipt?.sourceStopAttempted === false || receipt === null };
-        }
-        await delay(pollIntervalMs);
-    }
-}