@adea-ai/app-framework 0.26.0 → 0.28.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 (138) hide show
  1. package/README.md +183 -17
  2. package/dist/app/create-application.d.ts +2 -0
  3. package/dist/app/create-application.js +6 -0
  4. package/dist/app/service-registry.js +4 -0
  5. package/dist/appearance/custom-theme-import.js +43 -7
  6. package/dist/appearance/custom-theme-library.d.ts +2 -0
  7. package/dist/appearance/custom-theme-library.js +5 -1
  8. package/dist/appearance/theme-record-adapter.js +4 -2
  9. package/dist/appearance/theme-registry.js +7 -1
  10. package/dist/cli/cef-helper-cli.js +0 -0
  11. package/dist/cli/create-application-cli.js +4 -2
  12. package/dist/cli/electrobun-shortcut-patch-cli.js +0 -0
  13. package/dist/cli/framework-update-cli.js +0 -0
  14. package/dist/cli/macos-signing-cli.js +0 -0
  15. package/dist/cli/release-assets-plan-cli.js +0 -0
  16. package/dist/cli/release-cut-cli.js +0 -0
  17. package/dist/cli/release-descriptor-staging-cli.js +0 -0
  18. package/dist/cli/release-finalize-cli.js +0 -0
  19. package/dist/cli/release-promote-cli.js +0 -0
  20. package/dist/cli/release-publish-cli.js +0 -0
  21. package/dist/cli/release-sign-cli.js +0 -0
  22. package/dist/cli/release-step-cli.js +6 -1
  23. package/dist/cli/toolchain-identity-cli.js +0 -0
  24. package/dist/cli/update-helper-cli.js +28 -6
  25. package/dist/cli/windows-runtime-patch-cli.js +0 -0
  26. package/dist/desktop/client-asset-manifest.d.ts +47 -0
  27. package/dist/desktop/client-asset-manifest.js +114 -0
  28. package/dist/desktop/client-asset-stream.d.ts +10 -0
  29. package/dist/desktop/client-asset-stream.js +138 -33
  30. package/dist/desktop/client-assets.d.ts +20 -0
  31. package/dist/desktop/client-assets.js +132 -22
  32. package/dist/desktop/client-response-lifecycle.d.ts +22 -0
  33. package/dist/desktop/client-response-lifecycle.js +233 -0
  34. package/dist/desktop/desktop-host.d.ts +40 -2
  35. package/dist/desktop/desktop-host.js +159 -9
  36. package/dist/framework-source.json +1 -1
  37. package/dist/installer/command-artifact.d.ts +4 -2
  38. package/dist/installer/command-artifact.js +119 -19
  39. package/dist/installer/installer-identity.d.ts +4 -1
  40. package/dist/installer/installer-identity.js +6 -3
  41. package/dist/installer/installer-layout.d.ts +2 -0
  42. package/dist/installer/installer-layout.js +5 -1
  43. package/dist/installer/linux-process-group.d.ts +13 -0
  44. package/dist/installer/linux-process-group.js +58 -0
  45. package/dist/native/darwin-sync.d.ts +7 -0
  46. package/dist/native/darwin-sync.js +43 -0
  47. package/dist/native/desktop-build-hook.js +7 -0
  48. package/dist/native/directory-exchange.d.ts +10 -0
  49. package/dist/native/directory-exchange.js +90 -0
  50. package/dist/native/electrobun-source-patch.d.ts +5 -0
  51. package/dist/native/electrobun-source-patch.js +19 -1
  52. package/dist/native/posix-launcher-build.d.ts +24 -0
  53. package/dist/native/posix-launcher-build.js +232 -0
  54. package/dist/native/posix-tree-removal.d.ts +36 -0
  55. package/dist/native/posix-tree-removal.js +425 -0
  56. package/dist/release/release-steps.d.ts +5 -0
  57. package/dist/release/release-steps.js +2 -1
  58. package/dist/update-helper.bundle.js +1483 -105
  59. package/dist/updates/channel-update-manager.d.ts +5 -0
  60. package/dist/updates/channel-update-manager.js +13 -1
  61. package/dist/updates/desktop-updater.d.ts +78 -2
  62. package/dist/updates/desktop-updater.js +320 -37
  63. package/dist/updates/launch-environment.d.ts +2 -0
  64. package/dist/updates/launch-environment.js +4 -0
  65. package/dist/updates/native-file-lock.d.ts +15 -0
  66. package/dist/updates/native-file-lock.js +189 -0
  67. package/dist/updates/packaged-launch-admission.d.ts +13 -0
  68. package/dist/updates/packaged-launch-admission.js +45 -0
  69. package/dist/updates/packaged-release-config.d.ts +18 -0
  70. package/dist/updates/packaged-release-config.js +60 -0
  71. package/dist/updates/packaged-update-startup.d.ts +44 -0
  72. package/dist/updates/packaged-update-startup.js +81 -0
  73. package/dist/updates/update-arm.d.ts +9 -8
  74. package/dist/updates/update-arm.js +227 -62
  75. package/dist/updates/update-cleanup-error.d.ts +23 -0
  76. package/dist/updates/update-cleanup-error.js +65 -0
  77. package/dist/updates/update-download-cleanup.d.ts +11 -0
  78. package/dist/updates/update-download-cleanup.js +112 -2
  79. package/dist/updates/update-download-lock.d.ts +20 -0
  80. package/dist/updates/update-download-lock.js +73 -0
  81. package/dist/updates/update-download.d.ts +2 -0
  82. package/dist/updates/update-download.js +7 -3
  83. package/dist/updates/update-generation-lease.d.ts +6 -0
  84. package/dist/updates/update-generation-lease.js +14 -0
  85. package/dist/updates/update-helper.d.ts +11 -2
  86. package/dist/updates/update-helper.js +322 -13
  87. package/dist/updates/update-inherited-launch-lease.d.ts +22 -0
  88. package/dist/updates/update-inherited-launch-lease.js +58 -0
  89. package/dist/updates/update-instance-lease.d.ts +15 -0
  90. package/dist/updates/update-instance-lease.js +25 -0
  91. package/dist/updates/update-launch-gate.d.ts +137 -0
  92. package/dist/updates/update-launch-gate.js +617 -0
  93. package/dist/updates/update-launch.js +3 -1
  94. package/dist/updates/update-lock.d.ts +12 -0
  95. package/dist/updates/update-lock.js +18 -0
  96. package/dist/updates/update-manager.d.ts +2 -0
  97. package/dist/updates/update-manager.js +9 -2
  98. package/dist/updates/update-marker.d.ts +7 -0
  99. package/dist/updates/update-marker.js +62 -0
  100. package/dist/updates/update-preflight-error.d.ts +7 -0
  101. package/dist/updates/update-preflight-error.js +11 -0
  102. package/dist/updates/update-process-fence.d.ts +4 -0
  103. package/dist/updates/update-process-fence.js +85 -73
  104. package/dist/updates/update-process-liveness.d.ts +2 -0
  105. package/dist/updates/update-process-liveness.js +11 -0
  106. package/dist/updates/update-resume.d.ts +37 -3
  107. package/dist/updates/update-resume.js +839 -23
  108. package/dist/updates/update-retention-marker.d.ts +67 -0
  109. package/dist/updates/update-retention-marker.js +165 -0
  110. package/dist/updates/update-retention-plan.d.ts +25 -0
  111. package/dist/updates/update-retention-plan.js +54 -0
  112. package/dist/updates/update-retention-sync.d.ts +34 -0
  113. package/dist/updates/update-retention-sync.js +83 -0
  114. package/dist/updates/update-retirement.d.ts +205 -0
  115. package/dist/updates/update-retirement.js +1485 -0
  116. package/dist/updates/update-shutdown.d.ts +16 -4
  117. package/dist/updates/update-shutdown.js +133 -8
  118. package/dist/updates/update-state-store.d.ts +58 -0
  119. package/dist/updates/update-state-store.js +139 -0
  120. package/dist/updates/update-swap-stage.d.ts +1 -1
  121. package/dist/updates/update-swap-stage.js +85 -14
  122. package/dist/updates/update-swap.d.ts +45 -2
  123. package/dist/updates/update-swap.js +207 -17
  124. package/package.json +31 -1
  125. package/src/appearance/custom-theme-import.ts +96 -14
  126. package/src/appearance/custom-theme-library.ts +5 -0
  127. package/src/appearance/theme-record-adapter.ts +15 -6
  128. package/src/appearance/theme-registry.ts +8 -1
  129. package/src/desktop/client-asset-manifest.ts +207 -0
  130. package/src/desktop/client-asset-stream.ts +193 -32
  131. package/src/desktop/client-assets.ts +210 -19
  132. package/src/desktop/client-response-lifecycle.ts +305 -0
  133. package/src/native/electrobun-posix-launch-lease.patch +398 -0
  134. package/templates/application/README.md +50 -0
  135. package/templates/application/electrobun.config.ts +5 -1
  136. package/templates/application/scripts/build-desktop.ts +4 -0
  137. package/templates/application/src/bun/index.ts +173 -16
  138. package/templates/application/vite.config.ts +112 -6
