@gfean/react-native-bundle-drop 0.6.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (58) hide show
  1. package/BundleDrop.podspec +96 -0
  2. package/README.md +34 -9
  3. package/android/build.gradle +65 -0
  4. package/android/src/main/java/com/bundledrop/BundleDropModule.kt +137 -13
  5. package/android/src/main/java/com/bundledrop/BundleDropNativePaths.kt +43 -13
  6. package/android/src/main/java/com/bundledrop/BundleDropOtaResolver.kt +35 -0
  7. package/android/src/main/java/com/bundledrop/BundleDropStartupRecovery.kt +1117 -0
  8. package/ios/BundleDropBridge.m +27 -0
  9. package/ios/BundleDropLocator.swift +31 -15
  10. package/ios/BundleDropModule.swift +106 -3
  11. package/ios/BundleDropOtaResolver.swift +137 -29
  12. package/ios/BundleDropStartupRecovery.swift +1108 -0
  13. package/ios/BundleDropStartupRecoveryAdapter.swift +301 -0
  14. package/lib/CLI/cli.js +4 -5
  15. package/lib/CLI/scripts/doctor.js +28 -9
  16. package/lib/CLI/scripts/expo/configure-expo.js +2 -1
  17. package/lib/CLI/scripts/init-config.d.ts +2 -2
  18. package/lib/CLI/scripts/init-config.js +23 -14
  19. package/lib/CLI/scripts/login-cli.js +2 -3
  20. package/lib/CLI/scripts/native/write-runtime-identity.d.ts +19 -0
  21. package/lib/CLI/scripts/native/write-runtime-identity.js +92 -0
  22. package/lib/CLI/scripts/upload-cli.d.ts +12 -2
  23. package/lib/CLI/scripts/upload-cli.js +74 -11
  24. package/lib/CLI/serverUrl.d.ts +3 -0
  25. package/lib/CLI/serverUrl.js +31 -0
  26. package/lib/bundleInfo.d.ts +2 -0
  27. package/lib/bundleInfo.js +16 -1
  28. package/lib/context.js +12 -2
  29. package/lib/fs/bundlePointer.d.ts +1 -17
  30. package/lib/fs/bundlePointer.js +5 -93
  31. package/lib/install/bundleInstallShared.js +4 -4
  32. package/lib/manager/downloadAndInstall.js +25 -22
  33. package/lib/manager/reporting.d.ts +8 -1
  34. package/lib/manager/reporting.js +17 -22
  35. package/lib/manager/rollbackState.d.ts +18 -54
  36. package/lib/manager/rollbackState.js +115 -216
  37. package/lib/manager/updateCheck.js +9 -3
  38. package/lib/manager/updateState.d.ts +2 -1
  39. package/lib/manager/updateState.js +59 -6
  40. package/lib/metro.d.ts +1 -1
  41. package/lib/metro.js +4 -3
  42. package/lib/native/bundleDropNative.d.ts +62 -0
  43. package/lib/native/bundleDropNative.js +266 -1
  44. package/lib/patch-engine/installFromPatchSet.js +2 -2
  45. package/lib/runtime/service.js +29 -71
  46. package/lib/runtime-delivery/bootstrapConfig.d.ts +29 -11
  47. package/lib/runtime-delivery/bootstrapConfig.js +83 -22
  48. package/lib/runtime-delivery/manifestState.d.ts +3 -1
  49. package/lib/runtime-delivery/manifestState.js +22 -1
  50. package/lib/runtime-delivery/manifestVerifier.js +7 -1
  51. package/lib/scripts/bundle.d.ts +9 -2
  52. package/lib/scripts/bundle.js +68 -18
  53. package/lib/scripts/download-bundle.d.ts +1 -0
  54. package/lib/scripts/download-bundle.js +2 -2
  55. package/lib/scripts/resolveModule.d.ts +2 -0
  56. package/lib/scripts/resolveModule.js +5 -0
  57. package/package.json +5 -2
  58. package/plugin/xcodeBuildPhase.js +2 -1
