opencode-swarm 7.179.1 → 7.180.0

package/dist/cli/index-ejhxgyvm.js

@@ -0,0 +1,147 @@
+// @bun
+import {
+  require_proper_lockfile
+} from "./index-7g4c7s5r.js";
+import {
+  __toESM
+} from "./index-a76rekgs.js";
+
+// src/parallel/file-locks.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var LOCKS_DIR = ".swarm/locks";
+var LOCK_TIMEOUT_MS = 5 * 60 * 1000;
+var _internals = {
+  tryAcquireLock,
+  writeFile: fs.promises.writeFile
+};
+function getLockFilePath(directory, filePath) {
+  const normalized = path.resolve(directory, filePath);
+  const baseDir = path.resolve(directory) + path.sep;
+  const pathOk = process.platform === "win32" ? normalized.toLowerCase().startsWith(baseDir.toLowerCase()) : normalized.startsWith(baseDir);
+  if (!pathOk) {
+    throw new Error("Invalid file path: path traversal not allowed");
+  }
+  const pathForHash = process.platform === "win32" ? normalized.toLowerCase() : normalized;
+  const hash = crypto.createHash("sha256").update(pathForHash).digest("hex");
+  const lockPath = path.join(directory, LOCKS_DIR, `${hash}.lock`);
+  const legacyPaths = [pathForHash];
+  if (process.platform === "win32" && normalized !== pathForHash) {
+    legacyPaths.push(normalized);
+  }
+  for (const legacyPath of legacyPaths) {
+    const oldHash = Buffer.from(legacyPath).toString("base64").replace(/[/+=]/g, "_");
+    const oldLockPath = path.join(directory, LOCKS_DIR, `${oldHash}.lock`);
+    if (fs.existsSync(oldLockPath)) {
+      return oldLockPath;
+    }
+  }
+  return lockPath;
+}
+function getMetaPath(lockPath) {
+  return `${lockPath.replace(/\.lock$/, "")}.meta`;
+}
+function readMetaFile(metaPath) {
+  try {
+    const content = fs.readFileSync(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function tryAcquireLock(directory, filePath, agent, taskId) {
+  const lockPath = getLockFilePath(directory, filePath);
+  const locksDir = path.dirname(lockPath);
+  if (!fs.existsSync(locksDir)) {
+    fs.mkdirSync(locksDir, { recursive: true });
+  }
+  if (!fs.existsSync(lockPath)) {
+    fs.writeFileSync(lockPath, "", "utf-8");
+  }
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(lockPath, {
+      stale: LOCK_TIMEOUT_MS,
+      retries: {
+        retries: 5,
+        minTimeout: 10,
+        maxTimeout: 500,
+        factor: 2
+      },
+      realpath: false
+    });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ELOCKED" || code === "EEXIST") {
+      return { acquired: false };
+    }
+    throw err;
+  }
+  const lock = {
+    filePath,
+    agent,
+    taskId,
+    timestamp: new Date().toISOString(),
+    expiresAt: Date.now() + LOCK_TIMEOUT_MS,
+    _release: release
+  };
+  return { acquired: true, lock };
+}
+function listActiveLocks(directory) {
+  const locksDir = path.join(directory, LOCKS_DIR);
+  const locks = [];
+  if (!fs.existsSync(locksDir)) {
+    return locks;
+  }
+  const files = fs.readdirSync(locksDir);
+  const now = Date.now();
+  for (const file of files) {
+    if (!file.endsWith(".lock"))
+      continue;
+    const lockPath = path.join(locksDir, file);
+    try {
+      const stat = fs.statSync(lockPath);
+      if (stat.isFile()) {
+        const plLockDir = `${lockPath}.lock`;
+        if (fs.existsSync(plLockDir)) {
+          const metaPath = getMetaPath(lockPath);
+          const meta = readMetaFile(metaPath);
+          if (meta) {
+            if (meta.expiresAt < now) {
+              continue;
+            }
+            locks.push({
+              filePath: meta.originalPath,
+              agent: meta.agent,
+              taskId: meta.taskId,
+              timestamp: meta.acquiredAt,
+              expiresAt: meta.expiresAt,
+              laneId: meta.laneId
+            });
+          } else {
+            let acquiredAt = Date.now();
+            try {
+              acquiredAt = fs.statSync(plLockDir).mtimeMs;
+            } catch {}
+            const expiresAt = acquiredAt + LOCK_TIMEOUT_MS;
+            if (expiresAt < now) {
+              continue;
+            }
+            locks.push({
+              filePath: lockPath,
+              agent: "unknown",
+              taskId: "unknown",
+              timestamp: new Date(acquiredAt).toISOString(),
+              expiresAt
+            });
+          }
+        }
+      }
+    } catch {}
+  }
+  return locks;
+}
+
+export { tryAcquireLock, listActiveLocks };

package/dist/cli/{index-epfjc1c1.js → index-ekgc71m1.js}

@@ -1,36 +1,36 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-s4bkey0q.js";
+} from "./index-gc6h1fmf.js";
 import {
   observeReceiptTransition
-} from "./index-yfpswnjt.js";
+} from "./index-jmrsfhwq.js";
 import {
   resolveHiveEventsPath
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-34bwqcea.js";
+} from "./index-zvxy0mev.js";
 import {
   assertProjectRoot,
   atomicWriteFile
-} from "./index-f2v90gfc.js";
-import {
-  require_proper_lockfile
-} from "./index-7g4c7s5r.js";
+} from "./index-0v1rtanv.js";
 import {
   emit
 } from "./index-qt0793qm.js";
 import {
   canonicalRootKey
 } from "./index-1xnse449.js";