@@ -1,34 +1,850 @@
1
- import { updateStagingFor } from "./update-swap.js";
2
- import { lstat, readFile, rm } from "node:fs/promises";
1
+ import { verifyReleaseDescriptor } from "./signed-release.js";
2
+ import { renameUpdateExclusive } from "./update-exclusive-rename.js";
3
+ import { tryAcquireUpdateLock } from "./update-lock.js";
4
+ import { UpdateLockBusyError, acquireUpdateLock, readUpdateStageState, syncUpdateStageDirectory, writeUpdateStageState, writeUpdateStageStateDurably } from "./update-state-store.js";
5
+ import { readUpdateTreeDigest, readUpdateTreeIdentity, readUpdateTreeVersion, sameUpdateTreeDigest, sameUpdateTreeIdentity, syncUpdateTreeParent, updateStagingFor } from "./update-swap.js";
6
+ import { readUpdateMarker } from "./update-marker.js";
7
+ import { tryAcquireUpdateInstanceLease } from "./update-instance-lease.js";
8
+ import { readUpdateLaunchGate, tryAcquireUpdateHelperLiveness, tryRecoverUpdateLaunchGate } from "./update-launch-gate.js";
9
+ import { hasUpdateHelperArtifacts, parseUpdateHelperRequest } from "./update-helper.js";
10
+ import { updateProcessMayBeAlive } from "./update-process-liveness.js";
11
+ import { acquireRetainedUpdateTrees, acquireRetainedUpdateTreesWhileLocked, reconcileRetirementCleanupMarkerWhileLocked, retireCompletedUpdateWhileLocked } from "./update-retirement.js";
12
+ import { lstat, open, readFile, readdir, realpath, rm, rmdir, unlink } from "node:fs/promises";
3
13
  import { join } from "node:path";
14
+ import { constants as constants$1 } from "node:fs";
15
+ import { randomUUID } from "node:crypto";
4
16
  // src/updates/update-resume.ts
