velocious 1.0.726 → 1.0.728

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 (155) hide show
  1. package/README.md +2 -2
  2. package/bin/velocious.js +2 -19
  3. package/build/application.js +32 -3
  4. package/build/background-jobs/main.js +9 -1
  5. package/build/background-jobs/worker.js +69 -6
  6. package/build/bin/velocious.js +2 -19
  7. package/build/cli/process-args.js +34 -0
  8. package/build/configuration-types.js +1 -1
  9. package/build/configuration.js +43 -2
  10. package/build/database/advisory-lock-lock-server-backend.js +30 -24
  11. package/build/database/advisory-lock-lock-server-embedded-client.js +74 -0
  12. package/build/database/advisory-lock-lock-server-engine.js +544 -0
  13. package/build/database/advisory-lock-lock-server-local-client.js +260 -0
  14. package/build/database/advisory-lock-lock-server-socket-path.js +17 -0
  15. package/build/database/advisory-lock-lock-server-transport.js +30 -0
  16. package/build/database/drivers/base.js +34 -12
  17. package/build/database/drivers/mssql/index.js +17 -18
  18. package/build/database/drivers/mssql/table.js +28 -25
  19. package/build/database/drivers/mysql/index.js +15 -18
  20. package/build/database/drivers/mysql/table.js +31 -23
  21. package/build/database/drivers/pgsql/index.js +15 -18
  22. package/build/database/drivers/pgsql/table.js +28 -26
  23. package/build/database/drivers/sqlite/base.js +7 -9
  24. package/build/database/drivers/sqlite/table.js +32 -26
  25. package/build/database/pool/async-tracked-multi-connection.js +1 -0
  26. package/build/database/pool/base.js +14 -4
  27. package/build/database/pool/single-multi-use.js +1 -0
  28. package/build/database/record/auditing.js +89 -11
  29. package/build/database/record/index.js +1 -1
  30. package/build/environment-handlers/base.js +50 -9
  31. package/build/environment-handlers/node/advisory-lock-lock-server-local-server.js +206 -0
  32. package/build/environment-handlers/node/cli/commands/server.js +1 -0
  33. package/build/environment-handlers/node.js +30 -3
  34. package/build/http-server/server-lock.js +55 -18
  35. package/build/src/application.d.ts +7 -4
  36. package/build/src/application.d.ts.map +1 -1
  37. package/build/src/application.js +27 -4
  38. package/build/src/background-jobs/main.d.ts +2 -1
  39. package/build/src/background-jobs/main.d.ts.map +1 -1
  40. package/build/src/background-jobs/main.js +10 -2
  41. package/build/src/background-jobs/worker.d.ts +42 -0
  42. package/build/src/background-jobs/worker.d.ts.map +1 -1
  43. package/build/src/background-jobs/worker.js +61 -5
  44. package/build/src/cli/process-args.d.ts +11 -0
  45. package/build/src/cli/process-args.d.ts.map +1 -0
  46. package/build/src/cli/process-args.js +34 -0
  47. package/build/src/configuration-types.d.ts +3 -1
  48. package/build/src/configuration-types.d.ts.map +1 -1
  49. package/build/src/configuration-types.js +2 -2
  50. package/build/src/configuration.d.ts +16 -1
  51. package/build/src/configuration.d.ts.map +1 -1
  52. package/build/src/configuration.js +39 -3
  53. package/build/src/database/advisory-lock-lock-server-backend.d.ts +10 -3
  54. package/build/src/database/advisory-lock-lock-server-backend.d.ts.map +1 -1
  55. package/build/src/database/advisory-lock-lock-server-backend.js +25 -22
  56. package/build/src/database/advisory-lock-lock-server-embedded-client.d.ts +24 -0
  57. package/build/src/database/advisory-lock-lock-server-embedded-client.d.ts.map +1 -0
  58. package/build/src/database/advisory-lock-lock-server-embedded-client.js +64 -0
  59. package/build/src/database/advisory-lock-lock-server-engine.d.ts +285 -0
  60. package/build/src/database/advisory-lock-lock-server-engine.d.ts.map +1 -0
  61. package/build/src/database/advisory-lock-lock-server-engine.js +460 -0
  62. package/build/src/database/advisory-lock-lock-server-local-client.d.ts +114 -0
  63. package/build/src/database/advisory-lock-lock-server-local-client.d.ts.map +1 -0
  64. package/build/src/database/advisory-lock-lock-server-local-client.js +227 -0
  65. package/build/src/database/advisory-lock-lock-server-socket-path.d.ts +9 -0
  66. package/build/src/database/advisory-lock-lock-server-socket-path.d.ts.map +1 -0
  67. package/build/src/database/advisory-lock-lock-server-socket-path.js +16 -0
  68. package/build/src/database/advisory-lock-lock-server-transport.d.ts +18 -0
  69. package/build/src/database/advisory-lock-lock-server-transport.d.ts.map +1 -0
  70. package/build/src/database/advisory-lock-lock-server-transport.js +27 -0
  71. package/build/src/database/drivers/base.d.ts +15 -2
  72. package/build/src/database/drivers/base.d.ts.map +1 -1
  73. package/build/src/database/drivers/base.js +33 -13
  74. package/build/src/database/drivers/mssql/index.d.ts +2 -2
  75. package/build/src/database/drivers/mssql/index.d.ts.map +1 -1
  76. package/build/src/database/drivers/mssql/index.js +17 -18
  77. package/build/src/database/drivers/mssql/table.d.ts.map +1 -1
  78. package/build/src/database/drivers/mssql/table.js +25 -23
  79. package/build/src/database/drivers/mysql/index.d.ts +2 -2
  80. package/build/src/database/drivers/mysql/index.d.ts.map +1 -1
  81. package/build/src/database/drivers/mysql/index.js +16 -19
  82. package/build/src/database/drivers/mysql/table.d.ts.map +1 -1
  83. package/build/src/database/drivers/mysql/table.js +27 -22
  84. package/build/src/database/drivers/pgsql/index.d.ts +2 -2
  85. package/build/src/database/drivers/pgsql/index.d.ts.map +1 -1
  86. package/build/src/database/drivers/pgsql/index.js +16 -19
  87. package/build/src/database/drivers/pgsql/table.d.ts.map +1 -1
  88. package/build/src/database/drivers/pgsql/table.js +25 -23
  89. package/build/src/database/drivers/sqlite/base.d.ts.map +1 -1
  90. package/build/src/database/drivers/sqlite/base.js +8 -10
  91. package/build/src/database/drivers/sqlite/table.d.ts.map +1 -1
  92. package/build/src/database/drivers/sqlite/table.js +29 -25
  93. package/build/src/database/pool/async-tracked-multi-connection.d.ts.map +1 -1
  94. package/build/src/database/pool/async-tracked-multi-connection.js +2 -1
  95. package/build/src/database/pool/base.d.ts +6 -0
  96. package/build/src/database/pool/base.d.ts.map +1 -1
  97. package/build/src/database/pool/base.js +14 -5
  98. package/build/src/database/pool/single-multi-use.d.ts.map +1 -1
  99. package/build/src/database/pool/single-multi-use.js +2 -1
  100. package/build/src/database/record/auditing.d.ts +14 -4
  101. package/build/src/database/record/auditing.d.ts.map +1 -1
  102. package/build/src/database/record/auditing.js +77 -12
  103. package/build/src/database/record/index.d.ts +4 -2
  104. package/build/src/database/record/index.d.ts.map +1 -1
  105. package/build/src/database/record/index.js +2 -2
  106. package/build/src/environment-handlers/base.d.ts +86 -7
  107. package/build/src/environment-handlers/base.d.ts.map +1 -1
  108. package/build/src/environment-handlers/base.js +48 -9
  109. package/build/src/environment-handlers/node/advisory-lock-lock-server-local-server.d.ts +2 -0
  110. package/build/src/environment-handlers/node/advisory-lock-lock-server-local-server.d.ts.map +1 -0
  111. package/build/src/environment-handlers/node/advisory-lock-lock-server-local-server.js +179 -0
  112. package/build/src/environment-handlers/node/cli/commands/server.d.ts.map +1 -1
  113. package/build/src/environment-handlers/node/cli/commands/server.js +2 -1
  114. package/build/src/environment-handlers/node.d.ts +10 -4
  115. package/build/src/environment-handlers/node.d.ts.map +1 -1
  116. package/build/src/environment-handlers/node.js +30 -4
  117. package/build/src/http-server/server-lock.d.ts +43 -14
  118. package/build/src/http-server/server-lock.d.ts.map +1 -1
  119. package/build/src/http-server/server-lock.js +54 -19
  120. package/build/src/tenants/default-tenant-database-provisioning.d.ts.map +1 -1
  121. package/build/src/tenants/default-tenant-database-provisioning.js +7 -1
  122. package/build/tenants/default-tenant-database-provisioning.js +8 -0
  123. package/package.json +2 -2
  124. package/src/application.js +32 -3
  125. package/src/background-jobs/main.js +9 -1
  126. package/src/background-jobs/worker.js +69 -6
  127. package/src/cli/process-args.js +34 -0
  128. package/src/configuration-types.js +1 -1
  129. package/src/configuration.js +43 -2
  130. package/src/database/advisory-lock-lock-server-backend.js +30 -24
  131. package/src/database/advisory-lock-lock-server-embedded-client.js +74 -0
  132. package/src/database/advisory-lock-lock-server-engine.js +544 -0
  133. package/src/database/advisory-lock-lock-server-local-client.js +260 -0
  134. package/src/database/advisory-lock-lock-server-socket-path.js +17 -0
  135. package/src/database/advisory-lock-lock-server-transport.js +30 -0
  136. package/src/database/drivers/base.js +34 -12
  137. package/src/database/drivers/mssql/index.js +17 -18
  138. package/src/database/drivers/mssql/table.js +28 -25
  139. package/src/database/drivers/mysql/index.js +15 -18
  140. package/src/database/drivers/mysql/table.js +31 -23
  141. package/src/database/drivers/pgsql/index.js +15 -18
  142. package/src/database/drivers/pgsql/table.js +28 -26
  143. package/src/database/drivers/sqlite/base.js +7 -9
  144. package/src/database/drivers/sqlite/table.js +32 -26
  145. package/src/database/pool/async-tracked-multi-connection.js +1 -0
  146. package/src/database/pool/base.js +14 -4
  147. package/src/database/pool/single-multi-use.js +1 -0
  148. package/src/database/record/auditing.js +89 -11
  149. package/src/database/record/index.js +1 -1
  150. package/src/environment-handlers/base.js +50 -9
  151. package/src/environment-handlers/node/advisory-lock-lock-server-local-server.js +206 -0
  152. package/src/environment-handlers/node/cli/commands/server.js +1 -0
  153. package/src/environment-handlers/node.js +30 -3
  154. package/src/http-server/server-lock.js +55 -18
  155. package/src/tenants/default-tenant-database-provisioning.js +8 -0