+import {
+  require_proper_lockfile
+} from "./index-7g4c7s5r.js";
 import {
   loadPluginConfigWithMeta
-} from "./index-m1w40kfw.js";
+} from "./index-zptq8mp1.js";
 import {
   KnowledgeConfigSchema,
   init_schema
-} from "./index-9s1xzvnn.js";
+} from "./index-defq2crz.js";
 import {
   init_logger,
   warn
@@ -2813,7 +2813,7 @@ async function applyKnowledgeVerdictFeedback(directory, options) {
     }
     let bumps = 0;
     if (deltas.length > 0) {
-      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-1fphg9sa.js");
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-dnv0ph42.js");
       bumps = await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
     }
     return {

package/dist/cli/{index-s4bkey0q.js → index-gc6h1fmf.js}

@@ -2,15 +2,15 @@
 import {
   bunFile
 } from "./index-2s7dvzff.js";
+import {
+  SwarmError
+} from "./index-c1ggtmpm.js";
 import {
   RECENT_WRITE_WINDOW_MS,
   readCachedTextFile,
   wasObservedToExist,
   wasRecentlyWrittenByThisProcess
-} from "./index-ne9zamcs.js";
-import {
-  SwarmError
-} from "./index-c1ggtmpm.js";
+} from "./index-989v83pb.js";
 import {
   warn
 } from "./index-zgwm4ryv.js";

package/dist/cli/index-gx2vp8gx.js

@@ -0,0 +1,100 @@
+// @bun
+import {
+  exports_external,
+  init_zod
+} from "./index-gknz3bv1.js";
+
+// src/config/plan-schema.ts
+init_zod();
+var ExecutionProfileSchema = exports_external.object({
+  parallelization_enabled: exports_external.boolean().default(false),
+  max_concurrent_tasks: exports_external.number().int().min(1).max(64).default(10),
+  council_parallel: exports_external.boolean().default(true),
+  locked: exports_external.boolean().default(false),
+  auto_proceed: exports_external.boolean().default(false),
+  commit_after_each_completed_task: exports_external.boolean().default(false),
+  planning_profile: exports_external.enum(["balanced", "strict"]).optional()
+});
+var TaskStatusSchema = exports_external.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "blocked",
+  "closed"
+]);
+var TaskSizeSchema = exports_external.enum(["small", "medium", "large"]);
+var PhaseStatusSchema = exports_external.enum([
+  "pending",
+  "in_progress",
+  "complete",
+  "completed",
+  "blocked",
+  "closed"
+]);
+var MigrationStatusSchema = exports_external.enum([
+  "native",
+  "migrated",
+  "migration_failed"
+]);
+var TaskSchema = exports_external.object({
+  id: exports_external.string(),
+  phase: exports_external.number().int().min(1),
+  status: TaskStatusSchema.default("pending"),
+  size: TaskSizeSchema.default("small"),
+  description: exports_external.string().min(1),
+  depends: exports_external.array(exports_external.string()).default([]),
+  acceptance: exports_external.string().optional(),
+  files_touched: exports_external.array(exports_external.string()).default([]),
+  evidence_path: exports_external.string().optional(),
+  blocked_reason: exports_external.string().optional(),
+  fr_refs: exports_external.array(exports_external.string()).optional()
+});
+var PhaseSchema = exports_external.object({
+  id: exports_external.number().int().min(1),
+  name: exports_external.string().min(1),
+  status: PhaseStatusSchema.default("pending"),
+  tasks: exports_external.array(TaskSchema).default([]),
+  type: exports_external.enum(["code", "non-code"]).optional(),
+  required_agents: exports_external.array(exports_external.string()).optional()
+});
+var PlanSchema = exports_external.object({
+  schema_version: exports_external.literal("1.0.0"),
+  title: exports_external.string().min(1),
+  swarm: exports_external.string().min(1),
+  current_phase: exports_external.number().int().min(1).optional(),
+  phases: exports_external.array(PhaseSchema).min(1),
+  migration_status: MigrationStatusSchema.optional(),
+  specMtime: exports_external.string().optional(),
+  specHash: exports_external.string().optional(),
+  execution_profile: ExecutionProfileSchema.optional()
+});
+function isPhaseStatusTerminal(status) {
+  return status === "complete" || status === "completed" || status === "closed";
+}
+function isPhaseEffectivelyTerminal(phase) {
+  if (isPhaseStatusTerminal(phase.status))
+    return true;
+  const tasks = phase.tasks ?? [];
+  return tasks.length > 0 && tasks.every((task) => task.status === "completed" || task.status === "closed");
+}
+function resolveActivePhaseId(plan) {
+  const cursor = plan.current_phase;
+  if (cursor !== undefined) {
+    const cursorPhase = plan.phases.find((phase) => phase.id === cursor);
+    if (cursorPhase && !isPhaseEffectivelyTerminal(cursorPhase)) {
+      return cursorPhase.id;
+    }
+  }
+  const firstNonTerminal = plan.phases.find((phase) => !isPhaseEffectivelyTerminal(phase));
+  if (firstNonTerminal)
+    return firstNonTerminal.id;
+  return plan.phases[plan.phases.length - 1]?.id ?? 1;
+}
+function normalizeCurrentPhaseInPlace(plan) {
+  plan.current_phase = resolveActivePhaseId(plan);
+}
+function getCurrentPhase(plan) {
+  return resolveActivePhaseId(plan);
+}
+
+export { ExecutionProfileSchema, TaskStatusSchema, TaskSizeSchema, PhaseStatusSchema, MigrationStatusSchema, TaskSchema, PhaseSchema, PlanSchema, resolveActivePhaseId, normalizeCurrentPhaseInPlace, getCurrentPhase };