5
- function alive(pid) {
17
+ async function exists(path) {
18
+ return lstat(path).then(() => true, (error) => {
19
+ if (error.code === "ENOENT") return false;
20
+ throw error;
21
+ });
22
+ }
23
+ /** Validate the empty extraction remainder left by the legacy stage publisher. */
24
+ async function isLegacyExtractionRemainder(path) {
25
+ const info = await lstat(path);
26
+ if (!info.isDirectory() || info.isSymbolicLink()) return false;
27
+ const entries = await readdir(path);
28
+ if (entries.length !== 1 || entries[0] !== "payload") return false;
29
+ const payload = join(path, "payload");
30
+ const payloadInfo = await lstat(payload);
31
+ return payloadInfo.isDirectory() && !payloadInfo.isSymbolicLink() && (await readdir(payload)).length === 0;
32
+ }
33
+ async function readTreeDigestForProof(path) {
6
34
  try {
7
- process.kill(pid, 0);
8
- return true;
35
+ return await readUpdateTreeDigest(path);
36
+ } catch {
37
+ return;
38
+ }
39
+ }
40
+ /** Recover only layouts produced by a proven-exited legacy helper. */
41
+ async function recoverLegacyHandoff(options) {
42
+ const { target, staging, currentVersion, helperPid } = options;
43
+ if (!Number.isSafeInteger(helperPid) || helperPid < 2 || updateProcessMayBeAlive(helperPid)) return { status: "recovery-required" };
44
+ let request;
45
+ try {
46
+ const path = join(staging, "request.json");
47
+ const info = await lstat(path);
48
+ if (!info.isFile() || info.isSymbolicLink() || info.size < 1 || info.size > 65536) return { status: "recovery-required" };
49
+ request = parseUpdateHelperRequest(JSON.parse(await readFile(path, "utf8")));
50
+ } catch {
51
+ return { status: "recovery-required" };
52
+ }
53
+ const nativePlatform = process.platform === "darwin" && process.arch === "arm64" ? "macos-arm64" : process.platform === "win32" && process.arch === "x64" ? "windows-x64" : process.platform === "linux" && process.arch === "x64" ? "linux-x64" : void 0;
54
+ if (request.schema !== 1 || request.target !== target || request.platform !== nativePlatform || request.version === currentVersion) return { status: "recovery-required" };
55
+ const allowed = /* @__PURE__ */ new Set([
56
+ "candidate",
57
+ "helper",
58
+ "helper-armed",
59
+ "old",
60
+ "request.json"
61
+ ]);
62
+ for (const name of await readdir(staging)) {
63
+ if (allowed.has(name)) continue;
64
+ if (!/^framework-update-extract-[a-z0-9]{6}$/i.test(name)) return { status: "recovery-required" };
65
+ try {
66
+ if (!await isLegacyExtractionRemainder(join(staging, name))) return { status: "recovery-required" };
67
+ } catch {
68
+ return { status: "recovery-required" };
69
+ }
70
+ }
71
+ const candidate = join(staging, "candidate");
72
+ const old = join(staging, "old");
73
+ const [targetExists, candidateExists, oldExists] = await Promise.all([
74
+ exists(target),
75
+ exists(candidate),
76
+ exists(old)
77
+ ]);
78
+ if (!candidateExists || await readUpdateTreeVersion(candidate) !== request.version) return { status: "recovery-required" };
79
+ const candidateInfo = await lstat(candidate);
80
+ if (!candidateInfo.isDirectory() || candidateInfo.isSymbolicLink()) return { status: "recovery-required" };
81
+ if (!targetExists && oldExists) {
82
+ const oldInfo = await lstat(old);
83
+ if (!oldInfo.isDirectory() || oldInfo.isSymbolicLink() || await readUpdateTreeVersion(old) !== currentVersion) return { status: "recovery-required" };
84
+ renameUpdateExclusive(old, target);
85
+ } else if (targetExists && !oldExists) {
86
+ const targetInfo = await lstat(target);
87
+ if (!targetInfo.isDirectory() || targetInfo.isSymbolicLink() || await readUpdateTreeVersion(target) !== currentVersion) return { status: "recovery-required" };
88
+ } else return { status: "recovery-required" };
89
+ const archived = `${staging}.legacy-${randomUUID()}`;
90
+ renameUpdateExclusive(staging, archived);
91
+ return { status: "not-applied" };
92
+ }
93
+ async function resetToStaged(staging, state) {
94
+ const { helperPid: _helperPid, helperOwner: _helperOwner, previousTreeIdentity: _previousTreeIdentity, ...recoverable } = state;
95
+ const next = {
96
+ ...recoverable,
97
+ phase: "staged"
98
+ };
99
+ await clearHelperArtifacts(staging);
100
+ await writeUpdateStageState(staging, next);
101
+ return next;
102
+ }
103
+ async function clearHelperArtifacts(staging) {
104
+ await rm(join(staging, "request.json"), { force: true });
105
+ await rm(join(staging, "helper-armed"), { force: true });
106
+ await rm(join(staging, "helper-ready"), { force: true });
107
+ await rm(join(staging, "cancel.json"), { force: true });
108
+ await rm(join(staging, "cancel-ack.json"), { force: true });
109
+ await rm(join(staging, "helper"), {
110
+ recursive: true,
111
+ force: true
112
+ });
113
+ }
114
+ var knownStagingEntries = /* @__PURE__ */ new Set([
115
+ "candidate",
116
+ "helper",
117
+ "helper-armed",
118
+ "helper-ready",
119
+ "cancel.json",
120
+ "cancel-ack.json",
121
+ "request.json",
122
+ "state.json"
123
+ ]);
124
+ async function hasUnknownStagingEntries(staging, allowed = [], generation) {
125
+ const entries = await readdir(staging);
126
+ const stateTemporary = generation ? new RegExp(`^\\.state-${generation}-[0-9a-f-]{36}\\.tmp$`, "i") : void 0;
127
+ return entries.some((entry) => !knownStagingEntries.has(entry) && !allowed.includes(entry) && !(stateTemporary?.test(entry) ?? false));
128
+ }
129
+ async function reconcileSwap(target, staging, state) {
130
+ const candidate = join(staging, "candidate");
131
+ const old = join(staging, "old");
132
+ if (!await exists(target) && await exists(old) && await exists(candidate)) {
133
+ if (await hasUnknownStagingEntries(staging, ["old"], state.generation)) return void 0;
134
+ try {
135
+ const [oldInfo, candidateInfo] = await Promise.all([lstat(old), lstat(candidate)]);
136
+ const [oldIdentity, candidateIdentity] = await Promise.all([readUpdateTreeIdentity(old), readUpdateTreeIdentity(candidate)]);
137
+ if (!oldInfo.isDirectory() || oldInfo.isSymbolicLink() || !candidateInfo.isDirectory() || candidateInfo.isSymbolicLink() || !oldIdentity || !candidateIdentity || !sameUpdateTreeIdentity(candidateIdentity, state.candidateTreeIdentity) || sameUpdateTreeIdentity(oldIdentity, candidateIdentity) || state.previousTreeIdentity && !sameUpdateTreeIdentity(oldIdentity, state.previousTreeIdentity) || await readUpdateTreeVersion(old) !== state.previousVersion || await readUpdateTreeVersion(candidate) !== state.version || state.candidateTreeDigest !== void 0 && !sameUpdateTreeDigest(await readTreeDigestForProof(candidate), state.candidateTreeDigest)) return void 0;
138
+ renameUpdateExclusive(old, target);
139
+ return resetToStaged(staging, state);
140
+ } catch {
141
+ return;
142
+ }
143
+ }
144
+ if (await exists(old) || await hasUnknownStagingEntries(staging, [], state.generation) || !await exists(target) || !await exists(candidate)) return void 0;
145
+ try {
146
+ const [targetInfo, candidateInfo] = await Promise.all([lstat(target), lstat(candidate)]);
147
+ if (!targetInfo.isDirectory() || targetInfo.isSymbolicLink() || !candidateInfo.isDirectory() || candidateInfo.isSymbolicLink()) return void 0;
148
+ } catch {
149
+ return;
150
+ }
151
+ const [targetVersion, candidateVersion] = await Promise.all([readUpdateTreeVersion(target), readUpdateTreeVersion(candidate)]);
152
+ const [targetIdentity, candidateIdentity] = await Promise.all([readUpdateTreeIdentity(target), readUpdateTreeIdentity(candidate)]);
153
+ if (targetVersion === state.previousVersion && candidateVersion === state.version && targetIdentity !== void 0 && candidateIdentity !== void 0 && sameUpdateTreeIdentity(candidateIdentity, state.candidateTreeIdentity) && (state.candidateTreeDigest === void 0 || sameUpdateTreeDigest(await readTreeDigestForProof(candidate), state.candidateTreeDigest)) && !sameUpdateTreeIdentity(targetIdentity, candidateIdentity) && (!state.previousTreeIdentity || sameUpdateTreeIdentity(targetIdentity, state.previousTreeIdentity))) return resetToStaged(staging, state);
154
+ if (targetVersion === state.version && candidateVersion === state.previousVersion && sameUpdateTreeIdentity(targetIdentity, state.candidateTreeIdentity) && (state.candidateTreeDigest === void 0 || sameUpdateTreeDigest(await readTreeDigestForProof(target), state.candidateTreeDigest)) && sameUpdateTreeIdentity(candidateIdentity, state.previousTreeIdentity)) {
155
+ const completed = {
156
+ ...state,
157
+ phase: "completed"
158
+ };
159
+ await writeUpdateStageState(staging, completed);
160
+ return completed;
161
+ }
162
+ }
163
+ async function recoverStagedCandidate(options) {
164
+ const { target, staging, state, trust, currentVersion } = options;
165
+ if (!state.candidateTreeDigest && !options.allowDigestlessLegacy) return { status: "recovery-required" };
166
+ if (!state.signedRelease || state.previousVersion !== currentVersion) return { status: "recovery-required" };
167
+ const verified = verifyReleaseDescriptor(state.signedRelease, trust);
168
+ if (!verified.ok || verified.descriptor.version !== state.version) return { status: "recovery-required" };
169
+ if (await readUpdateTreeVersion(target) !== currentVersion) return { status: "recovery-required" };
170
+ const candidate = join(staging, "candidate");
171
+ let info;
172
+ try {
173
+ info = await lstat(candidate);
9
174
  } catch (error) {
10
- return error.code === "EPERM";
175
+ if (error.code === "ENOENT") return { status: "recovery-required" };
176
+ throw error;
11
177
  }
178
+ if (!info.isDirectory() || info.isSymbolicLink()) return { status: "recovery-required" };
179
+ if (await exists(join(staging, "old")) || await readUpdateTreeVersion(candidate) !== state.version || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(candidate), state.candidateTreeIdentity) || state.candidateTreeDigest !== void 0 && !sameUpdateTreeDigest(await readTreeDigestForProof(candidate), state.candidateTreeDigest)) return { status: "recovery-required" };
180
+ return {
181
+ status: "staged",
182
+ version: state.version,
183
+ channel: verified.descriptor.channel
184
+ };
12
185
  }
