@nowcrew/daemon 0.6.77 → 0.6.79-beta.1

package/dist/storage-ownership.js

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+const FingerprintSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/u);
+const StorageOwnershipClaimSchema = z.object({
+    version: z.literal(1),
+    machineId: z.string().uuid(),
+    workspaceId: z.string().uuid(),
+    environment: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,31}$/u),
+    volumeFingerprint: FingerprintSchema,
+    workspaceRootFingerprint: FingerprintSchema,
+    ownerEpoch: z.number().int().positive().safe(),
+    claimFingerprint: FingerprintSchema,
+}).strict();
+function claimFingerprint(identity) {
+    const digest = createHash("sha256").update([
+        "nowwork-storage-ownership-v1",
+        identity.machineId,
+        identity.workspaceId,
+        identity.environment,
+        identity.volumeFingerprint,
+        identity.workspaceRootFingerprint,
+        String(identity.ownerEpoch),
+    ].join("\0")).digest("hex");
+    return `sha256:${digest}`;
+}
+export function createStorageOwnershipClaim(input) {
+    const parsed = StorageOwnershipClaimSchema.omit({ version: true, claimFingerprint: true }).parse(input);
+    const identity = Object.freeze({
+        ...parsed,
+        machineId: parsed.machineId.toLowerCase(),
+        workspaceId: parsed.workspaceId.toLowerCase(),
+        environment: parsed.environment.toLowerCase(),
+    });
+    return Object.freeze({ ...identity, claimFingerprint: claimFingerprint(identity) });
+}
+export function storageOwnershipClaimPath(nowworkHome) {
+    return join(nowworkHome, "storage-layout.json");
+}
+export async function readStorageOwnershipClaim(nowworkHome) {
+    const path = storageOwnershipClaimPath(nowworkHome);
+    const metadata = await lstat(path);
+    if (!metadata.isFile())
+        throw new Error("storage ownership claim must be a file");
+    if (metadata.size > 16 * 1024)
+        throw new Error("storage ownership claim file is too large");
+    const parsed = StorageOwnershipClaimSchema.parse(JSON.parse(await readFile(path, "utf8")));
+    const { version: _version, claimFingerprint: reportedFingerprint, ...identity } = parsed;
+    const expected = createStorageOwnershipClaim(identity);
+    if (reportedFingerprint !== expected.claimFingerprint) {
+        throw new Error("storage ownership claim fingerprint is invalid");
+    }
+    return expected;
+}

package/dist/storage-runtime-controller.js