package/dist/cli/{index-h59vsbch.js → index-htrb9ec3.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   observeStoreHealth
-} from "./index-yfpswnjt.js";
+} from "./index-jmrsfhwq.js";
 import {
   telemetry
 } from "./index-qt0793qm.js";

package/dist/cli/{index-yfpswnjt.js → index-jmrsfhwq.js}

@@ -4,12 +4,12 @@ import {
   resolveLineageSalt,
   telemetry
 } from "./index-qt0793qm.js";
-import {
-  atomicWriteSwarmFile
-} from "./index-ne9zamcs.js";
 import {
   canonicalRootKeyFresh
 } from "./index-1xnse449.js";
+import {
+  atomicWriteSwarmFile
+} from "./index-989v83pb.js";
 
 // src/health/learning-health.ts
 import { promises as fs } from "fs";

package/dist/cli/{index-rb9jmj30.js → index-jrfv2am8.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   computePlanStructureHash
-} from "./index-b567t0cr.js";
+} from "./index-x6kjbjya.js";
 import {
   appendCoreEventSync
-} from "./index-h59vsbch.js";
+} from "./index-htrb9ec3.js";
 import {
   deleteCoordinationState,
   derivePlanId,
@@ -13,27 +13,27 @@ import {
   transitionCoordinationState,
   transitionCoordinationStateWithinTransaction,
   withCoordinationTransaction
-} from "./index-a11ztzs5.js";
+} from "./index-vmthakz0.js";
 import {
   getProjectDb
-} from "./index-nzekzzs2.js";
+} from "./index-bv4b8tpa.js";
 import {
   canonicalExistingFilesystemPath,
   legacyCanonicalExistingFilesystemPath
 } from "./index-ry16d01s.js";
 import {
   assertProjectRoot
-} from "./index-f2v90gfc.js";
+} from "./index-0v1rtanv.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
 import {
   atomicWriteSwarmFile,
   atomicWriteSwarmFileSync
-} from "./index-ne9zamcs.js";
+} from "./index-989v83pb.js";
 import {
   PlanSchema
-} from "./index-m1w40kfw.js";
+} from "./index-gx2vp8gx.js";
 import {
   init_path_identity,
   unsafePathTextReason

package/dist/cli/{index-pskba939.js → index-jscqefqm.js}

@@ -9,7 +9,7 @@ import {
   readEvaluationRun,
   saveEvaluationRun,
   saveTaskSetSnapshot
-} from "./index-g6nyk713.js";
+} from "./index-aspxz5r5.js";
 import {
   canonicalHash,
   computeCandidateInputContentHash,

package/dist/cli/{index-y98fvmb8.js → index-kp654qcw.js}

@@ -3,10 +3,10 @@ import {
   EvaluationRunV1Schema,
   GateAuditResultV1Schema,
   getProtectedEvaluationRunIds
-} from "./index-g6nyk713.js";
+} from "./index-aspxz5r5.js";
 import {
   readEffectiveSpecSync
-} from "./index-n1tcj1q7.js";
+} from "./index-bx70zs8d.js";
 import {
   validateWorkspaceRoot
 } from "./index-6b295cas.js";