13
- /**
14
- * Call on app start. Reports whether an earlier helper installed an update and
15
- * removes the staging directory, unless a helper is still running from it.
16
- */
17
- async function resumeUpdate(options) {
18
- const staging = updateStagingFor(options.target);
19
- const info = await lstat(staging).catch(() => void 0);
20
- if (!info) return { status: "none" };
186
+ async function resumeLocked(options) {
187
+ const { target, staging, trust, currentVersion } = options;
188
+ const launchGate = await readUpdateLaunchGate(target);
189
+ if (!await exists(staging)) {
190
+ if (launchGate) return { status: "recovery-required" };
191
+ const cleanup = await reconcileRetirementCleanupMarkerWhileLocked({
192
+ target,
193
+ staging,
194
+ currentVersion
195
+ });
196
+ return cleanup === "none" ? { status: "none" } : cleanup === "updated" ? {
197
+ status: "updated",
198
+ version: currentVersion
199
+ } : { status: "recovery-required" };
200
+ }
201
+ const info = await lstat(staging);
21
202
  if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Unexpected update staging entry");
22
- const helper = Number(await readFile(join(staging, "helper-armed"), "utf8").catch(() => 0));
23
- if (Number.isSafeInteger(helper) && helper > 1 && helper !== process.pid && alive(helper)) return { status: "in-progress" };
24
- const version = await readFile(join(staging, "updated"), "utf8").catch(() => void 0);
25
- await rm(staging, {
203
+ let state = await readUpdateStageState(staging);
204
+ if (!state) {
205
+ if (launchGate) return { status: "recovery-required" };
206
+ const cleanup = await reconcileRetirementCleanupMarkerWhileLocked({
207
+ target,
208
+ staging,
209
+ currentVersion
210
+ });
211
+ if (cleanup !== "none") return cleanup === "updated" ? {
212
+ status: "updated",
213
+ version: currentVersion
214
+ } : { status: "recovery-required" };
215
+ const helper = Number(await readFile(join(staging, "helper-armed"), "utf8").catch(() => 0));
216
+ if (Number.isSafeInteger(helper) && helper > 1 && updateProcessMayBeAlive(helper)) return { status: "in-progress" };
217
+ const legacyVersion = await readFile(join(staging, "updated"), "utf8").catch(() => void 0);
218
+ if (legacyVersion && await readUpdateTreeVersion(target) === legacyVersion) {
219
+ const entries = await readdir(staging);
220
+ if (entries.length !== 1 || entries[0] !== "updated") return { status: "recovery-required" };
221
+ await unlink(join(staging, "updated"));
222
+ await rmdir(staging);
223
+ return {
224
+ status: "updated",
225
+ version: legacyVersion
226
+ };
227
+ }
228
+ if (Number.isSafeInteger(helper) && helper > 1) return recoverLegacyHandoff({
229
+ target,
230
+ staging,
231
+ currentVersion,
232
+ helperPid: helper
233
+ });
234
+ if ((await readdir(staging)).length === 0) {
235
+ await rmdir(staging);
236
+ return { status: "not-applied" };
237
+ }
238
+ return { status: "recovery-required" };
239
+ }
240
+ if (launchGate) {
241
+ if (state.launchGateOwner !== launchGate.owner || state.generation !== launchGate.generation || state.version !== launchGate.version) return { status: "recovery-required" };
242
+ if (state.helperPid && updateProcessMayBeAlive(state.helperPid)) return { status: "in-progress" };
243
+ return { status: "recovery-required" };
244
+ }
245
+ if (state.launchGateOwner !== void 0 && state.phase !== "completed" && state.phase !== "retiring" && state.phase !== "retired") return { status: "recovery-required" };
246
+ if (state.helperPid && updateProcessMayBeAlive(state.helperPid)) return { status: "in-progress" };
247
+ if (!state.helperPid && await hasUpdateHelperArtifacts(staging)) return { status: "recovery-required" };
248
+ if (state.launchGateOwner && !state.candidateTreeDigest) return { status: "recovery-required" };
249
+ if (state.phase === "staged") {
250
+ if (state.helperPid) state = await resetToStaged(staging, state);
251
+ return recoverStagedCandidate({
252
+ target,
253
+ staging,
254
+ state,
255
+ trust,
256
+ currentVersion
257
+ });
258
+ }
259
+ if (state.phase === "armed") {
260
+ state = await resetToStaged(staging, state);
261
+ return recoverStagedCandidate({
262
+ target,
263
+ staging,
264
+ state,
265
+ trust,
266
+ currentVersion,
267
+ allowDigestlessLegacy: true
268
+ });
269
+ }
270
+ if (state.phase === "swapping") {
271
+ const reconciled = await reconcileSwap(target, staging, state);
272
+ if (!reconciled) return { status: "recovery-required" };
273
+ state = reconciled;
274
+ if (state.phase === "completed") {
275
+ if (await readUpdateTreeVersion(target) !== state.version) return { status: "recovery-required" };
276
+ if (!await retireCompletedUpdateWhileLocked({
277
+ target,
278
+ staging,
279
+ state
280
+ })) return { status: "recovery-required" };
281
+ return {
282
+ status: "updated",
283
+ version: state.version
284
+ };
285
+ }
286
+ if (state.helperPid) state = await resetToStaged(staging, state);
287
+ return recoverStagedCandidate({
288
+ target,
289
+ staging,
290
+ state,
291
+ trust,
292
+ currentVersion,
293
+ allowDigestlessLegacy: true
294
+ });
295
+ }
296
+ if (state.phase === "completed") {
297
+ if (await readUpdateTreeVersion(target) !== state.version || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(target), state.candidateTreeIdentity) || state.candidateTreeDigest !== void 0 && !sameUpdateTreeDigest(await readTreeDigestForProof(target), state.candidateTreeDigest)) return { status: "recovery-required" };
298
+ if (!await retireCompletedUpdateWhileLocked({
299
+ target,
300
+ staging,
301
+ state
302
+ })) return { status: "recovery-required" };
303
+ return {
304
+ status: "updated",
305
+ version: state.version
306
+ };
307
+ }
308
+ if (state.phase === "retiring" || state.phase === "retired") {
309
+ if (await readUpdateTreeVersion(target) !== state.version || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(target), state.candidateTreeIdentity) || state.candidateTreeDigest !== void 0 && !sameUpdateTreeDigest(await readTreeDigestForProof(target), state.candidateTreeDigest)) return { status: "recovery-required" };
310
+ if (!await retireCompletedUpdateWhileLocked({
311
+ target,
312
+ staging,
313
+ state
314
+ })) return { status: "recovery-required" };
315
+ return {
316
+ status: "updated",
317
+ version: state.version
318
+ };
319
+ }
320
+ if (state.phase === "failed") {
321
+ state = await resetToStaged(staging, state);
322
+ return recoverStagedCandidate({
323
+ target,
324
+ staging,
325
+ state,
326
+ trust,
327
+ currentVersion,
328
+ allowDigestlessLegacy: true
329
+ });
330
+ }
331
+ throw new Error("Invalid update staging phase");
332
+ }
333
+ var recoveryUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
334
+ var recoveryStagingEntries = /* @__PURE__ */ new Set([
335
+ "candidate",
336
+ "helper",
337
+ "helper-armed",
338
+ "helper-ready",
339
+ "cancel.json",
340
+ "cancel-ack.json",
341
+ "request.json",
342
+ "state.json"
343
+ ]);
344
+ function hasExactKeys(value, keys) {
345
+ const actual = Object.keys(value).toSorted();
346
+ const expected = keys.toSorted();
347
+ return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
348
+ }
349
+ async function readOptionalRecoveryFile(path, maxBytes) {
350
+ let info;
351
+ try {
352
+ info = await lstat(path);
353
+ } catch (error) {
354
+ if (error.code === "ENOENT") return void 0;
355
+ throw error;
356
+ }
357
+ if (!info.isFile() || info.isSymbolicLink() || info.size < 1 || info.size > maxBytes) throw new Error("Invalid schema-3 helper recovery artifact");
358
+ const file = await open(path, constants$1.O_RDONLY | (constants$1.O_NOFOLLOW ?? 0));
359
+ try {
360
+ const opened = await file.stat();
361
+ if (!opened.isFile() || opened.size < 1 || opened.size > maxBytes) throw new Error("Invalid schema-3 helper recovery artifact");
362
+ return await file.readFile("utf8");
363
+ } finally {
364
+ await file.close();
365
+ }
366
+ }
367
+ async function recoveryInventoryIsKnown(staging, state) {
368
+ const names = await readdir(staging);
369
+ const stateTemporary = new RegExp(`^\\.state-${state.generation}-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\\.tmp$`, "i");
370
+ for (const name of names) {
371
+ if (recoveryStagingEntries.has(name)) continue;
372
+ if (!stateTemporary.test(name)) return false;
373
+ const path = join(staging, name);
374
+ const info = await lstat(path);
375
+ if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) return false;
376
+ }
377
+ if (!names.includes("candidate") || !names.includes("state.json")) return false;
378
+ for (const name of names) {
379
+ const info = await lstat(join(staging, name));
380
+ if (stateTemporary.test(name)) {
381
+ if (!info.isFile() || info.isSymbolicLink()) return false;
382
+ continue;
383
+ }
384
+ if (name === "candidate" || name === "helper") {
385
+ if (!info.isDirectory() || info.isSymbolicLink()) return false;
386
+ } else if (!info.isFile() || info.isSymbolicLink()) return false;
387
+ }
388
+ return true;
389
+ }
390
+ async function isCanonicalRecoveryStaging(staging) {
391
+ const info = await lstat(staging).catch((error) => {
392
+ if (error.code === "ENOENT") return void 0;
393
+ throw error;
394
+ });
395
+ return Boolean(info && info.isDirectory() && !info.isSymbolicLink() && await realpath(staging) === staging);
396
+ }
397
+ function recoveryMarkerMatches(value, keys, expected) {
398
+ return Boolean(value && hasExactKeys(value, keys) && keys.every((key) => value[key] === expected[key]));
399
+ }
400
+ async function helperDirectoryIsKnown(staging, state, gate, requestMayBeAbsent) {
401
+ const helper = join(staging, "helper");
402
+ let entries;
403
+ try {
404
+ entries = await readdir(helper);
405
+ } catch (error) {
406
+ if (error.code === "ENOENT") return requestMayBeAbsent;
407
+ throw error;
408
+ }
409
+ const copiedFiles = /* @__PURE__ */ new Set();
410
+ for (const name of entries) {
411
+ const path = join(helper, name);
412
+ if (name === "bun" || name === "bun.exe" || name === "update-helper.js") {
413
+ const info = await lstat(path);
414
+ if (!info.isFile() || info.isSymbolicLink()) return false;
415
+ copiedFiles.add(name);
416
+ continue;
417
+ }
418
+ const match = /^\.(helper-ready|cancel\.json|cancel-ack\.json)\.([0-9a-f-]{36})\.tmp$/i.exec(name);
419
+ if (!match || !recoveryUuid.test(match[2])) return false;
420
+ let text;
421
+ try {
422
+ text = await readOptionalRecoveryFile(path, 1024);
423
+ } catch {
424
+ return false;
425
+ }
426
+ if (text === void 0) return false;
427
+ let value;
428
+ try {
429
+ value = JSON.parse(text);
430
+ } catch {
431
+ return false;
432
+ }
433
+ if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
434
+ const record = value;
435
+ if (match[1] === "helper-ready") {
436
+ if (!recoveryMarkerMatches(record, [
437
+ "schema",
438
+ "generation",
439
+ "helperOwner",
440
+ "launchGateOwner"
441
+ ], {
442
+ schema: 1,
443
+ generation: gate.generation,
444
+ helperOwner: state.helperOwner,
445
+ launchGateOwner: gate.owner
446
+ })) return false;
447
+ } else if (match[1] === "cancel.json") {
448
+ if (!recoveryMarkerMatches(record, [
449
+ "schema",
450
+ "generation",
451
+ "helperOwner"
452
+ ], {
453
+ schema: 1,
454
+ generation: gate.generation,
455
+ helperOwner: state.helperOwner
456
+ })) return false;
457
+ } else if (!recoveryMarkerMatches(record, [
458
+ "schema",
459
+ "generation",
460
+ "helperOwner",
461
+ "launchGateOwner"
462
+ ], {
463
+ schema: 1,
464
+ generation: gate.generation,
465
+ helperOwner: state.helperOwner,
466
+ launchGateOwner: gate.owner
467
+ })) return false;
468
+ }
469
+ if (requestMayBeAbsent) return true;
470
+ return copiedFiles.has("update-helper.js") && copiedFiles.has("bun") !== copiedFiles.has("bun.exe");
471
+ }
472
+ async function schema3RecoveryArtifactsMatch(target, staging, state, gate, requestMayBeAbsent, trust) {
473
+ if (!await recoveryInventoryIsKnown(staging, state)) return false;
474
+ const verified = state.signedRelease ? verifyReleaseDescriptor(state.signedRelease, trust) : { ok: false };
475
+ if (!verified.ok || verified.descriptor.version !== state.version) return false;
476
+ const requestText = await readOptionalRecoveryFile(join(staging, "request.json"), 65536);
477
+ if (requestText === void 0) {
478
+ if (!requestMayBeAbsent) return false;
479
+ } else try {
480
+ const value = JSON.parse(requestText);
481
+ const request = parseUpdateHelperRequest(value);
482
+ if (typeof value !== "object" || value === null || Array.isArray(value) || !hasExactKeys(value, [
483
+ "schema",
484
+ "target",
485
+ "platform",
486
+ "version",
487
+ "processes",
488
+ "processTimeoutMs",
489
+ "generation",
490
+ "helperOwner"
491
+ ]) || request.schema !== 3 || request.target !== target || request.generation !== gate.generation || request.version !== gate.version || request.helperOwner !== state.helperOwner || !requestPlatformMatchesTrust(request.platform, trust)) return false;
492
+ } catch {
493
+ return false;
494
+ }
495
+ const armedText = await readOptionalRecoveryFile(join(staging, "helper-armed"), 64);
496
+ if (armedText !== void 0 && (!/^\d+\s*$/.test(armedText) || Number(armedText.trim()) !== state.helperPid)) return false;
497
+ const markers = [
498
+ {
499
+ name: "helper-ready",
500
+ keys: [
501
+ "schema",
502
+ "generation",
503
+ "helperOwner",
504
+ "launchGateOwner"
505
+ ],
506
+ values: {
507
+ schema: 1,
508
+ generation: gate.generation,
509
+ helperOwner: state.helperOwner,
510
+ launchGateOwner: gate.owner
511
+ }
512
+ },
513
+ {
514
+ name: "cancel.json",
515
+ keys: [
516
+ "schema",
517
+ "generation",
518
+ "helperOwner"
519
+ ],
520
+ values: {
521
+ schema: 1,
522
+ generation: gate.generation,
523
+ helperOwner: state.helperOwner
524
+ }
525
+ },
526
+ {
527
+ name: "cancel-ack.json",
528
+ keys: [
529
+ "schema",
530
+ "generation",
531
+ "helperOwner",
532
+ "launchGateOwner"
533
+ ],
534
+ values: {
535
+ schema: 1,
536
+ generation: gate.generation,
537
+ helperOwner: state.helperOwner,
538
+ launchGateOwner: gate.owner
539
+ }
540
+ }
541
+ ];
542
+ for (const marker of markers) {
543
+ let value;
544
+ try {
545
+ value = await readUpdateMarker(staging, marker.name);
546
+ } catch {
547
+ return false;
548
+ }
549
+ if (value === void 0) continue;
550
+ if (!recoveryMarkerMatches(value, marker.keys, marker.values)) return false;
551
+ }
552
+ return helperDirectoryIsKnown(staging, state, gate, requestMayBeAbsent);
553
+ }
554
+ function requestPlatformMatchesTrust(platform, trust) {
555
+ return platform === "macos-arm64" && trust.platform === "darwin" && trust.arch === "arm64" || platform === "windows-x64" && trust.platform === "win32" && trust.arch === "x64" || platform === "linux-x64" && trust.platform === "linux" && trust.arch === "x64";
556
+ }
557
+ async function schema3TreeLayout(target, staging, state) {
558
+ if (!state.candidateTreeIdentity || !state.candidateTreeDigest || !state.previousTreeIdentity) return void 0;
559
+ const candidate = join(staging, "candidate");
560
+ const [targetInfo, candidateInfo] = await Promise.all([lstat(target).catch((error) => {
561
+ if (error.code === "ENOENT") return void 0;
562
+ throw error;
563
+ }), lstat(candidate).catch((error) => {
564
+ if (error.code === "ENOENT") return void 0;
565
+ throw error;
566
+ })]);
567
+ if (!targetInfo || !targetInfo.isDirectory() || targetInfo.isSymbolicLink() || !candidateInfo || !candidateInfo.isDirectory() || candidateInfo.isSymbolicLink()) return void 0;
568
+ const [targetVersion, candidateVersion, targetIdentity, candidateIdentity] = await Promise.all([
569
+ readUpdateTreeVersion(target),
570
+ readUpdateTreeVersion(candidate),
571
+ readUpdateTreeIdentity(target),
572
+ readUpdateTreeIdentity(candidate)
573
+ ]);
574
+ if (!targetIdentity || !candidateIdentity || sameUpdateTreeIdentity(targetIdentity, candidateIdentity)) return void 0;
575
+ if (targetVersion === state.previousVersion && candidateVersion === state.version && sameUpdateTreeIdentity(targetIdentity, state.previousTreeIdentity) && sameUpdateTreeIdentity(candidateIdentity, state.candidateTreeIdentity)) return sameUpdateTreeDigest(await readTreeDigestForProof(candidate), state.candidateTreeDigest) ? "pre-swap" : void 0;
576
+ if (targetVersion === state.version && candidateVersion === state.previousVersion && sameUpdateTreeIdentity(targetIdentity, state.candidateTreeIdentity) && sameUpdateTreeIdentity(candidateIdentity, state.previousTreeIdentity)) return sameUpdateTreeDigest(await readTreeDigestForProof(target), state.candidateTreeDigest) ? "post-swap" : void 0;
577
+ }
578
+ function schema3JournalMatchesGate(state, gate) {
579
+ return Boolean(state && state.schema === 1 && [
580
+ "armed",
581
+ "swapping",
582
+ "completed",
583
+ "staged"
584
+ ].includes(state.phase) && state.generation === gate.generation && state.version === gate.version && state.launchGateOwner === gate.owner && typeof state.helperOwner === "string" && recoveryUuid.test(state.helperOwner) && Number.isSafeInteger(state.helperPid) && (state.helperPid ?? 0) >= 2 && recoveryUuid.test(state.generation) && state.version !== state.previousVersion && state.candidateTreeIdentity !== void 0 && state.candidateTreeDigest !== void 0 && state.previousTreeIdentity !== void 0);
585
+ }
586
+ async function removeSchema3HelperArtifacts(staging) {
587
+ for (const name of [
588
+ "request.json",
589
+ "helper-armed",
590
+ "helper-ready",
591
+ "cancel.json",
592
+ "cancel-ack.json"
593
+ ]) await rm(join(staging, name), { force: true });
594
+ const state = await readUpdateStageState(staging);
595
+ if (!state) throw new Error("Schema-3 recovery journal disappeared");
596
+ const stateTemporary = new RegExp(`^\\.state-${state.generation}-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\\.tmp$`, "i");
597
+ for (const name of await readdir(staging)) {
598
+ if (!stateTemporary.test(name)) continue;
599
+ const path = join(staging, name);
600
+ const info = await lstat(path);
601
+ if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) throw new Error("Invalid schema-3 journal temporary");
602
+ await unlink(path);
603
+ }
604
+ await rm(join(staging, "helper"), {
26
605
  recursive: true,
27
606
  force: true
28
607
  });
29
- return version ? {
30
- status: "updated",
31
- version
32
- } : { status: "not-applied" };
33
608
  }
34
- export { resumeUpdate };
609
+ async function finalizationTemporaries(staging, state) {
610
+ const names = await readdir(staging);
611
+ const stateTemporary = new RegExp(`^\\.state-${state.generation}-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\\.tmp$`, "i");
612
+ const temporaryNames = [];
613
+ for (const name of names) {
614
+ if (name === "candidate" || name === "state.json") {
615
+ const info = await lstat(join(staging, name));
616
+ if (name === "candidate" ? !info.isDirectory() || info.isSymbolicLink() : !info.isFile() || info.isSymbolicLink()) return void 0;
617
+ continue;
618
+ }
619
+ if (!stateTemporary.test(name)) return void 0;
620
+ const path = join(staging, name);
621
+ const info = await lstat(path);
622
+ if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) return void 0;
623
+ temporaryNames.push(name);
624
+ }
625
+ if (!names.includes("candidate") || !names.includes("state.json")) return void 0;
626
+ return temporaryNames;
627
+ }
628
+ async function removeFinalizationTemporaries(staging, names) {
629
+ for (const name of names) {
630
+ const path = join(staging, name);
631
+ const info = await lstat(path);
632
+ if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) throw new Error("Invalid update journal temporary");
633
+ await unlink(path);
634
+ }
635
+ }
636
+ async function ownerlessStagedTreeMatches(target, staging, state) {
637
+ if (!state.candidateTreeIdentity || !state.candidateTreeDigest) return false;
638
+ const candidate = join(staging, "candidate");
639
+ const [targetInfo, candidateInfo] = await Promise.all([lstat(target).catch((error) => {
640
+ if (error.code === "ENOENT") return void 0;
641
+ throw error;
642
+ }), lstat(candidate).catch((error) => {
643
+ if (error.code === "ENOENT") return void 0;
644
+ throw error;
645
+ })]);
646
+ if (!targetInfo || !targetInfo.isDirectory() || targetInfo.isSymbolicLink() || !candidateInfo || !candidateInfo.isDirectory() || candidateInfo.isSymbolicLink()) return false;
647
+ const [targetVersion, candidateVersion, targetIdentity, candidateIdentity] = await Promise.all([
648
+ readUpdateTreeVersion(target),
649
+ readUpdateTreeVersion(candidate),
650
+ readUpdateTreeIdentity(target),
651
+ readUpdateTreeIdentity(candidate)
652
+ ]);
653
+ const candidateDigest = await readTreeDigestForProof(candidate);
654
+ return Boolean(targetVersion === state.previousVersion && candidateVersion === state.version && targetIdentity && candidateIdentity && !sameUpdateTreeIdentity(targetIdentity, candidateIdentity) && sameUpdateTreeIdentity(candidateIdentity, state.candidateTreeIdentity) && sameUpdateTreeDigest(candidateDigest, state.candidateTreeDigest) && (!state.previousTreeIdentity || sameUpdateTreeIdentity(targetIdentity, state.previousTreeIdentity)));
655
+ }
656
+ /**
657
+ * Reconcile only the schema-3 journal bound to the exact persisted gate. The
658
+ * caller deliberately opts into this operation; generated unmanaged startup
659
+ * reaches it through `recoverPackagedUpdateLaunchGate` before launch admission.
660
+ */
661
+ async function recoverUpdateLaunchGate(target, trust) {
662
+ const staging = updateStagingFor(target);
663
+ const result = await tryRecoverUpdateLaunchGate(target, async (gate) => {
664
+ if (!await isCanonicalRecoveryStaging(staging)) return false;
665
+ const state = await readUpdateStageState(staging);
666
+ if (!schema3JournalMatchesGate(state, gate)) return false;
667
+ const requestMayBeAbsent = state.phase === "staged" || state.phase === "completed";
668
+ if (!await schema3RecoveryArtifactsMatch(target, staging, state, gate, requestMayBeAbsent, trust)) return false;
669
+ const layout = await schema3TreeLayout(target, staging, state);
670
+ if (!layout) return false;
671
+ if (state.phase === "armed" && layout !== "pre-swap" || state.phase === "completed" && layout !== "post-swap" || state.phase === "staged" && layout !== "pre-swap") return false;
672
+ const nextPhase = state.phase === "completed" || state.phase === "swapping" && layout === "post-swap" ? "completed" : "staged";
673
+ const reconciled = {
674
+ ...state,
675
+ phase: nextPhase
676
+ };
677
+ await syncUpdateTreeParent(target);
678
+ await syncUpdateTreeParent(join(staging, "candidate"));
679
+ await writeUpdateStageStateDurably(staging, reconciled);
680
+ await removeSchema3HelperArtifacts(staging);
681
+ const entries = await readdir(staging);
682
+ if (entries.length !== 2 || !entries.includes("candidate") || !entries.includes("state.json")) return false;
683
+ const current = await readUpdateStageState(staging);
684
+ if (!schema3JournalMatchesGate(current, gate) || current.phase !== reconciled.phase || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(target), layout === "post-swap" ? current.candidateTreeIdentity : current.previousTreeIdentity) || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(join(staging, "candidate")), layout === "post-swap" ? current.previousTreeIdentity : current.candidateTreeIdentity)) return false;
685
+ await writeUpdateStageStateDurably(staging, reconciled);
686
+ return true;
687
+ });
688
+ if (result !== "absent" && result !== "recovered") return result;
689
+ const finalized = await finalizeClearedSchema3StagedOwner(target, staging, trust);
690
+ if (finalized === "absent") return result;
691
+ return finalized;
692
+ }
693
+ async function finalizeClearedSchema3StagedOwner(target, staging, trust) {
694
+ const instance = await tryAcquireUpdateInstanceLease(target, "exclusive");
695
+ if (!instance) return "busy";
696
+ let lock;
697
+ let helper;
698
+ try {
699
+ lock = await tryAcquireUpdateLock(target);
700
+ if (!lock) return "busy";
701
+ if (await readUpdateLaunchGate(target)) return "unreconciled";
702
+ helper = await tryAcquireUpdateHelperLiveness(target);
703
+ if (!helper) return "helper-live";
704
+ await syncUpdateTreeParent(target);
705
+ if (!await lstat(staging).catch((error) => {
706
+ if (error.code === "ENOENT") return void 0;
707
+ throw error;
708
+ })) return "absent";
709
+ if (!await isCanonicalRecoveryStaging(staging)) return "unreconciled";
710
+ const state = await readUpdateStageState(staging);
711
+ if (!state || state.phase !== "staged" && state.phase !== "completed") return "absent";
712
+ if (!state.launchGateOwner) {
713
+ if (state.helperPid !== void 0 || state.helperOwner !== void 0) return "unreconciled";
714
+ const verified = state.signedRelease ? verifyReleaseDescriptor(state.signedRelease, trust) : { ok: false };
715
+ if (!verified.ok || verified.descriptor.version !== state.version) return "absent";
716
+ const temporaries = await finalizationTemporaries(staging, state);
717
+ if (!temporaries) return "unreconciled";
718
+ if (!(state.phase === "staged" ? await ownerlessStagedTreeMatches(target, staging, state) : await schema3TreeLayout(target, staging, state) === "post-swap")) return "unreconciled";
719
+ await syncUpdateTreeParent(target);
720
+ await syncUpdateTreeParent(join(staging, "candidate"));
721
+ await removeFinalizationTemporaries(staging, temporaries);
722
+ await syncUpdateStageDirectory(staging);
723
+ return "absent";
724
+ }
725
+ if (!recoveryUuid.test(state.generation) || !recoveryUuid.test(state.launchGateOwner) || !recoveryUuid.test(state.helperOwner ?? "") || !Number.isSafeInteger(state.helperPid) || (state.helperPid ?? 0) < 2) return "unreconciled";
726
+ const verified = state.signedRelease ? verifyReleaseDescriptor(state.signedRelease, trust) : { ok: false };
727
+ if (!verified.ok || verified.descriptor.version !== state.version) return "unreconciled";
728
+ const temporaries = await finalizationTemporaries(staging, state);
729
+ if (!temporaries) return "unreconciled";
730
+ const info = await lstat(join(staging, "candidate"));
731
+ if (!info.isDirectory() || info.isSymbolicLink()) return "unreconciled";
732
+ const layout = await schema3TreeLayout(target, staging, state);
733
+ if (state.phase === "staged" && layout !== "pre-swap" || state.phase === "completed" && layout !== "post-swap") return "unreconciled";
734
+ await syncUpdateTreeParent(join(staging, "candidate"));
735
+ await removeFinalizationTemporaries(staging, temporaries);
736
+ const { helperPid: _helperPid, helperOwner: _helperOwner, launchGateOwner: _launchGateOwner, previousTreeIdentity: _previousTreeIdentity, ...stagedRecoverable } = state;
737
+ const { helperPid: _completedHelperPid, helperOwner: _completedHelperOwner, launchGateOwner: _completedLaunchGateOwner, ...completedRecoverable } = state;
738
+ await writeUpdateStageStateDurably(staging, state.phase === "staged" ? {
739
+ ...stagedRecoverable,
740
+ phase: "staged"
741
+ } : {
742
+ ...completedRecoverable,
743
+ phase: "completed"
744
+ });
745
+ return "recovered";
746
+ } finally {
747
+ try {
748
+ await helper?.release();
749
+ } finally {
750
+ try {
751
+ await lock?.release();
752
+ } finally {
753
+ await instance.release();
754
+ }
755
+ }
756
+ }
757
+ }
758
+ /**
759
+ * Call on app start. Reconcile only while holding the same per-install lock
760
+ * used by stage, helper handoff, and the swap. A valid staged candidate is
761
+ * retained until a helper completes or an explicit caller handles it.
762
+ */
763
+ async function resumeUpdate(options) {
764
+ const staging = updateStagingFor(options.target);
765
+ let lock;
766
+ try {
767
+ lock = await acquireUpdateLock(options.target, 100);
768
+ } catch (error) {
769
+ if (error instanceof UpdateLockBusyError) return { status: "in-progress" };
770
+ throw error;
771
+ }
772
+ try {
773
+ return await resumeLocked({
774
+ target: options.target,
775
+ staging,
776
+ trust: options.trust,
777
+ currentVersion: options.currentVersion
778
+ });
779
+ } finally {
780
+ await lock.release();
781
+ }
782
+ }
783
+ /**
784
+ * Resume and acquire retained-generation leases under one install lock. This
785
+ * lets callers with explicit release trust serve old lazy assets alongside a
786
+ * validated pending staged candidate without opening a swap race.
787
+ */
788
+ async function resumeUpdateWithRetainedTrees(options) {
789
+ const staging = updateStagingFor(options.target);
790
+ let lock;
791
+ try {
792
+ lock = await acquireUpdateLock(options.target, 100);
793
+ } catch (error) {
794
+ if (error instanceof UpdateLockBusyError) return { status: "in-progress" };
795
+ throw error;
796
+ }
797
+ let retained;
798
+ try {
799
+ if ((await readUpdateStageState(staging))?.phase === "armed") return { status: "recovery-required" };
800
+ const resumed = await resumeLocked({
801
+ target: options.target,
802
+ staging,
803
+ trust: options.trust,
804
+ currentVersion: options.currentVersion
805
+ });
806
+ if (resumed.status === "in-progress" || resumed.status === "recovery-required") return { status: resumed.status };
807
+ retained = await acquireRetainedUpdateTreesWhileLocked({
808
+ target: options.target,
809
+ currentVersion: resumed.status === "updated" ? resumed.version : options.currentVersion,
810
+ ...resumed.status === "staged" ? {
811
+ validatedStagedVersion: resumed.version,
812
+ stagedTrust: options.trust
813
+ } : {}
814
+ });
815
+ if (retained.status === "busy") return { status: "busy" };
816
+ const result = {
817
+ status: "ready",
818
+ resume: resumed,
819
+ retained
820
+ };
821
+ const heldLock = lock;
822
+ lock = void 0;
823
+ try {
824
+ await heldLock.release();
825
+ } catch (error) {
826
+ if (retained.status === "acquired") {
827
+ const acquired = retained;
828
+ retained = void 0;
829
+ try {
830
+ await acquired.release();
831
+ } catch (releaseError) {
832
+ throw new AggregateError([error, releaseError], "Update lock and retained tree leases failed to release", { cause: releaseError });
833
+ }
834
+ }
835
+ throw error;
836
+ }
837
+ retained = void 0;
838
+ return result;
839
+ } catch (error) {
840
+ if (retained?.status === "acquired") try {
841
+ await retained.release();
842
+ } catch (releaseError) {
843
+ throw new AggregateError([error, releaseError], "Resume failure and retained tree leases failed to release", { cause: releaseError });
844
+ }
845
+ throw error;
846
+ } finally {
847
+ await lock?.release();
848
+ }
849
+ }
850
+ export { acquireRetainedUpdateTrees, recoverUpdateLaunchGate, resumeUpdate, resumeUpdateWithRetainedTrees };