@@ -0,0 +1,1108 @@
1
+ import Foundation
2
+
3
+ enum BundleDropStartupRecoveryError: LocalizedError {
4
+ case invalidHash
5
+ case invalidHealthCheckMode
6
+ case invalidPolicy
7
+ case candidateUnavailable
8
+ case candidateIneligible
9
+ case ledgerCorrupt
10
+ case storageUnavailable
11
+ case staleLedger
12
+
13
+ var errorDescription: String? {
14
+ switch self {
15
+ case .invalidHash:
16
+ return "Bundle Drop startup recovery received an invalid bundle hash"
17
+ case .invalidHealthCheckMode:
18
+ return "Bundle Drop startup recovery healthCheckMode must be auto or manual"
19
+ case .invalidPolicy:
20
+ return "Bundle Drop startup recovery policy must use a non-negative 32-bit integer maxCrashCount and a finite non-negative healthyAfterSec"
21
+ case .candidateUnavailable:
22
+ return "Bundle Drop startup recovery could not verify the candidate bundle"
23
+ case .candidateIneligible:
24
+ return "Bundle Drop startup recovery rejected a quarantined or revoked candidate"
25
+ case .ledgerCorrupt:
26
+ return "Bundle Drop startup recovery ledger is malformed or unsupported"
27
+ case .storageUnavailable:
28
+ return "Bundle Drop startup recovery storage is unavailable"
29
+ case .staleLedger:
30
+ return "Bundle Drop startup recovery rejected a stale ledger transition"
31
+ }
32
+ }
33
+ }
34
+
35
+ enum BundleDropStartupRecoveryPhase: String, Codable {
36
+ case idle
37
+ case armed
38
+ case launching
39
+ case stable
40
+ case recovered
41
+ }
42
+
43
+ struct BundleDropStartupRecoveryPolicy: Codable, Equatable {
44
+ let maxCrashCount: Int
45
+ let healthCheckMode: String
46
+ let healthyAfterSec: Double
47
+ }
48
+
49
+ struct BundleDropStartupRecoveryAttempt: Codable, Equatable {
50
+ let hash: String
51
+ let attemptId: String
52
+ let processToken: String
53
+ let startedAt: Int64
54
+ var unacknowledgedLaunchCount: Int
55
+ var contentAppeared: Bool
56
+ }
57
+
58
+ struct BundleDropStartupRecoveryTransition: Codable, Equatable {
59
+ let kind: String
60
+ let targetHash: String?
61
+ }
62
+
63
+ struct BundleDropStartupRecoveryEvent: Codable, Equatable {
64
+ let id: String
65
+ let failedHash: String
66
+ let recoveryTarget: String
67
+ let recoveredHash: String?
68
+ let crashCount: Int
69
+ let reason: String
70
+ let failedAt: Int64
71
+ }
72
+
73
+ struct BundleDropStartupRecoveryLedger: Codable, Equatable {
74
+ var schemaVersion = 1
75
+ var revision = 0
76
+ var binaryIdentity: String?
77
+ var runtimeIdentity: String?
78
+ var legacyFailuresImported: Bool?
79
+ var phase = BundleDropStartupRecoveryPhase.idle
80
+ var candidateHash: String?
81
+ var stableHash: String?
82
+ var previousStableHash: String?
83
+ var lastHealthyAttemptId: String?
84
+ var activeAttempt: BundleDropStartupRecoveryAttempt?
85
+ var reservedAttemptId: String?
86
+ var pendingTransition: BundleDropStartupRecoveryTransition?
87
+ var policy: BundleDropStartupRecoveryPolicy?
88
+ var quarantinedHashes: [String] = []
89
+ var revokedHashes: [String] = []
90
+ var pendingRecoveryEvents: [BundleDropStartupRecoveryEvent] = []
91
+ }
92
+
93
+ struct BundleDropStartupSelection: Equatable {
94
+ let bundleURL: URL?
95
+ let attemptHash: String?
96
+ let attemptId: String?
97
+ }
98
+
99
+ struct BundleDropStartupActivationResult: Equatable {
100
+ let hash: String
101
+ let bundleURL: URL
102
+ }
103
+
104
+ struct BundleDropStartupRollbackResult: Equatable {
105
+ let rolledBack: Bool
106
+ let toEmbedded: Bool
107
+ let hash: String?
108
+ }
109
+
110
+ /// Native-owned startup ledger. JavaScript may request transitions through the bridge,
111
+ /// but it never writes this file directly.
112
+ final class BundleDropStartupRecoveryController {
113
+ static let protocolVersion = 1
114
+ private static let ledgerCommitLock = NSLock()
115
+
116
+ typealias Failpoint = (String) throws -> Void
117
+
118
+ private let bundleDropRoot: URL
119
+ private let expectedRuntimeVersion: String?
120
+ private let expectedBinaryIdentity: String?
121
+ private let processToken: String
122
+ private let fileManager: FileManager
123
+ private let now: () -> Int64
124
+ private let makeId: () -> String
125
+ private let failpoint: Failpoint?
126
+ private let lock = NSRecursiveLock()
127
+
128
+ private var ledgerURL: URL {
129
+ bundleDropRoot.appendingPathComponent("recovery-ledger.json")
130
+ }
131
+
132
+ private var legacyStateURL: URL {
133
+ bundleDropRoot.appendingPathComponent("state.json")
134
+ }
135
+
136
+ init(
137
+ bundleDropRoot: URL,
138
+ expectedRuntimeVersion: String?,
139
+ expectedBinaryIdentity: String? = nil,
140
+ processToken: String = UUID().uuidString.lowercased(),
141
+ fileManager: FileManager = .default,
142
+ now: @escaping () -> Int64 = { Int64(Date().timeIntervalSince1970) },
143
+ makeId: @escaping () -> String = { UUID().uuidString.lowercased() },
144
+ failpoint: Failpoint? = nil
145
+ ) {
146
+ self.bundleDropRoot = bundleDropRoot
147
+ self.expectedRuntimeVersion = expectedRuntimeVersion
148
+ self.expectedBinaryIdentity = expectedBinaryIdentity
149
+ self.processToken = processToken
150
+ self.fileManager = fileManager
151
+ self.now = now
152
+ self.makeId = makeId
153
+ self.failpoint = failpoint
154
+ }
155
+
156
+ func activateCandidate(
157
+ hash: String,
158
+ maxCrashCount: Int,
159
+ healthCheckMode: String,
160
+ healthyAfterSec: Double
161
+ ) throws -> BundleDropStartupActivationResult {
162
+ try withLock {
163
+ guard hasExpectedIdentity else {
164
+ throw BundleDropStartupRecoveryError.candidateUnavailable
165
+ }
166
+ guard Self.isCanonicalHash(hash) else {
167
+ throw BundleDropStartupRecoveryError.invalidHash
168
+ }
169
+ guard healthCheckMode == "auto" || healthCheckMode == "manual" else {
170
+ throw BundleDropStartupRecoveryError.invalidHealthCheckMode
171
+ }
172
+ guard maxCrashCount >= 0,
173
+ maxCrashCount <= Int(Int32.max),
174
+ healthyAfterSec.isFinite,
175
+ healthyAfterSec >= 0 else {
176
+ throw BundleDropStartupRecoveryError.invalidPolicy
177
+ }
178
+ guard let candidate = BundleDropOtaResolver.readBundle(
179
+ hash: hash,
180
+ bundleDropRoot: bundleDropRoot,
181
+ expectedRuntimeVersion: expectedRuntimeVersion,
182
+ fileManager: fileManager
183
+ ) else {
184
+ throw BundleDropStartupRecoveryError.candidateUnavailable
185
+ }
186
+ try failpoint?("afterCandidateVerified")
187
+
188
+ var ledger = try readLedgerImportingLegacyState()
189
+ if ledger.pendingTransition != nil {
190
+ try completePendingTransition(ledger: &ledger)
191
+ }
192
+ guard !ledger.quarantinedHashes.contains(hash), !ledger.revokedHashes.contains(hash) else {
193
+ throw BundleDropStartupRecoveryError.candidateIneligible
194
+ }
195
+
196
+ let current = BundleDropOtaResolver.readPointer(
197
+ named: "current.json",
198
+ bundleDropRoot: bundleDropRoot,
199
+ expectedRuntimeVersion: expectedRuntimeVersion,
200
+ fileManager: fileManager
201
+ )
202
+ let requestedPolicy = BundleDropStartupRecoveryPolicy(
203
+ maxCrashCount: maxCrashCount,
204
+ healthCheckMode: healthCheckMode,
205
+ healthyAfterSec: healthyAfterSec
206
+ )
207
+ if current?.hash == hash,
208
+ ledger.stableHash == hash,
209
+ ledger.phase == .stable || ledger.phase == .recovered {
210
+ return BundleDropStartupActivationResult(hash: hash, bundleURL: candidate.bundleURL)
211
+ }
212
+ if current?.hash == hash,
213
+ ledger.candidateHash == hash,
214
+ ledger.phase == .armed || ledger.phase == .launching {
215
+ var changed = ledger.policy != requestedPolicy
216
+ ledger.policy = requestedPolicy
217
+ if requestedPolicy.maxCrashCount == 0 {
218
+ changed = changed || ledger.phase != .armed || ledger.activeAttempt != nil || ledger.reservedAttemptId != nil
219
+ ledger.phase = .armed
220
+ ledger.activeAttempt = nil
221
+ ledger.reservedAttemptId = nil
222
+ ledger.lastHealthyAttemptId = nil
223
+ } else if ledger.phase == .armed, ledger.reservedAttemptId == nil {
224
+ ledger.reservedAttemptId = makeId()
225
+ changed = true
226
+ }
227
+ if changed {
228
+ try commit(&ledger)
229
+ }
230
+ return BundleDropStartupActivationResult(hash: hash, bundleURL: candidate.bundleURL)
231
+ }
232
+
233
+ let previousPointer = BundleDropOtaResolver.readPointer(
234
+ named: "previous.json",
235
+ bundleDropRoot: bundleDropRoot,
236
+ expectedRuntimeVersion: expectedRuntimeVersion,
237
+ fileManager: fileManager
238
+ )
239
+ let currentIsProvenStable = current?.hash == ledger.stableHash
240
+ let previousIsProvenStable = previousPointer?.hash == ledger.stableHash
241
+ let fallbackHash: String?
242
+ if currentIsProvenStable, let currentHash = current?.hash {
243
+ fallbackHash = currentHash
244
+ try writePointer(named: "previous.json", hash: currentHash, failpointPrefix: "previous")
245
+ } else if current?.hash == hash && previousIsProvenStable {
246
+ // Transitional compatibility for a JS client that changed current.json first.
247
+ fallbackHash = previousPointer?.hash
248
+ } else {
249
+ fallbackHash = nil
250
+ try? BundleDropOtaResolver.deletePointer(
251
+ named: "previous.json",
252
+ bundleDropRoot: bundleDropRoot,
253
+ fileManager: fileManager
254
+ )
255
+ }
256
+
257
+ ledger.phase = .armed
258
+ ledger.candidateHash = hash
259
+ ledger.stableHash = fallbackHash
260
+ ledger.previousStableHash = nil
261
+ ledger.lastHealthyAttemptId = nil
262
+ ledger.activeAttempt = nil
263
+ ledger.policy = requestedPolicy
264
+ ledger.reservedAttemptId = requestedPolicy.maxCrashCount > 0 ? makeId() : nil
265
+ try commit(&ledger)
266
+ try failpoint?("afterCandidateArmed")
267
+
268
+ if current?.hash != hash {
269
+ try writePointer(named: "current.json", hash: hash, failpointPrefix: "current")
270
+ }
271
+ return BundleDropStartupActivationResult(hash: hash, bundleURL: candidate.bundleURL)
272
+ }
273
+ }
274
+
275
+ func selectStartupBundle(beginReload: Bool = false) -> BundleDropStartupSelection {
276
+ withLock {
277
+ guard hasExpectedIdentity else {
278
+ return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
279
+ }
280
+ do {
281
+ var ledger = try readLedgerImportingLegacyState()
282
+ if ledger.pendingTransition != nil {
283
+ try completePendingTransition(ledger: &ledger)
284
+ }
285
+ guard let current = BundleDropOtaResolver.readPointer(
286
+ named: "current.json",
287
+ bundleDropRoot: bundleDropRoot,
288
+ expectedRuntimeVersion: expectedRuntimeVersion,
289
+ fileManager: fileManager
290
+ ) else {
291
+ if ledger.phase == .armed {
292
+ let fallback = ledger.stableHash.flatMap { hash in
293
+ verifiedPreviousPointer(hash: hash, ledger: ledger)
294
+ }
295
+ if let fallback {
296
+ try writePointer(
297
+ named: "current.json",
298
+ hash: fallback.hash,
299
+ failpointPrefix: "abortedActivationCurrent"
300
+ )
301
+ }
302
+ ledger.phase = fallback == nil ? .idle : .stable
303
+ ledger.candidateHash = nil
304
+ ledger.stableHash = fallback?.hash
305
+ ledger.previousStableHash = nil
306
+ ledger.activeAttempt = nil
307
+ ledger.reservedAttemptId = nil
308
+ ledger.policy = nil
309
+ try? BundleDropOtaResolver.deletePointer(
310
+ named: "previous.json",
311
+ bundleDropRoot: bundleDropRoot,
312
+ fileManager: fileManager
313
+ )
314
+ try commit(&ledger)
315
+ return BundleDropStartupSelection(
316
+ bundleURL: fallback?.bundleURL,
317
+ attemptHash: nil,
318
+ attemptId: nil
319
+ )
320
+ }
321
+ return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
322
+ }
323
+
324
+ // Activation writes the ledger before publishing current.json. If the
325
+ // process stops between those writes, abandon the unpublished candidate
326
+ // and continue booting the previously proven bundle.
327
+ if ledger.phase == .armed,
328
+ ledger.candidateHash != current.hash,
329
+ ledger.stableHash == current.hash {
330
+ ledger.phase = .stable
331
+ ledger.candidateHash = nil
332
+ ledger.activeAttempt = nil
333
+ ledger.reservedAttemptId = nil
334
+ ledger.policy = nil
335
+ try? BundleDropOtaResolver.deletePointer(
336
+ named: "previous.json",
337
+ bundleDropRoot: bundleDropRoot,
338
+ fileManager: fileManager
339
+ )
340
+ try commit(&ledger)
341
+ return BundleDropStartupSelection(bundleURL: current.bundleURL, attemptHash: nil, attemptId: nil)
342
+ }
343
+
344
+ if ledger.revokedHashes.contains(current.hash) || ledger.quarantinedHashes.contains(current.hash) {
345
+ return try recover(
346
+ failedHash: current.hash,
347
+ crashCount: ledger.activeAttempt?.unacknowledgedLaunchCount ?? 0,
348
+ quarantine: ledger.quarantinedHashes.contains(current.hash),
349
+ emitEvent: false,
350
+ ledger: &ledger
351
+ )
352
+ }
353
+
354
+ if ledger.stableHash == current.hash,
355
+ ledger.phase == .stable || ledger.phase == .recovered {
356
+ return BundleDropStartupSelection(
357
+ bundleURL: current.bundleURL,
358
+ attemptHash: nil,
359
+ attemptId: nil
360
+ )
361
+ }
362
+
363
+ guard ledger.candidateHash == current.hash,
364
+ ledger.phase == .armed || ledger.phase == .launching,
365
+ let policy = ledger.policy else {
366
+ // An OTA without native proof must never become startup-visible.
367
+ try BundleDropOtaResolver.deletePointer(
368
+ named: "current.json",
369
+ bundleDropRoot: bundleDropRoot,
370
+ fileManager: fileManager
371
+ )
372
+ return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
373
+ }
374
+
375
+ // A zero limit explicitly disables launch-health classification. The
376
+ // candidate remains ledger-tracked for integrity and revocation checks,
377
+ // but it is never treated as health-proven or charged a failed attempt.
378
+ if policy.maxCrashCount == 0 {
379
+ return BundleDropStartupSelection(
380
+ bundleURL: current.bundleURL,
381
+ attemptHash: nil,
382
+ attemptId: nil
383
+ )
384
+ }
385
+
386
+ if !beginReload,
387
+ ledger.activeAttempt?.processToken == processToken,
388
+ ledger.activeAttempt?.hash == current.hash {
389
+ return BundleDropStartupSelection(
390
+ bundleURL: current.bundleURL,
391
+ attemptHash: current.hash,
392
+ attemptId: ledger.activeAttempt?.attemptId
393
+ )
394
+ }
395
+
396
+ var unacknowledgedLaunchCount = ledger.activeAttempt?.unacknowledgedLaunchCount ?? 0
397
+ if ledger.phase == .launching, !beginReload {
398
+ unacknowledgedLaunchCount += 1
399
+ }
400
+
401
+ if policy.maxCrashCount > 0,
402
+ unacknowledgedLaunchCount >= policy.maxCrashCount {
403
+ return try recover(
404
+ failedHash: current.hash,
405
+ crashCount: unacknowledgedLaunchCount,
406
+ quarantine: true,
407
+ emitEvent: true,
408
+ ledger: &ledger
409
+ )
410
+ }
411
+
412
+ let attemptId = ledger.reservedAttemptId ?? makeId()
413
+ ledger.phase = .launching
414
+ ledger.reservedAttemptId = nil
415
+ ledger.activeAttempt = BundleDropStartupRecoveryAttempt(
416
+ hash: current.hash,
417
+ attemptId: attemptId,
418
+ processToken: processToken,
419
+ startedAt: now(),
420
+ unacknowledgedLaunchCount: unacknowledgedLaunchCount,
421
+ contentAppeared: false
422
+ )
423
+ try commit(&ledger)
424
+ try failpoint?("afterLaunchPersisted")
425
+ return BundleDropStartupSelection(
426
+ bundleURL: current.bundleURL,
427
+ attemptHash: current.hash,
428
+ attemptId: attemptId
429
+ )
430
+ } catch BundleDropStartupRecoveryError.ledgerCorrupt {
431
+ return repairCorruptLedger()
432
+ } catch {
433
+ // Failing closed here prevents an untracked candidate from booting.
434
+ return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
435
+ }
436
+ }
437
+ }
438
+
439
+ func markContentAppeared(hash: String, attemptId: String) -> Double? {
440
+ withLock {
441
+ do {
442
+ var ledger = try readLedgerImportingLegacyState()
443
+ guard ledger.phase == .launching,
444
+ ledger.candidateHash == hash,
445
+ ledger.activeAttempt?.hash == hash,
446
+ ledger.activeAttempt?.attemptId == attemptId,
447
+ ledger.activeAttempt?.contentAppeared == false,
448
+ ledger.policy?.healthCheckMode == "auto" else {
449
+ return nil
450
+ }
451
+ ledger.activeAttempt?.contentAppeared = true
452
+ try commit(&ledger)
453
+ return ledger.policy?.healthyAfterSec ?? 0
454
+ } catch {
455
+ return nil
456
+ }
457
+ }
458
+ }
459
+
460
+ func markHealthy(hash: String, attemptId: String) -> Bool {
461
+ withLock {
462
+ do {
463
+ var ledger = try readLedgerImportingLegacyState()
464
+ guard isCurrentBundleEligible(hash: hash, ledger: ledger) else {
465
+ return false
466
+ }
467
+ if ledger.phase == .stable,
468
+ ledger.stableHash == hash,
469
+ ledger.lastHealthyAttemptId == attemptId {
470
+ return true
471
+ }
472
+ guard ledger.phase == .launching,
473
+ ledger.candidateHash == hash,
474
+ ledger.activeAttempt?.hash == hash,
475
+ ledger.activeAttempt?.attemptId == attemptId else {
476
+ return false
477
+ }
478
+ ledger.phase = .stable
479
+ ledger.previousStableHash = ledger.stableHash
480
+ ledger.stableHash = hash
481
+ ledger.lastHealthyAttemptId = attemptId
482
+ ledger.candidateHash = nil
483
+ ledger.activeAttempt = nil
484
+ ledger.reservedAttemptId = nil
485
+ ledger.policy = nil
486
+ try commit(&ledger)
487
+ try failpoint?("afterHealthCommitted")
488
+ return true
489
+ } catch {
490
+ return false
491
+ }
492
+ }
493
+ }
494
+
495
+ func passiveCurrentBundle() -> URL? {
496
+ withLock {
497
+ guard hasExpectedIdentity else { return nil }
498
+ do {
499
+ guard let current = BundleDropOtaResolver.readPointer(
500
+ named: "current.json",
501
+ bundleDropRoot: bundleDropRoot,
502
+ expectedRuntimeVersion: expectedRuntimeVersion,
503
+ fileManager: fileManager
504
+ ), let ledger = try readLedgerFromDisk() else {
505
+ return nil
506
+ }
507
+ guard ledger.binaryIdentity == expectedBinaryIdentity,
508
+ ledger.runtimeIdentity == expectedRuntimeVersion,
509
+ !ledger.revokedHashes.contains(current.hash),
510
+ !ledger.quarantinedHashes.contains(current.hash) else {
511
+ return nil
512
+ }
513
+ let isStable = ledger.stableHash == current.hash &&
514
+ (ledger.phase == .stable || ledger.phase == .recovered)
515
+ let isCandidate = ledger.candidateHash == current.hash &&
516
+ (ledger.phase == .armed || ledger.phase == .launching) &&
517
+ ledger.policy != nil
518
+ return isStable || isCandidate ? current.bundleURL : nil
519
+ } catch {
520
+ return nil
521
+ }
522
+ }
523
+ }
524
+
525
+ func setRevokedHashes(_ hashes: [String]) throws {
526
+ try withLock {
527
+ guard hashes.allSatisfy(Self.isCanonicalHash) else {
528
+ throw BundleDropStartupRecoveryError.invalidHash
529
+ }
530
+ var ledger = try readLedgerImportingLegacyState()
531
+ let normalized = Array(Set(hashes)).sorted()
532
+ guard normalized != ledger.revokedHashes else { return }
533
+ ledger.revokedHashes = normalized
534
+ try commit(&ledger)
535
+ }
536
+ }
537
+
538
+ func acknowledgeRecovery(eventId: String) throws -> Bool {
539
+ try withLock {
540
+ var ledger = try readLedgerImportingLegacyState()
541
+ let originalCount = ledger.pendingRecoveryEvents.count
542
+ ledger.pendingRecoveryEvents.removeAll { $0.id == eventId }
543
+ guard ledger.pendingRecoveryEvents.count != originalCount else { return false }
544
+ try commit(&ledger)
545
+ return true
546
+ }
547
+ }
548
+
549
+ func rollback(forceEmbedded: Bool) throws -> BundleDropStartupRollbackResult {
550
+ try withLock {
551
+ var ledger = try readLedgerImportingLegacyState()
552
+ let current = BundleDropOtaResolver.readPointer(
553
+ named: "current.json",
554
+ bundleDropRoot: bundleDropRoot,
555
+ expectedRuntimeVersion: expectedRuntimeVersion,
556
+ fileManager: fileManager
557
+ )
558
+ let fallbackHash = forceEmbedded ? nil : provenFallbackHash(
559
+ failedHash: current?.hash,
560
+ ledger: ledger
561
+ )
562
+ let fallback = fallbackHash.flatMap { hash in
563
+ verifiedPreviousPointer(hash: hash, ledger: ledger)
564
+ }
565
+
566
+ ledger.phase = fallback == nil ? .idle : .stable
567
+ ledger.candidateHash = nil
568
+ ledger.previousStableHash = nil
569
+ ledger.stableHash = fallback?.hash
570
+ ledger.lastHealthyAttemptId = nil
571
+ ledger.activeAttempt = nil
572
+ ledger.reservedAttemptId = nil
573
+ ledger.policy = nil
574
+ ledger.pendingTransition = BundleDropStartupRecoveryTransition(
575
+ kind: "rollback",
576
+ targetHash: fallback?.hash
577
+ )
578
+ try commit(&ledger)
579
+ try failpoint?("afterRollbackPrepared")
580
+ try completePendingTransition(ledger: &ledger)
581
+ return BundleDropStartupRollbackResult(
582
+ rolledBack: current != nil,
583
+ toEmbedded: fallback == nil,
584
+ hash: fallback?.hash
585
+ )
586
+ }
587
+ }
588
+
589
+ func snapshot() throws -> [String: Any] {
590
+ try withLock {
591
+ let ledger = try readLedgerImportingLegacyState()
592
+ var result: [String: Any] = [
593
+ "protocolVersion": Self.protocolVersion,
594
+ "revision": ledger.revision,
595
+ "phase": ledger.phase.rawValue,
596
+ "quarantinedHashes": ledger.quarantinedHashes.sorted(),
597
+ "pendingRecoveryEvents": ledger.pendingRecoveryEvents.map(Self.eventDictionary),
598
+ ]
599
+ if let candidateHash = ledger.candidateHash {
600
+ result["candidateHash"] = candidateHash
601
+ }
602
+ if let stableHash = ledger.stableHash {
603
+ result["stableHash"] = stableHash
604
+ }
605
+ if let policy = ledger.policy {
606
+ result["policy"] = [
607
+ "maxCrashCount": policy.maxCrashCount,
608
+ "healthCheckMode": policy.healthCheckMode,
609
+ "healthyAfterSec": policy.healthyAfterSec,
610
+ ]
611
+ }
612
+ if let attempt = ledger.activeAttempt, ledger.phase == .launching {
613
+ result["activeAttempt"] = [
614
+ "hash": attempt.hash,
615
+ "attemptId": attempt.attemptId,
616
+ "status": "launching",
617
+ "unacknowledgedLaunchCount": attempt.unacknowledgedLaunchCount,
618
+ ]
619
+ } else {
620
+ result["activeAttempt"] = NSNull()
621
+ }
622
+ return result
623
+ }
624
+ }
625
+
626
+ private func recover(
627
+ failedHash: String,
628
+ crashCount: Int,
629
+ quarantine: Bool,
630
+ emitEvent: Bool,
631
+ ledger: inout BundleDropStartupRecoveryLedger
632
+ ) throws -> BundleDropStartupSelection {
633
+ let fallbackHash = provenFallbackHash(failedHash: failedHash, ledger: ledger)
634
+ let fallback = fallbackHash.flatMap { hash in
635
+ verifiedPreviousPointer(hash: hash, ledger: ledger)
636
+ }
637
+
638
+ if quarantine {
639
+ ledger.quarantinedHashes = Array(Set(ledger.quarantinedHashes + [failedHash])).sorted()
640
+ }
641
+ if emitEvent {
642
+ ledger.pendingRecoveryEvents.append(BundleDropStartupRecoveryEvent(
643
+ id: makeId(),
644
+ failedHash: failedHash,
645
+ recoveryTarget: fallback == nil ? "embedded" : "previous",
646
+ recoveredHash: fallback?.hash,
647
+ crashCount: crashCount,
648
+ reason: "crash_loop",
649
+ failedAt: now()
650
+ ))
651
+ if ledger.pendingRecoveryEvents.count > 20 {
652
+ ledger.pendingRecoveryEvents.removeFirst(ledger.pendingRecoveryEvents.count - 20)
653
+ }
654
+ }
655
+
656
+ ledger.phase = .recovered
657
+ ledger.candidateHash = failedHash
658
+ ledger.previousStableHash = nil
659
+ ledger.stableHash = fallback?.hash
660
+ ledger.lastHealthyAttemptId = nil
661
+ ledger.activeAttempt = nil
662
+ ledger.reservedAttemptId = nil
663
+ ledger.policy = nil
664
+ ledger.pendingTransition = BundleDropStartupRecoveryTransition(
665
+ kind: "recovery",
666
+ targetHash: fallback?.hash
667
+ )
668
+ try commit(&ledger)
669
+ try failpoint?("afterRecoveryPrepared")
670
+ try completePendingTransition(ledger: &ledger)
671
+ return BundleDropStartupSelection(
672
+ bundleURL: fallback?.bundleURL,
673
+ attemptHash: nil,
674
+ attemptId: nil
675
+ )
676
+ }
677
+
678
+ private func completePendingTransition(
679
+ ledger: inout BundleDropStartupRecoveryLedger
680
+ ) throws {
681
+ guard var transition = ledger.pendingTransition else { return }
682
+ if let targetHash = transition.targetHash,
683
+ !isPendingTransitionTargetEligible(targetHash, ledger: ledger) {
684
+ transition = BundleDropStartupRecoveryTransition(
685
+ kind: transition.kind,
686
+ targetHash: nil
687
+ )
688
+ ledger.stableHash = nil
689
+ ledger.previousStableHash = nil
690
+ ledger.pendingTransition = transition
691
+ if transition.kind == "recovery",
692
+ let eventIndex = ledger.pendingRecoveryEvents.lastIndex(where: {
693
+ $0.recoveryTarget == "previous" && $0.recoveredHash == targetHash
694
+ }) {
695
+ let event = ledger.pendingRecoveryEvents[eventIndex]
696
+ ledger.pendingRecoveryEvents[eventIndex] = BundleDropStartupRecoveryEvent(
697
+ id: event.id,
698
+ failedHash: event.failedHash,
699
+ recoveryTarget: "embedded",
700
+ recoveredHash: nil,
701
+ crashCount: event.crashCount,
702
+ reason: event.reason,
703
+ failedAt: event.failedAt
704
+ )
705
+ }
706
+ // Persist the downgrade before touching pointers so another interruption
707
+ // can only resume toward embedded, never toward the unavailable target.
708
+ try commit(&ledger)
709
+ }
710
+ try applyPendingPointerTransition(transition)
711
+ ledger.pendingTransition = nil
712
+ try commit(&ledger)
713
+ }
714
+
715
+ private func applyPendingPointerTransition(
716
+ _ transition: BundleDropStartupRecoveryTransition
717
+ ) throws {
718
+ guard transition.kind == "recovery" || transition.kind == "rollback" else {
719
+ throw BundleDropStartupRecoveryError.ledgerCorrupt
720
+ }
721
+ let failpointPrefix = transition.kind == "recovery" ? "recoveryCurrent" : "rollbackCurrent"
722
+ if let targetHash = transition.targetHash {
723
+ guard BundleDropOtaResolver.readBundle(
724
+ hash: targetHash,
725
+ bundleDropRoot: bundleDropRoot,
726
+ expectedRuntimeVersion: expectedRuntimeVersion,
727
+ fileManager: fileManager
728
+ ) != nil else {
729
+ throw BundleDropStartupRecoveryError.candidateUnavailable
730
+ }
731
+ try writePointer(named: "current.json", hash: targetHash, failpointPrefix: failpointPrefix)
732
+ } else {
733
+ try deleteCurrentPointer(failpointPrefix: failpointPrefix)
734
+ }
735
+ try? BundleDropOtaResolver.deletePointer(
736
+ named: "previous.json",
737
+ bundleDropRoot: bundleDropRoot,
738
+ fileManager: fileManager
739
+ )
740
+ }
741
+
742
+ private func isPendingTransitionTargetEligible(
743
+ _ hash: String,
744
+ ledger: BundleDropStartupRecoveryLedger
745
+ ) -> Bool {
746
+ guard hasExpectedIdentity,
747
+ ledger.binaryIdentity == expectedBinaryIdentity,
748
+ ledger.runtimeIdentity == expectedRuntimeVersion,
749
+ !ledger.quarantinedHashes.contains(hash),
750
+ !ledger.revokedHashes.contains(hash) else {
751
+ return false
752
+ }
753
+ return BundleDropOtaResolver.readBundle(
754
+ hash: hash,
755
+ bundleDropRoot: bundleDropRoot,
756
+ expectedRuntimeVersion: expectedRuntimeVersion,
757
+ fileManager: fileManager
758
+ ) != nil
759
+ }
760
+
761
+ private func provenFallbackHash(
762
+ failedHash: String?,
763
+ ledger: BundleDropStartupRecoveryLedger
764
+ ) -> String? {
765
+ guard let failedHash else { return nil }
766
+ if ledger.candidateHash == failedHash {
767
+ return ledger.stableHash
768
+ }
769
+ if ledger.stableHash == failedHash {
770
+ return ledger.previousStableHash
771
+ }
772
+ return nil
773
+ }
774
+
775
+ private func verifiedPreviousPointer(
776
+ hash: String,
777
+ ledger: BundleDropStartupRecoveryLedger
778
+ ) -> BundleDropOtaPointer? {
779
+ guard hasExpectedIdentity,
780
+ !ledger.quarantinedHashes.contains(hash),
781
+ !ledger.revokedHashes.contains(hash) else {
782
+ return nil
783
+ }
784
+ let previous = BundleDropOtaResolver.readPointer(
785
+ named: "previous.json",
786
+ bundleDropRoot: bundleDropRoot,
787
+ expectedRuntimeVersion: expectedRuntimeVersion,
788
+ fileManager: fileManager
789
+ )
790
+ return previous?.hash == hash ? previous : nil
791
+ }
792
+
793
+ private func isCurrentBundleEligible(
794
+ hash: String,
795
+ ledger: BundleDropStartupRecoveryLedger
796
+ ) -> Bool {
797
+ guard hasExpectedIdentity,
798
+ ledger.binaryIdentity == expectedBinaryIdentity,
799
+ ledger.runtimeIdentity == expectedRuntimeVersion,
800
+ !ledger.quarantinedHashes.contains(hash),
801
+ !ledger.revokedHashes.contains(hash),
802
+ let current = BundleDropOtaResolver.readPointer(
803
+ named: "current.json",
804
+ bundleDropRoot: bundleDropRoot,
805
+ expectedRuntimeVersion: expectedRuntimeVersion,
806
+ fileManager: fileManager
807
+ ),
808
+ current.hash == hash else {
809
+ return false
810
+ }
811
+ return BundleDropOtaResolver.readBundle(
812
+ hash: hash,
813
+ bundleDropRoot: bundleDropRoot,
814
+ expectedRuntimeVersion: expectedRuntimeVersion,
815
+ fileManager: fileManager
816
+ ) != nil
817
+ }
818
+
819
+ private func readLedgerImportingLegacyState() throws -> BundleDropStartupRecoveryLedger {
820
+ var ledger = try readLedgerFromDisk() ?? BundleDropStartupRecoveryLedger()
821
+ try bindLedgerToExpectedIdentity(&ledger)
822
+ guard ledger.legacyFailuresImported != true else {
823
+ return ledger
824
+ }
825
+
826
+ if fileManager.fileExists(atPath: legacyStateURL.path),
827
+ let data = try? Data(contentsOf: legacyStateURL),
828
+ let legacy = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
829
+ let failedBundles = legacy["failedBundles"] as? [String: Any] {
830
+ let imported = Self.newestLegacyFailureHashes(failedBundles)
831
+ let merged = Array(Set(ledger.quarantinedHashes + imported)).sorted()
832
+ ledger.quarantinedHashes = merged
833
+ }
834
+ ledger.legacyFailuresImported = true
835
+ try commit(&ledger)
836
+ return ledger
837
+ }
838
+
839
+ private var hasExpectedIdentity: Bool {
840
+ expectedRuntimeVersion?.isEmpty == false && expectedBinaryIdentity?.isEmpty == false
841
+ }
842
+
843
+ private func bindLedgerToExpectedIdentity(
844
+ _ ledger: inout BundleDropStartupRecoveryLedger
845
+ ) throws {
846
+ guard let runtimeIdentity = expectedRuntimeVersion,
847
+ !runtimeIdentity.isEmpty,
848
+ let binaryIdentity = expectedBinaryIdentity,
849
+ !binaryIdentity.isEmpty else {
850
+ throw BundleDropStartupRecoveryError.candidateUnavailable
851
+ }
852
+ guard ledger.runtimeIdentity != runtimeIdentity || ledger.binaryIdentity != binaryIdentity else {
853
+ return
854
+ }
855
+
856
+ let previousRevision = ledger.revision
857
+ ledger = BundleDropStartupRecoveryLedger()
858
+ ledger.revision = previousRevision
859
+ ledger.runtimeIdentity = runtimeIdentity
860
+ ledger.binaryIdentity = binaryIdentity
861
+ try BundleDropOtaResolver.deletePointer(
862
+ named: "current.json",
863
+ bundleDropRoot: bundleDropRoot,
864
+ fileManager: fileManager
865
+ )
866
+ try BundleDropOtaResolver.deletePointer(
867
+ named: "previous.json",
868
+ bundleDropRoot: bundleDropRoot,
869
+ fileManager: fileManager
870
+ )
871
+ try commit(&ledger)
872
+ }
873
+
874
+ private func readLedgerFromDisk() throws -> BundleDropStartupRecoveryLedger? {
875
+ guard fileManager.fileExists(atPath: ledgerURL.path) else { return nil }
876
+ do {
877
+ let ledger = try JSONDecoder().decode(
878
+ BundleDropStartupRecoveryLedger.self,
879
+ from: Data(contentsOf: ledgerURL)
880
+ )
881
+ guard Self.isValid(ledger) else {
882
+ throw BundleDropStartupRecoveryError.ledgerCorrupt
883
+ }
884
+ return ledger
885
+ } catch let error as BundleDropStartupRecoveryError {
886
+ throw error
887
+ } catch {
888
+ throw BundleDropStartupRecoveryError.ledgerCorrupt
889
+ }
890
+ }
891
+
892
+ private func repairCorruptLedger() -> BundleDropStartupSelection {
893
+ guard let runtimeIdentity = expectedRuntimeVersion,
894
+ !runtimeIdentity.isEmpty,
895
+ let binaryIdentity = expectedBinaryIdentity,
896
+ !binaryIdentity.isEmpty else {
897
+ return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
898
+ }
899
+
900
+ let currentHash = BundleDropOtaResolver.readPointer(
901
+ named: "current.json",
902
+ bundleDropRoot: bundleDropRoot,
903
+ expectedRuntimeVersion: expectedRuntimeVersion,
904
+ fileManager: fileManager
905
+ )?.hash
906
+ var replacement = BundleDropStartupRecoveryLedger()
907
+ replacement.revision = 1
908
+ replacement.binaryIdentity = binaryIdentity
909
+ replacement.runtimeIdentity = runtimeIdentity
910
+ replacement.legacyFailuresImported = true
911
+ replacement.phase = .recovered
912
+ replacement.quarantinedHashes = currentHash.map { [$0] } ?? []
913
+
914
+ do {
915
+ Self.ledgerCommitLock.lock()
916
+ defer { Self.ledgerCommitLock.unlock() }
917
+ try writeLedgerAtomically(replacement)
918
+ try BundleDropOtaResolver.deletePointer(
919
+ named: "current.json",
920
+ bundleDropRoot: bundleDropRoot,
921
+ fileManager: fileManager
922
+ )
923
+ try BundleDropOtaResolver.deletePointer(
924
+ named: "previous.json",
925
+ bundleDropRoot: bundleDropRoot,
926
+ fileManager: fileManager
927
+ )
928
+ } catch {
929
+ // The caller still fails closed to embedded. A later launch can retry the
930
+ // repair without trusting any health claim from the corrupt ledger.
931
+ }
932
+ return BundleDropStartupSelection(bundleURL: nil, attemptHash: nil, attemptId: nil)
933
+ }
934
+
935
+ private func commit(_ ledger: inout BundleDropStartupRecoveryLedger) throws {
936
+ ledger.schemaVersion = Self.protocolVersion
937
+ try fileManager.createDirectory(at: bundleDropRoot, withIntermediateDirectories: true)
938
+ try failpoint?("beforeLedgerWrite")
939
+ Self.ledgerCommitLock.lock()
940
+ do {
941
+ let persistedRevision = try readLedgerFromDisk()?.revision ?? 0
942
+ guard persistedRevision == ledger.revision else {
943
+ throw BundleDropStartupRecoveryError.staleLedger
944
+ }
945
+ ledger.revision += 1
946
+ } catch {
947
+ Self.ledgerCommitLock.unlock()
948
+ throw error
949
+ }
950
+ do {
951
+ try writeLedgerAtomically(ledger)
952
+ } catch {
953
+ Self.ledgerCommitLock.unlock()
954
+ throw error
955
+ }
956
+ Self.ledgerCommitLock.unlock()
957
+ try failpoint?("afterLedgerWrite")
958
+ }
959
+
960
+ private func writeLedgerAtomically(_ ledger: BundleDropStartupRecoveryLedger) throws {
961
+ let encoder = JSONEncoder()
962
+ encoder.outputFormatting = [.sortedKeys]
963
+ let temporaryURL = bundleDropRoot.appendingPathComponent(
964
+ ".recovery-ledger-\(UUID().uuidString).tmp"
965
+ )
966
+ do {
967
+ try encoder.encode(ledger).write(to: temporaryURL)
968
+ let handle = try FileHandle(forWritingTo: temporaryURL)
969
+ try handle.synchronize()
970
+ try handle.close()
971
+ if fileManager.fileExists(atPath: ledgerURL.path) {
972
+ _ = try fileManager.replaceItemAt(ledgerURL, withItemAt: temporaryURL)
973
+ } else {
974
+ try fileManager.moveItem(at: temporaryURL, to: ledgerURL)
975
+ }
976
+ } catch {
977
+ try? fileManager.removeItem(at: temporaryURL)
978
+ throw error
979
+ }
980
+ }
981
+
982
+ private func writePointer(named filename: String, hash: String, failpointPrefix: String) throws {
983
+ try failpoint?("before\(failpointPrefix.prefix(1).uppercased())\(failpointPrefix.dropFirst())Write")
984
+ try BundleDropOtaResolver.writePointer(
985
+ named: filename,
986
+ hash: hash,
987
+ bundleDropRoot: bundleDropRoot,
988
+ fileManager: fileManager
989
+ )
990
+ try failpoint?("after\(failpointPrefix.prefix(1).uppercased())\(failpointPrefix.dropFirst())Write")
991
+ }
992
+
993
+ private func deleteCurrentPointer(failpointPrefix: String) throws {
994
+ try failpoint?("before\(failpointPrefix.prefix(1).uppercased())\(failpointPrefix.dropFirst())Delete")
995
+ try BundleDropOtaResolver.deletePointer(
996
+ named: "current.json",
997
+ bundleDropRoot: bundleDropRoot,
998
+ fileManager: fileManager
999
+ )
1000
+ try failpoint?("after\(failpointPrefix.prefix(1).uppercased())\(failpointPrefix.dropFirst())Delete")
1001
+ }
1002
+
1003
+ private func withLock<T>(_ operation: () throws -> T) rethrows -> T {
1004
+ lock.lock()
1005
+ defer { lock.unlock() }
1006
+ return try operation()
1007
+ }
1008
+
1009
+ private static func isCanonicalHash(_ value: String) -> Bool {
1010
+ value.range(of: "^[a-f0-9]{64}$", options: .regularExpression) != nil
1011
+ }
1012
+
1013
+ private static func newestLegacyFailureHashes(
1014
+ _ failedBundles: [String: Any]
1015
+ ) -> [String] {
1016
+ failedBundles.compactMap { hash, value -> (hash: String, failedAt: Double?)? in
1017
+ guard isCanonicalHash(hash) else { return nil }
1018
+ let record = value as? [String: Any]
1019
+ let rawFailedAt = record?["failedAt"]
1020
+ let number = rawFailedAt is Bool ? nil : rawFailedAt as? NSNumber
1021
+ let failedAt = number?.doubleValue
1022
+ return (
1023
+ hash,
1024
+ failedAt.flatMap { $0.isFinite && $0 >= 0 ? $0 : nil }
1025
+ )
1026
+ }
1027
+ .sorted { left, right in
1028
+ switch (left.failedAt, right.failedAt) {
1029
+ case let (leftDate?, rightDate?) where leftDate != rightDate:
1030
+ return leftDate > rightDate
1031
+ case (_?, nil):
1032
+ return true
1033
+ case (nil, _?):
1034
+ return false
1035
+ default:
1036
+ return left.hash < right.hash
1037
+ }
1038
+ }
1039
+ .prefix(20)
1040
+ .map(\.hash)
1041
+ }
1042
+
1043
+ private static func isValid(_ ledger: BundleDropStartupRecoveryLedger) -> Bool {
1044
+ guard ledger.schemaVersion == protocolVersion,
1045
+ ledger.revision >= 0,
1046
+ ledger.binaryIdentity.map({ !$0.isEmpty }) ?? true,
1047
+ ledger.runtimeIdentity.map({ !$0.isEmpty }) ?? true,
1048
+ [ledger.candidateHash, ledger.stableHash, ledger.previousStableHash]
1049
+ .compactMap({ $0 })
1050
+ .allSatisfy(isCanonicalHash),
1051
+ ledger.quarantinedHashes.allSatisfy(isCanonicalHash),
1052
+ ledger.revokedHashes.allSatisfy(isCanonicalHash),
1053
+ Set(ledger.quarantinedHashes).count == ledger.quarantinedHashes.count,
1054
+ Set(ledger.revokedHashes).count == ledger.revokedHashes.count else {
1055
+ return false
1056
+ }
1057
+ if let policy = ledger.policy,
1058
+ policy.maxCrashCount < 0 ||
1059
+ !policy.healthyAfterSec.isFinite ||
1060
+ policy.healthyAfterSec < 0 ||
1061
+ (policy.healthCheckMode != "auto" && policy.healthCheckMode != "manual") {
1062
+ return false
1063
+ }
1064
+ if let attempt = ledger.activeAttempt,
1065
+ !isCanonicalHash(attempt.hash) ||
1066
+ attempt.attemptId.isEmpty ||
1067
+ attempt.processToken.isEmpty ||
1068
+ attempt.unacknowledgedLaunchCount < 0 {
1069
+ return false
1070
+ }
1071
+ if let reservedAttemptId = ledger.reservedAttemptId, reservedAttemptId.isEmpty {
1072
+ return false
1073
+ }
1074
+ if let lastHealthyAttemptId = ledger.lastHealthyAttemptId, lastHealthyAttemptId.isEmpty {
1075
+ return false
1076
+ }
1077
+ if let transition = ledger.pendingTransition,
1078
+ (transition.kind != "recovery" && transition.kind != "rollback") ||
1079
+ (transition.targetHash != nil && !isCanonicalHash(transition.targetHash!)) {
1080
+ return false
1081
+ }
1082
+ return ledger.pendingRecoveryEvents.allSatisfy { event in
1083
+ !event.id.isEmpty &&
1084
+ isCanonicalHash(event.failedHash) &&
1085
+ event.crashCount >= 0 &&
1086
+ event.failedAt >= 0 &&
1087
+ event.reason == "crash_loop" &&
1088
+ ((event.recoveryTarget == "embedded" && event.recoveredHash == nil) ||
1089
+ (event.recoveryTarget == "previous" &&
1090
+ event.recoveredHash.map(isCanonicalHash) == true))
1091
+ }
1092
+ }
1093
+
1094
+ private static func eventDictionary(_ event: BundleDropStartupRecoveryEvent) -> [String: Any] {
1095
+ var result: [String: Any] = [
1096
+ "id": event.id,
1097
+ "failedHash": event.failedHash,
1098
+ "recoveryTarget": event.recoveryTarget,
1099
+ "crashCount": event.crashCount,
1100
+ "reason": event.reason,
1101
+ "failedAt": event.failedAt,
1102
+ ]
1103
+ if let recoveredHash = event.recoveredHash {
1104
+ result["recoveredHash"] = recoveredHash
1105
+ }
1106
+ return result
1107
+ }
1108
+ }