@@ -23,9 +23,10 @@ function deterministicUuid(value) {
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 function storageId(input, workspaceId) {
-    return `storage_${createHash("sha256").update([
-        input.serverUrl.replace(/\/+$/u, ""), input.profile, workspaceId, input.nowworkHome,
-    ].join("\0")).digest("hex").slice(0, 32)}`;
+    if (input.ownership.workspaceId !== workspaceId || input.ownership.environment !== input.environment) {
+        throw new Error("Storage ownership claim does not match the migration identity");
+    }
+    return `storage_${input.ownership.claimFingerprint.slice("sha256:".length)}`;
 }
 function installationBase(input, workspaceId, migrationId, createdAt) {
     const layout = storageLayout({
@@ -102,6 +103,7 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
         ...injected,
     };
     let workspaceId = null;
+    let machineId = null;
     let identity;
     let gate = null;
     let sendStatus = null;
@@ -194,6 +196,10 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
                 targetWorkspaceRoot: target.workspaceRoot,
                 backupsRoot: input.local.backupsRoot,
                 backupArtifacts: input.backupArtifacts.map((artifact) => ({ ...artifact })),
+                ownership: {
+                    ownerEpoch: input.ownership.ownerEpoch,
+                    ownershipClaimFingerprint: input.ownership.claimFingerprint,
+                },
                 acceptedWarnings: [...input.policy.acceptedWarnings],
             },
             service: {
@@ -229,6 +235,10 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
             profile: input.profile,
             sourceStorageFingerprint,
             targetStorageFingerprint: identity.storageIdFingerprint,
+            ownership: {
+                ownerEpoch: input.ownership.ownerEpoch,
+                ownershipClaimFingerprint: input.ownership.claimFingerprint,
+            },
             runDoctor: async (migrationId) => dependencies.runDoctor(await doctorInput(migrationId)),
             runMigration: async (doctor) => {
                 await gate.closeAndFlush();
@@ -264,6 +274,7 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
                         environment: operation.environment,
                         workspaceId: operation.workspaceId,
                         profile: operation.profile,
+                        ...(operation.migration.ownership === undefined ? {} : operation.migration.ownership),
                     }, sendStatus);
                     if (outcome.reopenAdmission)
                         gate.reopen();
@@ -285,20 +296,31 @@ export function createStorageMigrationRuntimeController(rawInput, injected = {})
     };
     const bindServerIdentity = (server) => {
         const nextWorkspaceId = UUID.parse(server.workspaceId).toLowerCase();
+        const nextMachineId = UUID.parse(server.machineId).toLowerCase();
         if (workspaceId !== null && workspaceId !== nextWorkspaceId) {
             throw new Error("Storage migration server workspace identity changed");
         }
-        workspaceId = nextWorkspaceId;
+        if (machineId !== null && machineId !== nextMachineId) {
+            throw new Error("Storage migration server machine identity changed");
+        }
+        if (input.ownership.workspaceId !== nextWorkspaceId
+            || input.ownership.machineId !== nextMachineId
+            || input.ownership.environment !== input.environment) {
+            throw new Error("Storage ownership claim does not match authenticated server identity");
+        }
         const createdAt = dependencies.now().toISOString();
-        const installation = installationBase(input, workspaceId, undefined, createdAt);
+        const installation = installationBase(input, nextWorkspaceId, undefined, createdAt);
         const layout = storageLayout({
             nowworkHome: input.nowworkHome,
             environment: input.environment,
-            workspaceId,
+            workspaceId: nextWorkspaceId,
             runtimeBase: input.local.runtimeBase,
             platform: input.platform,
         });
-        identity = storageHelloIdentity({ installation, layout });
+        const nextIdentity = storageHelloIdentity({ installation, layout, ownership: input.ownership });
+        workspaceId = nextWorkspaceId;
+        machineId = nextMachineId;
+        identity = nextIdentity;
         ensureControl();
         drainPendingControlMessages();
     };

package/dist/storage-runtime-readiness.js

@@ -5,10 +5,12 @@ import { buildServiceSpec } from "./computer-service.js";
 import { profilePath } from "./computer-profile.js";
 import { assertManagedServiceIdentity } from "./managed-service-lifecycle.js";
 import { managedServiceRegistryPath, readManagedServiceRegistry, } from "./managed-service-registry.js";
-import { resolveLocalStorageRoots } from "./storage-config.js";
+import { installationsPath, resolveLocalStorageRoots } from "./storage-config.js";
 import { readStorageMigrationPolicy } from "./storage-migration-policy.js";
 import { createStorageMigrationRuntimeController, } from "./storage-runtime-controller.js";
 import { resolveEnvTag, resolveNowworkHome } from "./storage-layout.js";
+import { readStorageOwnershipClaim } from "./storage-ownership.js";
+import { resolveDaemonLocalStateRoot } from "./daemon-local-home.js";
 const notReady = (reason) => Object.freeze({ ready: false, reason });
 function canonicalPath(value) {
     const absolute = resolve(value);
@@ -73,6 +75,12 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
         serverUrl: z.string().url().parse(rawInput.serverUrl),
         platform: rawInput.platform,
     };
+    const localHome = resolveDaemonLocalStateRoot({
+        userHome: rawInput.userHome,
+        platform: rawInput.platform,
+        explicit: rawInput.environment.NOWWORK_LOCAL_HOME,
+        mode: rawInput.environment.NOWWORK_LOCAL_HOME_MODE ?? rawInput.environment.NOWWORK_STORAGE_MODE,
+    });
     let nowworkHome;
     let environment;
     try {
@@ -106,11 +114,12 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
         assertManagedServiceIdentity,
         readPolicy: readStorageMigrationPolicy,
         createController: createStorageMigrationRuntimeController,
+        readOwnership: readStorageOwnershipClaim,
         ...injected,
     };
     let sourceRecord;
     try {
-        const records = await dependencies.readManagedServices({ userHome: input.userHome });
+        const records = await dependencies.readManagedServices({ userHome: input.userHome, localHome });
         const found = findSourceRecord(records, input);
         if (found === null)
             return notReady("source_service_record_missing");
@@ -132,7 +141,7 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
     const assertSourceIdentity = () => dependencies.assertManagedServiceIdentity({
         spec: sourceSpec,
         record: sourceRecord,
-        registry: { userHome: input.userHome },
+        registry: { userHome: input.userHome, localHome },
     });
     try {
         await assertSourceIdentity();
@@ -153,6 +162,17 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
     catch {
         return notReady("migration_policy_invalid");
     }
+    let ownership;
+    try {
+        ownership = await dependencies.readOwnership(nowworkHome);
+    }
+    catch (error) {
+        return notReady(error.code === "ENOENT"
+            ? "storage_ownership_claim_missing"
+            : "storage_ownership_claim_invalid");
+    }
+    if (ownership.environment !== environment)
+        return notReady("storage_ownership_claim_invalid");
     const local = resolveLocalStorageRoots({
         platform: input.platform,
         userHome: input.userHome,
@@ -169,6 +189,7 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
         sourceRecord,
         local,
         policy,
+        ownership,
         serviceEnvironment: {
             NOWWORK_HOME: nowworkHome,
             NOWWORK_ENV_TAG: environment,
@@ -177,7 +198,8 @@ export async function probeStorageMigrationRuntime(rawInput, injected = {}) {
         backupArtifacts: [
             { name: "profile.json", path: profilePath(input.profile, input.currentDaemonHome) },
             { name: "service-descriptor", path: sourceRecord.descriptorPath },
-            { name: "managed-service-registry.json", path: managedServiceRegistryPath(input.userHome) },
+            { name: "managed-service-registry.json", path: managedServiceRegistryPath(input.userHome, localHome) },
+            { name: "installations.json", path: installationsPath(local.configRoot) },
         ],
     }, { assertSourceIdentity });
     return Object.freeze({ ready: true, runtime });

package/dist/storage-runtime.js

@@ -1,6 +1,7 @@
 import { findInstallationForProfile, readInstallations, resolveLocalStorageRoots, } from "./storage-config.js";
 import { storageHelloIdentity } from "./storage-identity.js";
 import { storageLayout } from "./storage-layout.js";
+import { readStorageOwnershipClaim } from "./storage-ownership.js";
 const canonicalServerUrl = (value) => value.replace(/\/+$/u, "");
 export function resolveStorageRuntime(input) {
     const installation = findInstallationForProfile(input.records, input.profile);
@@ -24,7 +25,11 @@ export function resolveStorageRuntime(input) {
     return Object.freeze({
         installation,
         layout,
-        identity: storageHelloIdentity({ installation, layout }),
+        identity: storageHelloIdentity({
+            installation,
+            layout,
+            ...(input.ownership === undefined ? {} : { ownership: input.ownership }),
+        }),
         local,
     });
 }
@@ -35,5 +40,16 @@ export async function loadStorageRuntime(input) {
         environment: input.environment,
     });
     const records = await readInstallations({ configRoot: local.configRoot });
-    return resolveStorageRuntime({ ...input, records });
+    const baseline = resolveStorageRuntime({ ...input, records });
+    if (baseline === null)
+        return null;
+    let ownership;
+    try {
+        ownership = await readStorageOwnershipClaim(baseline.layout.persistentRoot);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    return ownership === undefined ? baseline : resolveStorageRuntime({ ...input, records, ownership });
 }

package/dist/storage-status-delivery.js

@@ -18,6 +18,8 @@ const DeliveredFrameSchema = z.object({
     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(),
@@ -45,6 +47,8 @@ export function storageStatusEventId(frame) {
         frame.environment,
         frame.workspaceId,
         frame.profile,
+        frame.ownerEpoch ?? null,
+        frame.ownershipClaimFingerprint ?? null,
         frame.sourceStorageFingerprint ?? null,
         frame.targetStorageFingerprint ?? null,
         frame.manifestDigest ?? null,

package/dist/storage-status-replay.js

@@ -35,7 +35,10 @@ export function storageMigrationStatusReplay(receipt, expected) {
     if (expected !== undefined && (receipt.migrationId !== expected.migrationId
         || receipt.environment !== expected.environment
         || receipt.workspaceId !== expected.workspaceId
-        || receipt.profile !== expected.profile)) {
+        || 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({
@@ -45,6 +48,10 @@ export function storageMigrationStatusReplay(receipt, expected) {
         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"
             ? {
@@ -98,6 +105,10 @@ export async function monitorStorageMigrationStatus(input, send, injected = {})
                 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 } : {}),
@@ -114,6 +125,10 @@ export async function monitorStorageMigrationStatus(input, send, injected = {})
                 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 } : {}),

package/dist/storage-worker-executor.js

@@ -367,6 +367,7 @@ export async function executeStorageMigrationWorker(handoffPath, injected = {})
         targetWorkspaceRoot: operation.migration.targetWorkspaceRoot,
         backupsRoot: operation.migration.backupsRoot,
         backupArtifacts: operation.migration.backupArtifacts,
+        ...(operation.migration.ownership === undefined ? {} : { ownership: operation.migration.ownership }),
         acceptedWarnings: operation.migration.acceptedWarnings,
         onStatus: () => assertHeartbeatHealthy(),
         assertHealthy: assertHeartbeatHealthy,

package/dist/storage-worker-operation.js

@@ -118,6 +118,10 @@ const OperationSchema = z.object({
             name: z.string().regex(/^[a-z0-9][a-z0-9_.-]{0,127}$/u),
             path: AbsolutePathSchema,
         }).strict()).max(32),
+        ownership: z.object({
+            ownerEpoch: z.number().int().positive().safe(),
+            ownershipClaimFingerprint: z.string().regex(/^sha256:[0-9a-f]{64}$/u),
+        }).strict().optional(),
         acceptedWarnings: z.array(StorageMigrationWarningCodeSchema)
             .max(StorageMigrationWarningCodeSchema.options.length),
     }).strict(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.77",
+  "version": "0.6.79-beta.1",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",

package/dist/project-skills/capability.js

@@ -1,109 +0,0 @@
-import { PROJECT_SKILLS_CAPABILITY, PROJECT_SKILL_PROJECTION_V2_CAPABILITY, } from "./types.js";
-export function projectSkillV2RolloutReady(platform, readiness) {
-    const platformReady = platform === "darwin"
-        || platform === "linux"
-        || (platform === "win32" && readiness.nativeWindowsSmokePassed);
-    return platformReady
-        && readiness.runtimeRootStorePrimitiveReady
-        && readiness.runtimeRootStoreRecoveryReady
-        && readiness.leaseRecoveryReady
-        && readiness.controllerReady
-        && readiness.executionHandlerReady
-        && readiness.codexAdapterReady
-        && readiness.claudeAdapterReady;
-}
-export function effectiveProjectSkillCapabilities(capabilities, projectSkillsReady, projectSkillV2Ready) {
-    const projectSkillCapabilitiesReady = projectSkillsReady && projectSkillV2Ready;
-    if (!projectSkillCapabilitiesReady
-        && !capabilities.includes(PROJECT_SKILLS_CAPABILITY)
-        && !capabilities.includes(PROJECT_SKILL_PROJECTION_V2_CAPABILITY)
-        && Object.isFrozen(capabilities))
-        return capabilities;
-    const filtered = capabilities.filter((capability) => capability !== PROJECT_SKILL_PROJECTION_V2_CAPABILITY
-        && (projectSkillCapabilitiesReady || capability !== PROJECT_SKILLS_CAPABILITY));
-    if (!projectSkillCapabilitiesReady || !filtered.includes(PROJECT_SKILLS_CAPABILITY)) {
-        return Object.freeze(filtered);
-    }
-    const v1Index = filtered.indexOf(PROJECT_SKILLS_CAPABILITY);
-    return Object.freeze([
-        ...filtered.slice(0, v1Index + 1),
-        PROJECT_SKILL_PROJECTION_V2_CAPABILITY,
-        ...filtered.slice(v1Index + 1),
-    ]);
-}
-export function withProjectSkillCapabilityStatus(value, status) {
-    return {
-        ...value,
-        projectSkillsStatus: status,
-        capabilities: status === "ready"
-            ? value.capabilities
-            : effectiveProjectSkillCapabilities(value.capabilities, false, false),
-    };
-}
-const settleReadinessGate = async (operation) => {
-    try {
-        return await operation() === true;
-    }
-    catch {
-        return false;
-    }
-};
-export async function createProjectSkillConnectionCapabilitySnapshot(input) {
-    const runtimeRootStorePrimitiveReady = await settleReadinessGate(input.probeRuntimeRootStorePrimitive);
-    const controllerReady = await settleReadinessGate(input.initializeController);
-    const recoveryReady = await settleReadinessGate(input.recoverRuntimeRootsAndLeases);
-    const readiness = Object.freeze({
-        runtimeRootStorePrimitiveReady,
-        runtimeRootStoreRecoveryReady: recoveryReady,
-        leaseRecoveryReady: recoveryReady,
-        controllerReady,
-        executionHandlerReady: true,
-        codexAdapterReady: true,
-        claudeAdapterReady: true,
-        nativeWindowsSmokePassed: false,
-    });
-    const projectSkillsReady = projectSkillV2RolloutReady(input.platform, readiness);
-    return Object.freeze({
-        capabilities: effectiveProjectSkillCapabilities(input.baseCapabilities, projectSkillsReady, projectSkillsReady),
-        projectSkillsReady,
-        readiness,
-    });
-}
-export async function prepareProjectSkillConnectionCapabilities(input) {
-    const snapshot = await createProjectSkillConnectionCapabilitySnapshot({
-        ...input,
-        baseCapabilities: [...input.baseCapabilities, ...await input.additionalCapabilities()],
-    });
-    input.applyReadiness(snapshot.projectSkillsReady);
-    return snapshot.capabilities;
-}
-export function createProjectSkillControllerReadiness(input) {
-    let status = "initializing";
-    let initialization = null;
-    const ensure = () => {
-        if (status === "ready")
-            return Promise.resolve(true);
-        if (initialization !== null)
-            return initialization;
-        status = "initializing";
-        const attempt = input.initialize().then(() => {
-            status = "ready";
-            return true;
-        }, (error) => {
-            status = "unavailable";
-            input.onUnavailable(error);
-            return false;
-        }).finally(() => {
-            if (initialization === attempt)
-                initialization = null;
-            input.onSettled();
-        });
-        initialization = attempt;
-        return attempt;
-    };
-    return Object.freeze({
-        status: () => status,
-        ensure,
-        applyPreflight: (ready) => { status = ready ? "ready" : "unavailable"; },
-    });
-}

package/dist/project-skills/controller-convergence.js

@@ -1,57 +0,0 @@
-import { ProjectProjectionError, } from "./reconciler.js";
-export const MAX_REMEMBERED_PROJECT_SKILL_AGENTS = 64;
-const compareBinary = (left, right) => {
-    if (left < right)
-        return -1;
-    if (left > right)
-        return 1;
-    return 0;
-};
-const copySnapshot = (snapshot) => Object.freeze({
-    bindings: Object.freeze(snapshot.bindings.map((binding) => Object.freeze({ ...binding }))),
-    generation: snapshot.generation,
-});
-export function createProjectSkillSnapshotEpoch(maxEntries = MAX_REMEMBERED_PROJECT_SKILL_AGENTS) {
-    if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) {
-        throw new ProjectProjectionError("skill_projection_failed");
-    }
-    const snapshots = new Map();
-    return Object.freeze({
-        begin() {
-            snapshots.clear();
-        },
-        remember(handle, snapshot) {
-            const previous = snapshots.get(handle);
-            if (previous !== undefined && snapshot.generation < previous.generation)
-                return;
-            if (previous === undefined && snapshots.size >= maxEntries) {
-                throw new ProjectProjectionError("skill_projection_failed");
-            }
-            snapshots.set(handle, copySnapshot(snapshot));
-        },
-        forget(handle) {
-            snapshots.delete(handle);
-        },
-        entries() {
-            return Object.freeze([...snapshots.entries()]
-                .sort(([left], [right]) => compareBinary(left, right))
-                .map(([handle, snapshot]) => Object.freeze([handle, copySnapshot(snapshot)])));
-        },
-    });
-}
-const stableErrorCode = (reason) => reason?.code === "skill_projection_snapshot_corrupt"
-    ? "skill_projection_snapshot_corrupt"
-    : "skill_projection_failed";
-export function toPathPrivateConvergenceResults(entries, results) {
-    return Object.freeze(entries.map(([handle], index) => {
-        const result = results[index];
-        if (result?.status === "fulfilled") {
-            return Object.freeze({ handle, status: "fulfilled" });
-        }
-        return Object.freeze({
-            handle,
-            status: "rejected",
-            errorCode: stableErrorCode(result?.reason),
-        });
-    }));
-}