@@ -23,13 +23,13 @@ import {
   readTaskEvidence,
   readTaskEvidenceRaw,
   sanitizeTaskId
-} from "./index-n2wjrgcs.js";
+} from "./index-caj76d0f.js";
 import {
   estimateCharsForTokens,
   estimateTokens,
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-s4bkey0q.js";
+} from "./index-gc6h1fmf.js";
 import {
   bunHash,
   bunWrite,
@@ -58,10 +58,10 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-b567t0cr.js";
+} from "./index-x6kjbjya.js";
 import {
   appendCoreEventSync
-} from "./index-h59vsbch.js";
+} from "./index-htrb9ec3.js";
 import {
   derivePlanId,
   derivePlanIdentityHash,
@@ -69,40 +69,42 @@ import {
   importCoordinationOnce,
   listCoordinationStates,
   transitionCoordinationState
-} from "./index-a11ztzs5.js";
+} from "./index-vmthakz0.js";
 import {
   DURABILITY_CLASSES,
   getProjectDb,
   projectDbExists,
   withDurabilityClass
-} from "./index-nzekzzs2.js";
+} from "./index-bv4b8tpa.js";
 import {
   assertProjectRoot,
-  tryAcquireLock,
   withEvidenceLock
-} from "./index-f2v90gfc.js";
+} from "./index-0v1rtanv.js";
 import {
   emit
 } from "./index-qt0793qm.js";