@@ -0,0 +1,460 @@
1
+ // @ts-check
2
+ /**
3
+ * One engine connection: the transport-side view of a lock client. `send`
4
+ * delivers engine messages (responses and `lost` pushes) back to the client.
5
+ * @typedef {object} LockServerEngineConnection
6
+ * @property {(body: Record<string, unknown>) => void} send - Delivers one engine message to this connection.
7
+ * @property {() => void} [onClose] - Engine-side close hook (transport teardown).
8
+ */
9
+ /**
10
+ * One registered engine connection with its held lock names.
11
+ * @typedef {object} LockServerEngineRegisteredConnection
12
+ * @property {Map<string, number>} held - Lock names this connection holds, mapped to their granted epoch.
13
+ * @property {LockServerEngineConnection} connection - Transport-side connection.
14
+ * @property {string} id - Server-minted holder id.
15
+ * @property {boolean} open - False once the connection was closed.
16
+ */
17
+ /**
18
+ * One queued acquire request waiting on the FIFO queue.
19
+ * @typedef {object} LockServerEngineWaiter
20
+ * @property {LockServerEngineRegisteredConnection} connection - Waiting connection.
21
+ * @property {string} correlationId - Request correlation echoed on the response.
22
+ * @property {number} [deadline] - Absolute deadline; absent waits indefinitely.
23
+ * @property {string} name - Lock name.
24
+ * @property {ReturnType<typeof setTimeout> | null} timer - Bounded-wait timeout timer.
25
+ */
26
+ /**
27
+ * One lock name's live state in the engine.
28
+ * @typedef {object} LockServerEngineLockRecord
29
+ * @property {LockServerEngineRegisteredConnection | null} holder - Current lease holder, null when free.
30
+ * @property {number} epoch - Last granted fencing epoch (0 before the first grant).
31
+ * @property {number} leaseExpiresAt - When the current lease expires without renewal.
32
+ * @property {string} name - Lock name.
33
+ * @property {LockServerEngineWaiter[]} waiters - FIFO queue of pending acquires.
34
+ */
35
+ /**
36
+ * One engine request message.
37
+ * @typedef {object} LockServerEngineRequest
38
+ * @property {string} correlationId - Client-generated id echoed on the response.
39
+ * @property {number} [epoch] - Holder epoch for `renew`/`release`.
40
+ * @property {string} name - Lock name.
41
+ * @property {number} [timeoutMs] - Bounded wait for `acquire`.
42
+ */
43
+ /**
44
+ * Registers one engine connection with its server-minted holder id — exactly
45
+ * like the consens-lock daemon mints the holder id from the transport, so a
46
+ * client can only renew or release its own leases.
47
+ * @param {LockServerEngineConnection} connection - Transport-side connection.
48
+ * @param {string} id - Holder id.
49
+ * @returns {LockServerEngineRegisteredConnection} - Registered connection.
50
+ */
51
+ function registeredConnection(connection, id) {
52
+ return { connection, held: new Map(), id, open: true };
53
+ }
54
+ /**
55
+ * Shared lock-server engine implementing the consens-lock protocol v2 semantics
56
+ * in plain JS with no Node builtins and no sockets (STC-715). It is the single
57
+ * lease/epoch/fencing authority reused by every lock-server mode:
58
+ *
59
+ * - `embedded` mode runs it directly inside the environment process (the
60
+ * in-process transport feeds this same message surface over function calls),
61
+ * so browser/Expo bundles can use the lock-server tier without `ws`.
62
+ * - `local` mode runs it in a spawned child process over stdio JSON-lines
63
+ * (`src/environment-handlers/node/advisory-lock-lock-server-server.js`).
64
+ *
65
+ * Semantics mirror the external daemon (`docs/protocol.md` in
66
+ * `diestoeckels/consens-lock`): server-minted holder ids bound to the
67
+ * connection, leases renewed per third of `leaseMs`, a monotonic fencing epoch
68
+ * per lock name bumped on every grant and on every invalidation, a FIFO waiter
69
+ * queue per name, an expired-lease sweeper, and an asynchronous `lost` push so
70
+ * a fenced holder learns without waiting for its next renew.
71
+ *
72
+ * Grant decisions run synchronously in the engine's single event loop: the
73
+ * check-and-set on the holder map has no `await` between read and write, so
74
+ * two concurrent acquires can never both be granted.
75
+ */
76
+ export default class AdvisoryLockLockServerEngine {
77
+ /**
78
+ * Creates one engine instance. No I/O happens here.
79
+ * @param {object} [args] - Engine options.
80
+ * @param {number} [args.leaseMs] - Lease duration per grant. Defaults to 30000.
81
+ * @param {number} [args.sweepIntervalMs] - Expired-lease sweep interval. Defaults to 200.
82
+ */
83
+ constructor({ leaseMs = 30_000, sweepIntervalMs = 200 } = {}) {
84
+ this.leaseMs = leaseMs;
85
+ this.sweepIntervalMs = sweepIntervalMs;
86
+ /** @type {Map<string, LockServerEngineLockRecord>} */
87
+ this.locks = new Map();
88
+ /** @type {Map<string, number>} */
89
+ this.epochByLock = new Map();
90
+ /** @type {Map<string, LockServerEngineRegisteredConnection>} */
91
+ this.connections = new Map();
92
+ this.connectionCounter = 0;
93
+ this.closed = false;
94
+ /** @type {ReturnType<typeof setInterval> | null} */
95
+ this.sweepTimer = null;
96
+ }
97
+ /**
98
+ * Starts the expired-lease sweeper (idempotent). Long-lived transports call
99
+ * this; the sweeper is the backstop for holders whose transport died without
100
+ * a close event.
101
+ * @returns {void}
102
+ */
103
+ startSweeper() {
104
+ if (this.closed || this.sweepTimer)
105
+ return;
106
+ const timer = setInterval(() => this.sweep(), this.sweepIntervalMs);
107
+ timer.unref?.();
108
+ this.sweepTimer = timer;
109
+ }
110
+ /**
111
+ * Registers one connection (the transport opened it) and returns its
112
+ * server-minted holder id.
113
+ * @param {LockServerEngineConnection} connection - Transport-side connection.
114
+ * @returns {string} - Holder id bound to this connection.
115
+ */
116
+ openConnection(connection) {
117
+ if (this.closed)
118
+ throw new Error("Lock server engine is closed");
119
+ const id = `engine-holder-${++this.connectionCounter}`;
120
+ const registered = registeredConnection(connection, id);
121
+ this.connections.set(id, registered);
122
+ this.connectionCounter = Math.max(this.connectionCounter, this.connections.size);
123
+ return id;
124
+ }
125
+ /**
126
+ * Returns the registered connection for one transport connection id,
127
+ * auto-registering the given transport view when the first message arrives
128
+ * before an explicit open (the stdio server has no separate connection-open
129
+ * frame per client).
130
+ * @param {string} connectionId - Transport connection id.
131
+ * @param {LockServerEngineConnection} [transport] - Transport view to register when the id is new.
132
+ * @returns {LockServerEngineRegisteredConnection | null} - Registered connection, or null when the engine is closed.
133
+ */
134
+ ensureConnection(connectionId, transport) {
135
+ if (this.closed)
136
+ return null;
137
+ const existing = this.connections.get(connectionId);
138
+ if (existing)
139
+ return existing;
140
+ const registered = registeredConnection(transport || { send: () => { } }, connectionId);
141
+ this.connections.set(connectionId, registered);
142
+ this.connectionCounter = Math.max(this.connectionCounter, this.connections.size);
143
+ return registered;
144
+ }
145
+ /**
146
+ * Handles one request message from a connection and answers it (or queues
147
+ * the wait) through the connection's `send`.
148
+ * @param {string} connectionId - Connection the message arrived on.
149
+ * @param {Record<string, unknown>} body - Request message.
150
+ * @returns {void}
151
+ */
152
+ handleMessage(connectionId, body) {
153
+ const registered = this.ensureConnection(connectionId);
154
+ if (this.closed || !registered || !registered.open || !body || typeof body !== "object")
155
+ return;
156
+ // Transport-level frames (the connection-open params carrying auth and
157
+ // protocol version) are answered by the transport's hello-ack, not here;
158
+ // only request/response traffic with a correlationId reaches the engine.
159
+ if (body.type === "hello" || typeof body.correlationId !== "string")
160
+ return;
161
+ const correlationId = typeof body.correlationId === "string" ? body.correlationId : "";
162
+ const name = typeof body.name === "string" ? body.name : "";
163
+ switch (body.type) {
164
+ case "acquire":
165
+ this.handleAcquire(registered, { correlationId, name, timeoutMs: typeof body.timeoutMs === "number" ? body.timeoutMs : undefined });
166
+ return;
167
+ case "try-acquire":
168
+ this.handleTryAcquire(registered, { correlationId, name });
169
+ return;
170
+ case "renew":
171
+ this.handleRenew(registered, { correlationId, epoch: typeof body.epoch === "number" ? body.epoch : -1, name });
172
+ return;
173
+ case "release":
174
+ this.handleRelease(registered, { correlationId, epoch: typeof body.epoch === "number" ? body.epoch : undefined, name });
175
+ return;
176
+ case "who-holds":
177
+ this.respond(registered, correlationId, { holder: this.holderInfo(name), type: "response" });
178
+ return;
179
+ case "list":
180
+ this.respond(registered, correlationId, { holders: this.listHolders(), type: "response" });
181
+ return;
182
+ default:
183
+ this.respond(registered, correlationId, { error: `Unknown lock-server request type: ${String(body.type)}`, status: "error", type: "response" });
184
+ }
185
+ }
186
+ /**
187
+ * Removes a connection and releases every lease it holds immediately — the
188
+ * same transport-close semantics the external daemon has.
189
+ * @param {string} connectionId - Registered connection id.
190
+ * @returns {void}
191
+ */
192
+ connectionClose(connectionId) {
193
+ const registered = this.connections.get(connectionId);
194
+ if (!registered)
195
+ return;
196
+ this.connections.delete(connectionId);
197
+ registered.open = false;
198
+ for (const name of [...registered.held.keys()]) {
199
+ const record = this.locks.get(name);
200
+ if (!record || record.holder !== registered)
201
+ continue;
202
+ record.holder = null;
203
+ registered.held.delete(name);
204
+ this.grantNext(record);
205
+ }
206
+ }
207
+ /**
208
+ * Stops the sweeper and closes every connection (shutdown path).
209
+ * @returns {void}
210
+ */
211
+ close() {
212
+ this.closed = true;
213
+ if (this.sweepTimer) {
214
+ clearInterval(this.sweepTimer);
215
+ this.sweepTimer = null;
216
+ }
217
+ for (const registered of [...this.connections.values()]) {
218
+ try {
219
+ registered.connection.onClose?.();
220
+ }
221
+ catch {
222
+ // A failing transport close hook must not block the shutdown of the
223
+ // remaining connections.
224
+ }
225
+ this.connections.delete(registered.id);
226
+ registered.open = false;
227
+ }
228
+ }
229
+ /**
230
+ * Handles `acquire`: grants immediately, answers `already-held` for a
231
+ * re-entrant acquisition, or joins the name's FIFO waiter queue with a
232
+ * bounded timeout.
233
+ * @param {LockServerEngineRegisteredConnection} registered - Requesting connection.
234
+ * @param {LockServerEngineRequest & {timeoutMs?: number}} request - Request fields.
235
+ * @returns {void}
236
+ */
237
+ handleAcquire(registered, request) {
238
+ const { correlationId, name, timeoutMs } = request;
239
+ if (!name) {
240
+ this.respond(registered, correlationId, { error: "acquire requires a lock name", status: "error", type: "response" });
241
+ return;
242
+ }
243
+ const record = this.lockRecord(name);
244
+ const heldEpoch = registered.held.get(name);
245
+ if (record.holder === registered && typeof heldEpoch === "number") {
246
+ this.respond(registered, correlationId, { epoch: heldEpoch, leaseExpiresAt: record.leaseExpiresAt, status: "already-held", type: "response" });
247
+ return;
248
+ }
249
+ if (!record.holder) {
250
+ this.grant(registered, record, correlationId);
251
+ return;
252
+ }
253
+ const waiter = /** @type {LockServerEngineWaiter} */ ({ connection: registered, correlationId, name });
254
+ if (typeof timeoutMs === "number" && timeoutMs >= 0) {
255
+ waiter.deadline = Date.now() + timeoutMs;
256
+ const timer = setTimeout(() => this.expireWaiter(record, waiter), timeoutMs);
257
+ timer.unref?.();
258
+ waiter.timer = timer;
259
+ }
260
+ record.waiters.push(waiter);
261
+ }
262
+ /**
263
+ * Handles `try-acquire`: grants when free, answers `busy` when held.
264
+ * @param {LockServerEngineRegisteredConnection} registered - Requesting connection.
265
+ * @param {LockServerEngineRequest} request - Request fields.
266
+ * @returns {void}
267
+ */
268
+ handleTryAcquire(registered, request) {
269
+ const { correlationId, name } = request;
270
+ if (!name) {
271
+ this.respond(registered, correlationId, { error: "try-acquire requires a lock name", status: "error", type: "response" });
272
+ return;
273
+ }
274
+ const record = this.lockRecord(name);
275
+ const heldEpoch = registered.held.get(name);
276
+ if (record.holder === registered && typeof heldEpoch === "number") {
277
+ this.respond(registered, correlationId, { epoch: heldEpoch, leaseExpiresAt: record.leaseExpiresAt, status: "already-held", type: "response" });
278
+ return;
279
+ }
280
+ if (record.holder) {
281
+ this.respond(registered, correlationId, { ownerId: record.holder.id, status: "busy", type: "response" });
282
+ return;
283
+ }
284
+ this.grant(registered, record, correlationId);
285
+ }
286
+ /**
287
+ * Handles `renew` with the fencing check: only the current holder with the
288
+ * matching epoch may extend the lease; a superseded holder gets `lost` with
289
+ * the current epoch.
290
+ * @param {LockServerEngineRegisteredConnection} registered - Renewing connection.
291
+ * @param {LockServerEngineRequest & {epoch: number}} request - Request fields.
292
+ * @returns {void}
293
+ */
294
+ handleRenew(registered, request) {
295
+ const { correlationId, epoch, name } = request;
296
+ const record = this.locks.get(name);
297
+ if (!record) {
298
+ this.respond(registered, correlationId, { status: "not-found", type: "response" });
299
+ return;
300
+ }
301
+ if (record.holder !== registered || record.epoch !== epoch) {
302
+ const status = registered.held.has(name) ? "lost" : "not-found";
303
+ this.respond(registered, correlationId, { currentEpoch: record.epoch, status, type: "response" });
304
+ return;
305
+ }
306
+ record.leaseExpiresAt = Date.now() + this.leaseMs;
307
+ this.respond(registered, correlationId, { leaseExpiresAt: record.leaseExpiresAt, status: "renewed", type: "response" });
308
+ }
309
+ /**
310
+ * Handles `release`: idempotent for the holder; `not-holder` after an epoch
311
+ * bump is the expected answer for a superseded holder.
312
+ * @param {LockServerEngineRegisteredConnection} registered - Releasing connection.
313
+ * @param {LockServerEngineRequest & {epoch?: number}} request - Request fields.
314
+ * @returns {void}
315
+ */
316
+ handleRelease(registered, request) {
317
+ const { correlationId, epoch, name } = request;
318
+ const record = this.locks.get(name);
319
+ if (!record) {
320
+ this.respond(registered, correlationId, { status: "not-found", type: "response" });
321
+ return;
322
+ }
323
+ if (record.holder !== registered) {
324
+ const status = registered.held.has(name) ? "not-holder" : "not-found";
325
+ this.respond(registered, correlationId, { currentEpoch: record.epoch, status, type: "response" });
326
+ return;
327
+ }
328
+ if (typeof epoch === "number" && epoch !== record.epoch) {
329
+ this.respond(registered, correlationId, { currentEpoch: record.epoch, status: "not-holder", type: "response" });
330
+ return;
331
+ }
332
+ record.holder = null;
333
+ registered.held.delete(name);
334
+ this.respond(registered, correlationId, { status: "released", type: "response" });
335
+ this.grantNext(record);
336
+ }
337
+ /**
338
+ * Grants the lock to a connection: bumps the monotonic per-name epoch,
339
+ * installs the holder, and answers `acquired` echoing the correlation.
340
+ * @param {LockServerEngineRegisteredConnection} registered - Granted connection.
341
+ * @param {LockServerEngineLockRecord} record - Lock record.
342
+ * @param {string} correlationId - Correlation to echo.
343
+ * @returns {void}
344
+ */
345
+ grant(registered, record, correlationId) {
346
+ const epoch = (this.epochByLock.get(record.name) ?? 0) + 1;
347
+ this.epochByLock.set(record.name, epoch);
348
+ record.epoch = epoch;
349
+ record.holder = registered;
350
+ record.leaseExpiresAt = Date.now() + this.leaseMs;
351
+ registered.held.set(record.name, epoch);
352
+ this.respond(registered, correlationId, { epoch, leaseExpiresAt: record.leaseExpiresAt, status: "acquired", type: "response" });
353
+ }
354
+ /**
355
+ * Moves the FIFO queue's first live waiter into the grant path.
356
+ * @param {LockServerEngineLockRecord} record - Freed lock record.
357
+ * @returns {void}
358
+ */
359
+ grantNext(record) {
360
+ while (record.waiters.length > 0) {
361
+ const waiter = /** @type {LockServerEngineWaiter} */ (record.waiters.shift());
362
+ if (waiter.timer)
363
+ clearTimeout(waiter.timer);
364
+ if (!waiter.connection.open)
365
+ continue;
366
+ this.grant(waiter.connection, record, waiter.correlationId);
367
+ return;
368
+ }
369
+ }
370
+ /**
371
+ * Removes a waiter whose bounded wait elapsed and answers `timeout`.
372
+ * @param {LockServerEngineLockRecord} record - Lock record the waiter queued on.
373
+ * @param {LockServerEngineWaiter} waiter - Expired waiter.
374
+ * @returns {void}
375
+ */
376
+ expireWaiter(record, waiter) {
377
+ const index = record.waiters.indexOf(waiter);
378
+ if (index >= 0)
379
+ record.waiters.splice(index, 1);
380
+ if (!waiter.connection.open)
381
+ return;
382
+ this.respond(waiter.connection, waiter.correlationId, { status: "timeout", type: "response" });
383
+ }
384
+ /**
385
+ * Sweeps expired leases: bumps the epoch (the old holder is fenced), pushes
386
+ * `lost` to the old holder, and grants the next waiter.
387
+ * @returns {void}
388
+ */
389
+ sweep() {
390
+ if (this.closed)
391
+ return;
392
+ const now = Date.now();
393
+ for (const record of this.locks.values()) {
394
+ const holder = record.holder;
395
+ if (!holder || record.leaseExpiresAt > now)
396
+ continue;
397
+ const fencedEpoch = record.epoch;
398
+ record.holder = null;
399
+ holder.held.delete(record.name);
400
+ this.epochByLock.set(record.name, fencedEpoch + 1);
401
+ record.epoch = fencedEpoch + 1;
402
+ try {
403
+ holder.connection.send({ epoch: record.epoch, name: record.name, type: "lost" });
404
+ }
405
+ catch {
406
+ // A dead transport cannot receive the push; the lease is already gone.
407
+ }
408
+ this.grantNext(record);
409
+ }
410
+ }
411
+ /**
412
+ * Returns (creating when needed) the live record for one lock name.
413
+ * @param {string} name - Lock name.
414
+ * @returns {LockServerEngineLockRecord} - Live record.
415
+ */
416
+ lockRecord(name) {
417
+ const existing = this.locks.get(name);
418
+ if (existing)
419
+ return existing;
420
+ /** @type {LockServerEngineLockRecord} */
421
+ const record = { epoch: this.epochByLock.get(name) ?? 0, holder: null, leaseExpiresAt: 0, name, waiters: [] };
422
+ this.locks.set(name, record);
423
+ return record;
424
+ }
425
+ /**
426
+ * Current holder info for one name (diagnostics).
427
+ * @param {string} name - Lock name.
428
+ * @returns {{epoch: number, holderId: string, leaseExpiresAt: number, name: string, waiterCount: number} | null} - Holder info, or null when free.
429
+ */
430
+ holderInfo(name) {
431
+ const record = this.locks.get(name);
432
+ if (!record || !record.holder)
433
+ return null;
434
+ return { epoch: record.epoch, holderId: record.holder.id, leaseExpiresAt: record.leaseExpiresAt, name, waiterCount: record.waiters.length };
435
+ }
436
+ /**
437
+ * Live holder list (diagnostics).
438
+ * @returns {{epoch: number, holderId: string, leaseExpiresAt: number, name: string, waiterCount: number}[]} - Live holders.
439
+ */
440
+ listHolders() {
441
+ const holders = [];
442
+ for (const record of this.locks.values()) {
443
+ if (!record.holder)
444
+ continue;
445
+ holders.push({ epoch: record.epoch, holderId: record.holder.id, leaseExpiresAt: record.leaseExpiresAt, name: record.name, waiterCount: record.waiters.length });
446
+ }
447
+ return holders;
448
+ }
449
+ /**
450
+ * Sends one response to a connection.
451
+ * @param {LockServerEngineRegisteredConnection} registered - Target connection.
452
+ * @param {string} correlationId - Correlation to echo.
453
+ * @param {Record<string, unknown>} body - Response fields.
454
+ * @returns {void}
455
+ */
456
+ respond(registered, correlationId, body) {
457
+ registered.connection.send({ ...body, correlationId });
458
+ }
459
+ }
460
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-lock-server-engine.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-lock-server-engine.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * One engine connection: the transport-side view of a lock client. `send`\n * delivers engine messages (responses and `lost` pushes) back to the client.\n * @typedef {object} LockServerEngineConnection\n * @property {(body: Record<string, unknown>) => void} send - Delivers one engine message to this connection.\n * @property {() => void} [onClose] - Engine-side close hook (transport teardown).\n */\n/**\n * One registered engine connection with its held lock names.\n * @typedef {object} LockServerEngineRegisteredConnection\n * @property {Map<string, number>} held - Lock names this connection holds, mapped to their granted epoch.\n * @property {LockServerEngineConnection} connection - Transport-side connection.\n * @property {string} id - Server-minted holder id.\n * @property {boolean} open - False once the connection was closed.\n */\n/**\n * One queued acquire request waiting on the FIFO queue.\n * @typedef {object} LockServerEngineWaiter\n * @property {LockServerEngineRegisteredConnection} connection - Waiting connection.\n * @property {string} correlationId - Request correlation echoed on the response.\n * @property {number} [deadline] - Absolute deadline; absent waits indefinitely.\n * @property {string} name - Lock name.\n * @property {ReturnType<typeof setTimeout> | null} timer - Bounded-wait timeout timer.\n */\n/**\n * One lock name's live state in the engine.\n * @typedef {object} LockServerEngineLockRecord\n * @property {LockServerEngineRegisteredConnection | null} holder - Current lease holder, null when free.\n * @property {number} epoch - Last granted fencing epoch (0 before the first grant).\n * @property {number} leaseExpiresAt - When the current lease expires without renewal.\n * @property {string} name - Lock name.\n * @property {LockServerEngineWaiter[]} waiters - FIFO queue of pending acquires.\n */\n/**\n * One engine request message.\n * @typedef {object} LockServerEngineRequest\n * @property {string} correlationId - Client-generated id echoed on the response.\n * @property {number} [epoch] - Holder epoch for `renew`/`release`.\n * @property {string} name - Lock name.\n * @property {number} [timeoutMs] - Bounded wait for `acquire`.\n */\n/**\n * Registers one engine connection with its server-minted holder id — exactly\n * like the consens-lock daemon mints the holder id from the transport, so a\n * client can only renew or release its own leases.\n * @param {LockServerEngineConnection} connection - Transport-side connection.\n * @param {string} id - Holder id.\n * @returns {LockServerEngineRegisteredConnection} - Registered connection.\n */\nfunction registeredConnection(connection, id) {\n  return {connection, held: new Map(), id, open: true}\n}\n\n/**\n * Shared lock-server engine implementing the consens-lock protocol v2 semantics\n * in plain JS with no Node builtins and no sockets (STC-715). It is the single\n * lease/epoch/fencing authority reused by every lock-server mode:\n *\n * - `embedded` mode runs it directly inside the environment process (the\n *   in-process transport feeds this same message surface over function calls),\n *   so browser/Expo bundles can use the lock-server tier without `ws`.\n * - `local` mode runs it in a spawned child process over stdio JSON-lines\n *   (`src/environment-handlers/node/advisory-lock-lock-server-server.js`).\n *\n * Semantics mirror the external daemon (`docs/protocol.md` in\n * `diestoeckels/consens-lock`): server-minted holder ids bound to the\n * connection, leases renewed per third of `leaseMs`, a monotonic fencing epoch\n * per lock name bumped on every grant and on every invalidation, a FIFO waiter\n * queue per name, an expired-lease sweeper, and an asynchronous `lost` push so\n * a fenced holder learns without waiting for its next renew.\n *\n * Grant decisions run synchronously in the engine's single event loop: the\n * check-and-set on the holder map has no `await` between read and write, so\n * two concurrent acquires can never both be granted.\n */\nexport default class AdvisoryLockLockServerEngine {\n  /**\n   * Creates one engine instance. No I/O happens here.\n   * @param {object} [args] - Engine options.\n   * @param {number} [args.leaseMs] - Lease duration per grant. Defaults to 30000.\n   * @param {number} [args.sweepIntervalMs] - Expired-lease sweep interval. Defaults to 200.\n   */\n  constructor({leaseMs = 30_000, sweepIntervalMs = 200} = {}) {\n    this.leaseMs = leaseMs\n    this.sweepIntervalMs = sweepIntervalMs\n    /** @type {Map<string, LockServerEngineLockRecord>} */\n    this.locks = new Map()\n    /** @type {Map<string, number>} */\n    this.epochByLock = new Map()\n    /** @type {Map<string, LockServerEngineRegisteredConnection>} */\n    this.connections = new Map()\n    this.connectionCounter = 0\n    this.closed = false\n    /** @type {ReturnType<typeof setInterval> | null} */\n    this.sweepTimer = null\n  }\n\n  /**\n   * Starts the expired-lease sweeper (idempotent). Long-lived transports call\n   * this; the sweeper is the backstop for holders whose transport died without\n   * a close event.\n   * @returns {void}\n   */\n  startSweeper() {\n    if (this.closed || this.sweepTimer) return\n\n    const timer = setInterval(() => this.sweep(), this.sweepIntervalMs)\n\n    timer.unref?.()\n    this.sweepTimer = timer\n  }\n\n  /**\n   * Registers one connection (the transport opened it) and returns its\n   * server-minted holder id.\n   * @param {LockServerEngineConnection} connection - Transport-side connection.\n   * @returns {string} - Holder id bound to this connection.\n   */\n  openConnection(connection) {\n    if (this.closed) throw new Error(\"Lock server engine is closed\")\n\n    const id = `engine-holder-${++this.connectionCounter}`\n    const registered = registeredConnection(connection, id)\n\n    this.connections.set(id, registered)\n    this.connectionCounter = Math.max(this.connectionCounter, this.connections.size)\n\n    return id\n  }\n\n  /**\n   * Returns the registered connection for one transport connection id,\n   * auto-registering the given transport view when the first message arrives\n   * before an explicit open (the stdio server has no separate connection-open\n   * frame per client).\n   * @param {string} connectionId - Transport connection id.\n   * @param {LockServerEngineConnection} [transport] - Transport view to register when the id is new.\n   * @returns {LockServerEngineRegisteredConnection | null} - Registered connection, or null when the engine is closed.\n   */\n  ensureConnection(connectionId, transport) {\n    if (this.closed) return null\n\n    const existing = this.connections.get(connectionId)\n\n    if (existing) return existing\n\n    const registered = registeredConnection(transport || {send: () => {}}, connectionId)\n\n    this.connections.set(connectionId, registered)\n    this.connectionCounter = Math.max(this.connectionCounter, this.connections.size)\n\n    return registered\n  }\n\n  /**\n   * Handles one request message from a connection and answers it (or queues\n   * the wait) through the connection's `send`.\n   * @param {string} connectionId - Connection the message arrived on.\n   * @param {Record<string, unknown>} body - Request message.\n   * @returns {void}\n   */\n  handleMessage(connectionId, body) {\n    const registered = this.ensureConnection(connectionId)\n\n    if (this.closed || !registered || !registered.open || !body || typeof body !== \"object\") return\n\n    // Transport-level frames (the connection-open params carrying auth and\n    // protocol version) are answered by the transport's hello-ack, not here;\n    // only request/response traffic with a correlationId reaches the engine.\n    if (body.type === \"hello\" || typeof body.correlationId !== \"string\") return\n\n    const correlationId = typeof body.correlationId === \"string\" ? body.correlationId : \"\"\n    const name = typeof body.name === \"string\" ? body.name : \"\"\n\n    switch (body.type) {\n      case \"acquire\":\n        this.handleAcquire(registered, {correlationId, name, timeoutMs: typeof body.timeoutMs === \"number\" ? body.timeoutMs : undefined})\n\n        return\n      case \"try-acquire\":\n        this.handleTryAcquire(registered, {correlationId, name})\n\n        return\n      case \"renew\":\n        this.handleRenew(registered, {correlationId, epoch: typeof body.epoch === \"number\" ? body.epoch : -1, name})\n\n        return\n      case \"release\":\n        this.handleRelease(registered, {correlationId, epoch: typeof body.epoch === \"number\" ? body.epoch : undefined, name})\n\n        return\n      case \"who-holds\":\n        this.respond(registered, correlationId, {holder: this.holderInfo(name), type: \"response\"})\n\n        return\n      case \"list\":\n        this.respond(registered, correlationId, {holders: this.listHolders(), type: \"response\"})\n\n        return\n      default:\n        this.respond(registered, correlationId, {error: `Unknown lock-server request type: ${String(body.type)}`, status: \"error\", type: \"response\"})\n    }\n  }\n\n  /**\n   * Removes a connection and releases every lease it holds immediately — the\n   * same transport-close semantics the external daemon has.\n   * @param {string} connectionId - Registered connection id.\n   * @returns {void}\n   */\n  connectionClose(connectionId) {\n    const registered = this.connections.get(connectionId)\n\n    if (!registered) return\n\n    this.connections.delete(connectionId)\n    registered.open = false\n\n    for (const name of [...registered.held.keys()]) {\n      const record = this.locks.get(name)\n\n      if (!record || record.holder !== registered) continue\n\n      record.holder = null\n      registered.held.delete(name)\n      this.grantNext(record)\n    }\n  }\n\n  /**\n   * Stops the sweeper and closes every connection (shutdown path).\n   * @returns {void}\n   */\n  close() {\n    this.closed = true\n\n    if (this.sweepTimer) {\n      clearInterval(this.sweepTimer)\n      this.sweepTimer = null\n    }\n\n    for (const registered of [...this.connections.values()]) {\n      try {\n        registered.connection.onClose?.()\n      } catch {\n        // A failing transport close hook must not block the shutdown of the\n        // remaining connections.\n      }\n\n      this.connections.delete(registered.id)\n      registered.open = false\n    }\n  }\n\n  /**\n   * Handles `acquire`: grants immediately, answers `already-held` for a\n   * re-entrant acquisition, or joins the name's FIFO waiter queue with a\n   * bounded timeout.\n   * @param {LockServerEngineRegisteredConnection} registered - Requesting connection.\n   * @param {LockServerEngineRequest & {timeoutMs?: number}} request - Request fields.\n   * @returns {void}\n   */\n  handleAcquire(registered, request) {\n    const {correlationId, name, timeoutMs} = request\n\n    if (!name) {\n      this.respond(registered, correlationId, {error: \"acquire requires a lock name\", status: \"error\", type: \"response\"})\n\n      return\n    }\n\n    const record = this.lockRecord(name)\n    const heldEpoch = registered.held.get(name)\n\n    if (record.holder === registered && typeof heldEpoch === \"number\") {\n      this.respond(registered, correlationId, {epoch: heldEpoch, leaseExpiresAt: record.leaseExpiresAt, status: \"already-held\", type: \"response\"})\n\n      return\n    }\n\n    if (!record.holder) {\n      this.grant(registered, record, correlationId)\n\n      return\n    }\n\n    const waiter = /** @type {LockServerEngineWaiter} */ ({connection: registered, correlationId, name})\n\n    if (typeof timeoutMs === \"number\" && timeoutMs >= 0) {\n      waiter.deadline = Date.now() + timeoutMs\n      const timer = setTimeout(() => this.expireWaiter(record, waiter), timeoutMs)\n\n      timer.unref?.()\n      waiter.timer = timer\n    }\n\n    record.waiters.push(waiter)\n  }\n\n  /**\n   * Handles `try-acquire`: grants when free, answers `busy` when held.\n   * @param {LockServerEngineRegisteredConnection} registered - Requesting connection.\n   * @param {LockServerEngineRequest} request - Request fields.\n   * @returns {void}\n   */\n  handleTryAcquire(registered, request) {\n    const {correlationId, name} = request\n\n    if (!name) {\n      this.respond(registered, correlationId, {error: \"try-acquire requires a lock name\", status: \"error\", type: \"response\"})\n\n      return\n    }\n\n    const record = this.lockRecord(name)\n    const heldEpoch = registered.held.get(name)\n\n    if (record.holder === registered && typeof heldEpoch === \"number\") {\n      this.respond(registered, correlationId, {epoch: heldEpoch, leaseExpiresAt: record.leaseExpiresAt, status: \"already-held\", type: \"response\"})\n\n      return\n    }\n\n    if (record.holder) {\n      this.respond(registered, correlationId, {ownerId: record.holder.id, status: \"busy\", type: \"response\"})\n\n      return\n    }\n\n    this.grant(registered, record, correlationId)\n  }\n\n  /**\n   * Handles `renew` with the fencing check: only the current holder with the\n   * matching epoch may extend the lease; a superseded holder gets `lost` with\n   * the current epoch.\n   * @param {LockServerEngineRegisteredConnection} registered - Renewing connection.\n   * @param {LockServerEngineRequest & {epoch: number}} request - Request fields.\n   * @returns {void}\n   */\n  handleRenew(registered, request) {\n    const {correlationId, epoch, name} = request\n    const record = this.locks.get(name)\n\n    if (!record) {\n      this.respond(registered, correlationId, {status: \"not-found\", type: \"response\"})\n\n      return\n    }\n\n    if (record.holder !== registered || record.epoch !== epoch) {\n      const status = registered.held.has(name) ? \"lost\" : \"not-found\"\n\n      this.respond(registered, correlationId, {currentEpoch: record.epoch, status, type: \"response\"})\n\n      return\n    }\n\n    record.leaseExpiresAt = Date.now() + this.leaseMs\n    this.respond(registered, correlationId, {leaseExpiresAt: record.leaseExpiresAt, status: \"renewed\", type: \"response\"})\n  }\n\n  /**\n   * Handles `release`: idempotent for the holder; `not-holder` after an epoch\n   * bump is the expected answer for a superseded holder.\n   * @param {LockServerEngineRegisteredConnection} registered - Releasing connection.\n   * @param {LockServerEngineRequest & {epoch?: number}} request - Request fields.\n   * @returns {void}\n   */\n  handleRelease(registered, request) {\n    const {correlationId, epoch, name} = request\n    const record = this.locks.get(name)\n\n    if (!record) {\n      this.respond(registered, correlationId, {status: \"not-found\", type: \"response\"})\n\n      return\n    }\n\n    if (record.holder !== registered) {\n      const status = registered.held.has(name) ? \"not-holder\" : \"not-found\"\n\n      this.respond(registered, correlationId, {currentEpoch: record.epoch, status, type: \"response\"})\n\n      return\n    }\n\n    if (typeof epoch === \"number\" && epoch !== record.epoch) {\n      this.respond(registered, correlationId, {currentEpoch: record.epoch, status: \"not-holder\", type: \"response\"})\n\n      return\n    }\n\n    record.holder = null\n    registered.held.delete(name)\n    this.respond(registered, correlationId, {status: \"released\", type: \"response\"})\n    this.grantNext(record)\n  }\n\n  /**\n   * Grants the lock to a connection: bumps the monotonic per-name epoch,\n   * installs the holder, and answers `acquired` echoing the correlation.\n   * @param {LockServerEngineRegisteredConnection} registered - Granted connection.\n   * @param {LockServerEngineLockRecord} record - Lock record.\n   * @param {string} correlationId - Correlation to echo.\n   * @returns {void}\n   */\n  grant(registered, record, correlationId) {\n    const epoch = (this.epochByLock.get(record.name) ?? 0) + 1\n\n    this.epochByLock.set(record.name, epoch)\n    record.epoch = epoch\n    record.holder = registered\n    record.leaseExpiresAt = Date.now() + this.leaseMs\n    registered.held.set(record.name, epoch)\n\n    this.respond(registered, correlationId, {epoch, leaseExpiresAt: record.leaseExpiresAt, status: \"acquired\", type: \"response\"})\n  }\n\n  /**\n   * Moves the FIFO queue's first live waiter into the grant path.\n   * @param {LockServerEngineLockRecord} record - Freed lock record.\n   * @returns {void}\n   */\n  grantNext(record) {\n    while (record.waiters.length > 0) {\n      const waiter = /** @type {LockServerEngineWaiter} */ (record.waiters.shift())\n\n      if (waiter.timer) clearTimeout(waiter.timer)\n      if (!waiter.connection.open) continue\n\n      this.grant(waiter.connection, record, waiter.correlationId)\n\n      return\n    }\n  }\n\n  /**\n   * Removes a waiter whose bounded wait elapsed and answers `timeout`.\n   * @param {LockServerEngineLockRecord} record - Lock record the waiter queued on.\n   * @param {LockServerEngineWaiter} waiter - Expired waiter.\n   * @returns {void}\n   */\n  expireWaiter(record, waiter) {\n    const index = record.waiters.indexOf(waiter)\n\n    if (index >= 0) record.waiters.splice(index, 1)\n    if (!waiter.connection.open) return\n\n    this.respond(waiter.connection, waiter.correlationId, {status: \"timeout\", type: \"response\"})\n  }\n\n  /**\n   * Sweeps expired leases: bumps the epoch (the old holder is fenced), pushes\n   * `lost` to the old holder, and grants the next waiter.\n   * @returns {void}\n   */\n  sweep() {\n    if (this.closed) return\n\n    const now = Date.now()\n\n    for (const record of this.locks.values()) {\n      const holder = record.holder\n\n      if (!holder || record.leaseExpiresAt > now) continue\n\n      const fencedEpoch = record.epoch\n\n      record.holder = null\n      holder.held.delete(record.name)\n      this.epochByLock.set(record.name, fencedEpoch + 1)\n      record.epoch = fencedEpoch + 1\n\n      try {\n        holder.connection.send({epoch: record.epoch, name: record.name, type: \"lost\"})\n      } catch {\n        // A dead transport cannot receive the push; the lease is already gone.\n      }\n\n      this.grantNext(record)\n    }\n  }\n\n  /**\n   * Returns (creating when needed) the live record for one lock name.\n   * @param {string} name - Lock name.\n   * @returns {LockServerEngineLockRecord} - Live record.\n   */\n  lockRecord(name) {\n    const existing = this.locks.get(name)\n\n    if (existing) return existing\n\n    /** @type {LockServerEngineLockRecord} */\n    const record = {epoch: this.epochByLock.get(name) ?? 0, holder: null, leaseExpiresAt: 0, name, waiters: []}\n\n    this.locks.set(name, record)\n\n    return record\n  }\n\n  /**\n   * Current holder info for one name (diagnostics).\n   * @param {string} name - Lock name.\n   * @returns {{epoch: number, holderId: string, leaseExpiresAt: number, name: string, waiterCount: number} | null} - Holder info, or null when free.\n   */\n  holderInfo(name) {\n    const record = this.locks.get(name)\n\n    if (!record || !record.holder) return null\n\n    return {epoch: record.epoch, holderId: record.holder.id, leaseExpiresAt: record.leaseExpiresAt, name, waiterCount: record.waiters.length}\n  }\n\n  /**\n   * Live holder list (diagnostics).\n   * @returns {{epoch: number, holderId: string, leaseExpiresAt: number, name: string, waiterCount: number}[]} - Live holders.\n   */\n  listHolders() {\n    const holders = []\n\n    for (const record of this.locks.values()) {\n      if (!record.holder) continue\n\n      holders.push({epoch: record.epoch, holderId: record.holder.id, leaseExpiresAt: record.leaseExpiresAt, name: record.name, waiterCount: record.waiters.length})\n    }\n\n    return holders\n  }\n\n  /**\n   * Sends one response to a connection.\n   * @param {LockServerEngineRegisteredConnection} registered - Target connection.\n   * @param {string} correlationId - Correlation to echo.\n   * @param {Record<string, unknown>} body - Response fields.\n   * @returns {void}\n   */\n  respond(registered, correlationId, body) {\n    registered.connection.send({...body, correlationId})\n  }\n}\n"]}
@@ -0,0 +1,114 @@
1
+ import net from "node:net";
2
+ /**
3
+ * Unix-domain-socket transport client for the `local` lock-server mode
4
+ * (STC-715). It connects to the local engine server
5
+ * (`src/environment-handlers/node/advisory-lock-lock-server-local-server.js`)
6
+ * over a Unix socket — no listening network port, no `ws` — and spawns that
7
+ * server as a child of this environment when no local engine is running yet.
8
+ *
9
+ * One local engine serves every process on the host that points at the same
10
+ * socket path, which is what makes `local` mode the multi-process single-host
11
+ * answer (embedded mode only coordinates inside one JS realm).
12
+ *
13
+ * Crash detection and bounded restart: when the socket dies, the transport
14
+ * reports `transportClosed` to the backend adapter, which fails pending
15
+ * requests and starts its `reprobeCooldownMs` unavailability cache. The next
16
+ * acquisition after the cooldown reconnects — respawning the engine child when
17
+ * the socket file is gone. The cooldown IS the restart backoff; there is no
18
+ * separate respawn loop.
19
+ */
20
+ export default class AdvisoryLockLockServerLocalClient {
21
+ authToken: string;
22
+ connectTimeoutMs: number;
23
+ leaseMs: number;
24
+ socketPath: string;
25
+ connectionId: string;
26
+ /** @type {net.Socket | null} */
27
+ socket: net.Socket | null;
28
+ /** @type {((body: Record<string, unknown>) => void) | null} */
29
+ onMessage: ((body: Record<string, unknown>) => void) | null;
30
+ /** @type {import("node:child_process").ChildProcess | null} */
31
+ spawnedChild: import("node:child_process").ChildProcess | null;
32
+ closed: boolean;
33
+ dead: boolean;
34
+ stdoutBuffer: string;
35
+ /**
36
+ * Creates the local transport client. No socket or process is touched until
37
+ * `connect()` — constructing this object performs no I/O.
38
+ * @param {object} args - Client options.
39
+ * @param {string} [args.authToken] - Shared secret forwarded in the hello params.
40
+ * @param {number} [args.connectTimeoutMs] - Bounded wait for the socket/engine child to become ready.
41
+ * @param {number} [args.leaseMs] - Lease duration the engine child should use.
42
+ * @param {string} args.socketPath - Unix socket path of the local engine.
43
+ */
44
+ constructor({ authToken, connectTimeoutMs, leaseMs, socketPath }: {
45
+ authToken?: string;
46
+ connectTimeoutMs?: number;
47
+ leaseMs?: number;
48
+ socketPath: string;
49
+ });
50
+ /**
51
+ * Connects to the local engine, spawning the engine child when the socket is
52
+ * not there yet.
53
+ * @returns {Promise<void>} - Resolves once the socket is connected.
54
+ */
55
+ connect(): Promise<void>;
56
+ /**
57
+ * Opens the 1:1 view of the socket connection (one connection per
58
+ * transport, like the websocket adapter).
59
+ * @param {string} _type - Connection role (`lock`).
60
+ * @param {{onMessage: (body: Record<string, unknown>) => void, params: Record<string, unknown>}} args - Connection options.
61
+ * @returns {{ready: Promise<void>, sendMessage: (body: Record<string, unknown>) => void, close: () => void}} - Connection handle.
62
+ */
63
+ openConnection(_type: string, args: {
64
+ onMessage: (body: Record<string, unknown>) => void;
65
+ params: Record<string, unknown>;
66
+ }): {
67
+ ready: Promise<void>;
68
+ sendMessage: (body: Record<string, unknown>) => void;
69
+ close: () => void;
70
+ };
71
+ /**
72
+ * Closes the socket and stops an engine child this client spawned. A child
73
+ * it did not spawn keeps serving the other processes on the host and idles
74
+ * out on its own once its last connection closes.
75
+ * @returns {void}
76
+ */
77
+ close(): void;
78
+ /**
79
+ * Opens the Unix socket and wires the line protocol.
80
+ * @returns {Promise<void>} - Resolves when connected.
81
+ */
82
+ openSocket(): Promise<void>;
83
+ /**
84
+ * Spawns the local engine server as a child of this environment.
85
+ * @returns {void}
86
+ */
87
+ spawnEngineChild(): void;
88
+ /**
89
+ * Writes one protocol message as a JSON line to the socket.
90
+ * @param {Record<string, unknown>} body - Message to send.
91
+ * @returns {void}
92
+ */
93
+ writeLine(body: Record<string, unknown>): void;
94
+ /**
95
+ * Buffers socket data and dispatches complete JSON lines to the message
96
+ * handler.
97
+ * @param {string} chunk - Raw socket chunk.
98
+ * @returns {void}
99
+ */
100
+ handleSocketChunk(chunk: string): void;
101
+ /**
102
+ * Reports transport death to the adapter (crash detection).
103
+ * @param {Error} error - Death reason.
104
+ * @returns {void}
105
+ */
106
+ handleTransportDeath(error: Error): void;
107
+ /**
108
+ * Whether a connect failure means "no engine is listening yet" (spawn it).
109
+ * @param {unknown} error - Connect error.
110
+ * @returns {boolean} - True for ENOENT / ECONNREFUSED on a missing socket.
111
+ */
112
+ socketMissingError(error: unknown): boolean;
113
+ }
114
+ //# sourceMappingURL=advisory-lock-lock-server-local-client.d.ts.map