+import {
+  canonicalRootKeyFresh
+} from "./index-1xnse449.js";
+import {
+  tryAcquireLock
+} from "./index-ejhxgyvm.js";
 import {
   atomicWriteSwarmFileSync,
   invalidateCachedArtifact,
   readCachedParsedFile
-} from "./index-ne9zamcs.js";
-import {
-  canonicalRootKeyFresh
-} from "./index-1xnse449.js";
+} from "./index-989v83pb.js";
 import {
   PlanSchema,
   normalizeCurrentPhaseInPlace,
   resolveActivePhaseId
-} from "./index-m1w40kfw.js";
+} from "./index-gx2vp8gx.js";
 import {
   GIT_BINARY_ENV_VAR,
   describeGitResolution,
   init_git_executable,
   resolveGitExecutable
-} from "./index-zz7gzw57.js";
+} from "./index-zxdawwc7.js";
 import {
   ZodError,
   init_zod
@@ -2935,6 +2937,19 @@ async function updateTaskStatus(directory, taskId, status, options) {
           warn(`[plan/manager] run-memory record for ${taskId} failed: ${err instanceof Error ? err.message : String(err)}`);
         }
       }
+      if (status === "completed") {
+        try {
+          const completedTask = updatedPlan.phases.flatMap((phase) => phase.tasks).find((candidate) => candidate.id === taskId);
+          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-46g9sqak.js");
+          await maybePropagateSpeckitCheckoff(directory, {
+            taskId,
+            frRefs: completedTask?.fr_refs ?? [],
+            text: completedTask?.description ?? ""
+          });
+        } catch (err) {
+          warn(`[plan/manager] speckit check-off for ${taskId} failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
       if (status === "completed" && _internals5.isGitRepo(directory) && _internals5.isEpicModeActiveForProject(directory)) {
         const mergeFailure = _internals5.getWorktreeMergeFailure(taskId);
         if (mergeFailure) {
@@ -2950,7 +2965,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
               break;
             }
           }
-          const { readDeclaredScopeFilesFromBindings } = await import("./scope-persistence-d0358pw7.js");
+          const { readDeclaredScopeFilesFromBindings } = await import("./scope-persistence-nsw324ce.js");
           const canonicalScope = readDeclaredScopeFilesFromBindings({
             directory,
             taskId,

package/dist/cli/{index-93nx95me.js → index-mhrn7hbb.js}

@@ -2,7 +2,7 @@
 import {
   _internals,
   resolveWorktreeIsolationConfig
-} from "./index-ajm7ebyd.js";
+} from "./index-dcttq1mn.js";
 import {
   ApprovalEvidenceSchema,
   BaseEvidenceSchema,
@@ -27,7 +27,7 @@ import {
   SpecSectionSchema,
   SwarmSpecSchema,
   validateSpecContent
-} from "./index-wrt875kh.js";
+} from "./index-0725jpp7.js";
 import {
   ExecutionProfileSchema,
   MigrationStatusSchema,
@@ -36,7 +36,9 @@ import {
   PlanSchema,
   TaskSchema,
   TaskSizeSchema,
-  TaskStatusSchema,
+  TaskStatusSchema
+} from "./index-gx2vp8gx.js";
+import {
   getSafeDefaultConfigLoadResult,
   loadAgentPrompt,
   loadGateOverrides,
@@ -44,9 +46,8 @@ import {
   loadPluginConfigWithMeta,
   loadPluginConfigWithMetaAsync,
   resetConfigAdvisoryDedup
-} from "./index-m1w40kfw.js";
-import"./index-zz7gzw57.js";
-import"./index-4ddpvd5c.js";
+} from "./index-zptq8mp1.js";
+import"./index-zxdawwc7.js";
 import {
   AUTO_REVIEW_V8_BURN_IN_DECISION,
   AgentOverrideConfigSchema,
@@ -71,7 +72,7 @@ import {
   TurboConfigSchema,
   WorktreeIsolationConfigSchema,
   resolveAutoReviewConfig
-} from "./index-9s1xzvnn.js";
+} from "./index-defq2crz.js";
 import {
   ALL_AGENT_NAMES,
   ALL_SUBAGENT_NAMES,

package/dist/cli/{index-h4nh6s8b.js → index-nhxykfyy.js}

@@ -5,7 +5,7 @@ import {
   batchDurabilityClass,
   classifyDbWriteError,
   getProjectDb
-} from "./index-nzekzzs2.js";
+} from "./index-bv4b8tpa.js";
 import {
   _internals,
   canonicalRootKeyFresh

package/dist/cli/{index-yp25bc9n.js → index-pnt98k7z.js}

@@ -11,16 +11,16 @@ import {
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-34bwqcea.js";
+} from "./index-zvxy0mev.js";
 import {
   atomicWriteFile
-} from "./index-f2v90gfc.js";
+} from "./index-0v1rtanv.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
 import {
   readCachedParsedFile
-} from "./index-ne9zamcs.js";
+} from "./index-989v83pb.js";
 import {
   init_knowledge_types,
   isActiveStatus
@@ -739,7 +739,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
   const {
     readAuthoritativeKnowledgeCounterRollups,
     effectiveRetrievalOutcomes
-  } = await import("./knowledge-events-2bgefatz.js");
+  } = await import("./knowledge-events-naf9kyyc.js");
   const rollups = await readAuthoritativeKnowledgeCounterRollups(directory);
   const flagIds = new Set;
   for (const e of atFloor) {
@@ -806,11 +806,11 @@ async function applyConfidenceFloorAction(directory, touched, options) {
     });
   }
   if (action === "quarantine" && toQuarantine.length > 0) {
-    const { quarantineEntry } = await import("./knowledge-validator-723h2vck.js");
-    const { KnowledgeConfigSchema } = await import("./schema-jt9axyj6.js");
+    const { quarantineEntry } = await import("./knowledge-validator-a1rfzkmv.js");
+    const { KnowledgeConfigSchema } = await import("./schema-a5zb02h8.js");
     let config;
     try {
-      const { loadPluginConfigWithMeta } = await import("./index-93nx95me.js");
+      const { loadPluginConfigWithMeta } = await import("./index-mhrn7hbb.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-vp9pn7sv.js → index-ret97f1t.js}

@@ -3,7 +3,7 @@ import {
   queryHistoricalOutcomes,
   readKnowledgeEvents,
   recordKnowledgeEvent
-} from "./index-epfjc1c1.js";
+} from "./index-ekgc71m1.js";
 import {
   jaccardBigram,
   readKnowledge,
@@ -11,7 +11,7 @@ import {
   resolveSwarmKnowledgePath,
   transactKnowledge,
   wordBigrams
-} from "./index-yp25bc9n.js";
+} from "./index-pnt98k7z.js";
 import {
   init_knowledge_types,
   isActiveStatus
@@ -224,11 +224,11 @@ async function maybeQuarantineOnContradiction(directory, entryId, threshold, win
         alreadyInactive: true
       };
     }
-    const { quarantineEntry } = await import("./knowledge-validator-723h2vck.js");
+    const { quarantineEntry } = await import("./knowledge-validator-a1rfzkmv.js");
     let policyConfig;
     try {
-      const { KnowledgeConfigSchema } = await import("./schema-jt9axyj6.js");
-      const { loadPluginConfigWithMeta } = await import("./index-93nx95me.js");
+      const { KnowledgeConfigSchema } = await import("./schema-a5zb02h8.js");
+      const { loadPluginConfigWithMeta } = await import("./index-mhrn7hbb.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       policyConfig = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {