velocious 1.0.371 → 1.0.373

package/README.md

@@ -11,7 +11,7 @@
 * Per-row association counts via `.withCount(...)` on frontend and backend queries (see [docs/with-count.md](docs/with-count.md))
 * Consumer-defined per-row SQL aggregates/computations via `.queryData(...)` on frontend and backend queries (see [docs/query-data.md](docs/query-data.md))
 * Per-record ability checks via `.abilities(...)` on frontend queries + `record.can(action)` (see [docs/abilities.md](docs/abilities.md))
-* Cross-process broadcast bus for `broadcastToChannel` via `velocious beacon` (see [docs/beacon.md](docs/beacon.md))
+* Cross-process broadcast bus for `broadcastToChannel` via `velocious beacon`, including forked background job runners (see [docs/beacon.md](docs/beacon.md))
 * Rails-style request and database query logging (see [docs/logging.md](docs/logging.md))
 * In-process driver schema metadata caching (see [docs/schema-metadata-cache.md](docs/schema-metadata-cache.md))
 
@@ -1988,3 +1988,13 @@ export default new Configuration({
 ```
 
 Use `configuration.runWithTenant(tenant, callback)` or `Current.tenant()` when custom model/database routing needs to read the active tenant manually.
+
+For Apartment-style project/account databases, mark the logical per-tenant identifier with `tenantOnly: true`, provide `tenantDatabaseProviders`, and run tenant lifecycle commands explicitly. One logical identifier can resolve to any number of physical tenant databases at runtime; provider `listTenants` is queried for every command run so added/removed tenants do not require configuration changes or redeploys.
+
+```sh
+npx velocious db:tenants:create projectTenant
+npx velocious db:tenants:check projectTenant
+npx velocious db:tenants:migrate projectTenant
+```
+
+See [docs/tenant-databases.md](docs/tenant-databases.md) for the full configuration and migration pattern.

package/build/src/background-jobs/job-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"job-runner.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job-runner.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,+CAHW,OAAO,YAAY,EAAE,oBAAoB,GACvC,OAAO,CAAC,IAAI,CAAC,CA2CzB"}
+{"version":3,"file":"job-runner.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/job-runner.js"],"names":[],"mappings":"AA+CA;;;GAGG;AACH,+CAHW,OAAO,YAAY,EAAE,oBAAoB,GACvC,OAAO,CAAC,IAAI,CAAC,CAgDzB"}

package/build/src/background-jobs/job-runner.js

@@ -2,6 +2,42 @@
 import configurationResolver from "../configuration-resolver.js";
 import BackgroundJobRegistry from "./job-registry.js";
 import BackgroundJobsStatusReporter from "./status-reporter.js";
+const BEACON_READY_TIMEOUT_MS = 5000;
+/**
+ * @param {import("../configuration.js").default} configuration - Configuration.
+ * @param {unknown} error - Beacon readiness error.
+ * @returns {void}
+ */
+function reportBeaconReadyError(configuration, error) {
+    const errorEvents = configuration.getErrorEvents();
+    const normalizedError = error instanceof Error ? error : new Error(String(error));
+    const payload = {
+        context: { peerType: "background-jobs-runner", stage: "beacon-ready" },
+        error: normalizedError
+    };
+    const hasListener = errorEvents.listenerCount("framework-error") > 0
+        || errorEvents.listenerCount("all-error") > 0;
+    errorEvents.emit("framework-error", payload);
+    errorEvents.emit("all-error", { ...payload, errorType: "framework-error" });
+    if (!hasListener) {
+        console.error(`[velocious framework-error stage=beacon-ready] ${normalizedError.message}`);
+    }
+}
+/**
+ * @param {import("../configuration.js").default} configuration - Configuration.
+ * @returns {Promise<void>}
+ */
+async function connectBeacon(configuration) {
+    const beaconClient = await configuration.connectBeacon({ peerType: "background-jobs-runner" });
+    if (!beaconClient)
+        return;
+    try {
+        await beaconClient.waitForReady({ timeoutMs: BEACON_READY_TIMEOUT_MS });
+    }
+    catch (error) {
+        reportBeaconReadyError(configuration, error);
+    }
+}
 /**
  * @param {import("./types.js").BackgroundJobPayload} payload - Payload.
  * @returns {Promise<void>} - Resolves when complete.
@@ -10,6 +46,7 @@ export default async function runJobPayload(payload) {
     const configuration = await configurationResolver();
     configuration.setCurrent();
     await configuration.initialize({ type: "background-jobs-runner" });
+    await connectBeacon(configuration);
     const reporter = new BackgroundJobsStatusReporter({ configuration });
     const registry = new BackgroundJobRegistry({ configuration });
     await registry.load();
@@ -18,31 +55,36 @@ export default async function runJobPayload(payload) {
     /** @type {(...args: any[]) => Promise<void>} */
     const perform = jobInstance.perform;
     try {
-        await configuration.withConnections(async () => {
-            await perform.apply(jobInstance, payload.args || []);
-        });
-        if (payload.id) {
-            await reporter.reportWithRetry({
-                jobId: payload.id,
-                status: "completed",
-                workerId: payload.workerId,
-                handedOffAtMs: payload.handedOffAtMs,
-                maxDurationMs: 30000
+        try {
+            await configuration.withConnections(async () => {
+                await perform.apply(jobInstance, payload.args || []);
             });
+            if (payload.id) {
+                await reporter.reportWithRetry({
+                    jobId: payload.id,
+                    status: "completed",
+                    workerId: payload.workerId,
+                    handedOffAtMs: payload.handedOffAtMs,
+                    maxDurationMs: 30000
+                });
+            }
         }
-    }
-    catch (error) {
-        if (payload.id) {
-            await reporter.reportWithRetry({
-                jobId: payload.id,
-                status: "failed",
-                error,
-                workerId: payload.workerId,
-                handedOffAtMs: payload.handedOffAtMs,
-                maxDurationMs: 30000
-            });
+        catch (error) {
+            if (payload.id) {
+                await reporter.reportWithRetry({
+                    jobId: payload.id,
+                    status: "failed",
+                    error,
+                    workerId: payload.workerId,
+                    handedOffAtMs: payload.handedOffAtMs,
+                    maxDurationMs: 30000
+                });
+            }
+            throw error;
         }
-        throw error;
+    }
+    finally {
+        await configuration.disconnectBeacon();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/background-jobs/worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/worker.js"],"names":[],"mappings":"AAUA;IACE;;;;;;;;OAQG;IACH,qEAPG;QAAqD,aAAa;QAC5C,IAAI;QACJ,IAAI;QACJ,uBAAuB;KAG/C,EAyCA;IAvCC,6DAA6D;IAC7D,sBADW,OAAO,CAAC,OAAO,qBAAqB,EAAE,OAAO,CAAC,CAC2C;IACpG,gEAAgE;IAChE,eADW,OAAO,qBAAqB,EAAE,OAAO,GAAG,SAAS,CAC9B;IAC9B,yBAAgB;IAChB,yBAAgB;IAChB;;;;;OAKG;IACH,iCAFU,MAAM,GAAG,SAAS,CAIf;IACb;;;;OAIG;IACH,yBAFU,MAAM,CAEwD;IACxE,oBAAuB;IACvB,8DAA4B;IAC5B,qCAAqC;IACrC,YADW,UAAU,GAAG,SAAS,CACN;IAC3B,uDAAuD;IACvD,gBADW,4BAA4B,GAAG,SAAS,CACpB;IAC/B;;;;;;;;;;OAUG;IACH,oBAFU,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAEO;IAGrC;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAqBzB;IAED;;;;;;;;;;;;OAYG;IACH,qBAHG;QAAsB,SAAS;KAC/B,GAAU,OAAO,CAAC,IAAI,CAAC,CA8BzB;IAED,0BA+BC;IAED;;;OAGG;IACH,oBAHW,OAAO,YAAY,EAAE,oBAAoB,GACvC,OAAO,CAAC,IAAI,CAAC,CA2CzB;IAED;;;OAGG;IACH,gCAHW,OAAO,YAAY,EAAE,oBAAoB,GAAG;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GACtD,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAED;;;;;OAKG;IACH,uBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,uBAHW,OAAO,YAAY,EAAE,oBAAoB,GACvC,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,2BAHW,OAAO,YAAY,EAAE,oBAAoB,GACvC,OAAO,CAAC,IAAI,CAAC,CAuBzB;IAED;;;;;;;;OAQG;IACH,oEAPG;QAAqB,KAAK,EAAlB,MAAM;QACuB,MAAM,EAAnC,WAAW,GAAG,QAAQ;QACP,KAAK,GAApB,OAAO;QACO,aAAa;QACb,QAAQ;KAC9B,GAAU,OAAO,CAAC,IAAI,CAAC,CAUzB;CACF;uBAjTsB,kBAAkB;yCAGA,sBAAsB"}
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/worker.js"],"names":[],"mappings":"AAUA;IACE;;;;;;;;OAQG;IACH,qEAPG;QAAqD,aAAa;QAC5C,IAAI;QACJ,IAAI;QACJ,uBAAuB;KAG/C,EAyCA;IAvCC,6DAA6D;IAC7D,sBADW,OAAO,CAAC,OAAO,qBAAqB,EAAE,OAAO,CAAC,CAC2C;IACpG,gEAAgE;IAChE,eADW,OAAO,qBAAqB,EAAE,OAAO,GAAG,SAAS,CAC9B;IAC9B,yBAAgB;IAChB,yBAAgB;IAChB;;;;;OAKG;IACH,iCAFU,MAAM,GAAG,SAAS,CAIf;IACb;;;;OAIG;IACH,yBAFU,MAAM,CAEwD;IACxE,oBAAuB;IACvB,8DAA4B;IAC5B,qCAAqC;IACrC,YADW,UAAU,GAAG,SAAS,CACN;IAC3B,uDAAuD;IACvD,gBADW,4BAA4B,GAAG,SAAS,CACpB;IAC/B;;;;;;;;;;OAUG;IACH,oBAFU,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAEO;IAGrC;;OAEG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAqBzB;IAED;;;;;;;;;;;;OAYG;IACH,qBAHG;QAAsB,SAAS;KAC/B,GAAU,OAAO,CAAC,IAAI,CAAC,CA8BzB;IAED,0BA+BC;IAED;;;OAGG;IACH,oBAHW,OAAO,YAAY,EAAE,oBAAoB,GACvC,OAAO,CAAC,IAAI,CAAC,CA2CzB;IAED;;;OAGG;IACH,gCAHW,OAAO,YAAY,EAAE,oBAAoB,GAAG;QAAC,EAAE,EAAE,MAAM,CAAA;KAAC,GACtD,OAAO,CAAC,IAAI,CAAC,CAoBzB;IAED;;;;;OAKG;IACH,uBAFa,IAAI,CAKhB;IAED;;;OAGG;IACH,uBAHW,OAAO,YAAY,EAAE,oBAAoB,GACvC,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAED;;;OAGG;IACH,2BAHW,OAAO,YAAY,EAAE,oBAAoB,GACvC,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAED;;;;;;;;OAQG;IACH,oEAPG;QAAqB,KAAK,EAAlB,MAAM;QACuB,MAAM,EAAnC,WAAW,GAAG,QAAQ;QACP,KAAK,GAApB,OAAO;QACO,aAAa;QACb,QAAQ;KAC9B,GAAU,OAAO,CAAC,IAAI,CAAC,CAUzB;CACF;uBAlTsB,kBAAkB;yCAGA,sBAAsB"}

package/build/src/background-jobs/worker.js

@@ -261,6 +261,7 @@ export default class BackgroundJobsWorker {
             detached: true,
             stdio: "ignore",
             env: Object.assign({}, process.env, {
+                VELOCIOUS_ENV: configuration.getEnvironment(),
                 VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,
                 VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`,
                 VELOCIOUS_JOB_PAYLOAD: encodedPayload
@@ -288,4 +289,4 @@ export default class BackgroundJobsWorker {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker.js","sourceRoot":"","sources":["../../../src/background-jobs/worker.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,GAAG,MAAM,KAAK,CAAA;AACrB,OAAO,EAAC,KAAK,EAAC,MAAM,oBAAoB,CAAA;AACxC,OAAO,UAAU,MAAM,kBAAkB,CAAA;AACzC,OAAO,qBAAqB,MAAM,mBAAmB,CAAA;AACrD,OAAO,qBAAqB,MAAM,8BAA8B,CAAA;AAChE,OAAO,4BAA4B,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAC,UAAU,EAAC,MAAM,QAAQ,CAAA;AAEjC,MAAM,CAAC,OAAO,OAAO,oBAAoB;IACvC;;;;;;;;OAQG;IACH,YAAY,EAAC,aAAa,EAAE,IAAI,EAAE,IAAI,EAAE,uBAAuB,EAAC,GAAG,EAAE;QACnE,6DAA6D;QAC7D,IAAI,CAAC,oBAAoB,GAAG,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,qBAAqB,EAAE,CAAA;QACpG,gEAAgE;QAChE,IAAI,CAAC,aAAa,GAAG,SAAS,CAAA;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB;;;;;WAKG;QACH,IAAI,CAAC,+BAA+B,GAAG,OAAO,uBAAuB,KAAK,QAAQ,IAAI,uBAAuB,IAAI,CAAC;YAChH,CAAC,CAAC,uBAAuB;YACzB,CAAC,CAAC,SAAS,CAAA;QACb;;;;WAIG;QACH,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,+BAA+B,IAAI,CAAC,CAAA;QACxE,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;QACvB,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,CAAA;QAC5B,qCAAqC;QACrC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;QAC3B,uDAAuD;QACvD,IAAI,CAAC,cAAc,GAAG,SAAS,CAAA;QAC/B;;;;;;;;;;WAUG;QACH,IAAI,CAAC,kBAAkB,GAAG,IAAI,GAAG,EAAE,CAAA;IACrC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,CAAC,aAAa,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAA;QACpD,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,CAAA;QAC/B,MAAM,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,EAAC,IAAI,EAAE,wBAAwB,EAAC,CAAC,CAAA;QACrE,MAAM,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,EAAC,QAAQ,EAAE,wBAAwB,EAAC,CAAC,CAAA;QAE5E,mEAAmE;QACnE,IAAI,OAAO,IAAI,CAAC,+BAA+B,KAAK,QAAQ,EAAE,CAAC;YAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,uBAAuB,EAAE,CAAA;YAE3D,IAAI,CAAC,uBAAuB,GAAG,MAAM,CAAC,uBAAuB,IAAI,IAAI,CAAC,uBAAuB,CAAA;QAC/F,CAAC;QAED,IAAI,CAAC,cAAc,GAAG,IAAI,4BAA4B,CAAC;YACrD,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,CAAC,CAAA;QACF,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;IACvB,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,IAAI,CAAC,EAAC,SAAS,EAAC,GAAG,EAAE;QACzB,IAAI,IAAI,CAAC,UAAU;YAAE,OAAM;QAC3B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;QAEtB,oEAAoE;QACpE,0CAA0C;QAC1C,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC;gBACH,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,UAAU,EAAC,CAAC,CAAA;YAC1C,CAAC;YAAC,MAAM,CAAC;gBACP,gDAAgD;YAClD,CAAC;QACH,CAAC;QAED,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YACrC,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAA;YAC9D,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;gBACpD,IAAI,KAAK,CAAA;gBACT,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,GAAG,KAAK,GAAG,UAAU,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA,CAAC,CAAC,CAAC,CAAA;gBACpF,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAA;gBACpC,YAAY,CAAC,KAAK,CAAC,CAAA;YACrB,CAAC;iBAAM,CAAC;gBACN,MAAM,KAAK,CAAA;YACb,CAAC;QACH,CAAC;QAED,IAAI,IAAI,CAAC,UAAU;YAAE,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAA;QAC5C,IAAI,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAA;IACrE,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAA;QACxC,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;QAE3F,MAAM,MAAM,GAAG,aAAa,CAAC,uBAAuB,EAAE,CAAA;QACtD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAA;QACrC,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAA;QACpE,MAAM,MAAM,GAAG,GAAG,CAAC,gBAAgB,CAAC,EAAC,IAAI,EAAE,IAAI,EAAC,CAAC,CAAA;QACjD,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAA;QACzC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAE5B,yFAAyF;QACzF,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;YACzC,IAAI,OAAO,EAAE,IAAI,KAAK,KAAK,EAAE,CAAC;gBAC5B,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;YACxC,CAAC;QACH,CAAC,CAAC,CAAA;QAEF,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YAC/B,OAAO,CAAC,KAAK,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAA;QAC9D,CAAC,CAAC,CAAA;QAEF,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;YAC1B,IAAI,IAAI,CAAC,UAAU;gBAAE,OAAM;YAC3B,UAAU,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAA,CAAC,CAAC,EAAE,IAAI,CAAC,CAAA;QAClD,CAAC,CAAC,CAAA;QAEF,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;YACxB,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAC,CAAC,CAAA;YACzE,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC,CAAC,CAAA;QAClC,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU,CAAC,OAAO;QACtB,IAAI,CAAC,OAAO,CAAC,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAA;QACrE,uEAAuE;QACvE,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,CAAC,OAAO,CAAC,CAAA;QAEtD,MAAM,OAAO,GAAG,iBAAiB,CAAC,OAAO,IAAI,EAAE,CAAA;QAC/C,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,KAAK,KAAK,CAAA;QAE3C,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;YAC/C,IAAI,CAAC,mBAAmB,EAAE,CAAA;YAC1B,OAAM;QACR,CAAC;QAED,mEAAmE;QACnE,mEAAmE;QACnE,mEAAmE;QACnE,mDAAmD;QACnD,+DAA+D;QAC/D,kEAAkE;QAClE,gEAAgE;QAChE,iEAAiE;QACjE,6CAA6C;QAC7C,2DAA2D;QAC3D,oCAAoC;QACpC,4BAA4B;QAC5B,IAAI,QAAQ,CAAA;QAEZ,QAAQ,GAAG,IAAI,CAAC,sBAAsB,CAAC,iBAAiB,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YACrE,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;YAExC,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,KAAK,IAAI,CAAC,uBAAuB,GAAG,CAAC,EAAE,CAAC;gBAC1F,IAAI,CAAC,mBAAmB,EAAE,CAAA;YAC5B,CAAC;QACH,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;QAErC,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAChE,IAAI,CAAC,mBAAmB,EAAE,CAAA;QAC5B,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,sBAAsB,CAAC,OAAO;QAClC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAA;YACjC,MAAM,IAAI,CAAC,gBAAgB,CAAC;gBAC1B,KAAK,EAAE,OAAO,CAAC,EAAE;gBACjB,MAAM,EAAE,WAAW;gBACnB,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ;aAC5C,CAAC,CAAA;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,gBAAgB,CAAC;gBAC1B,KAAK,EAAE,OAAO,CAAC,EAAE;gBACjB,MAAM,EAAE,QAAQ;gBAChB,KAAK;gBACL,aAAa,EAAE,OAAO,CAAC,aAAa;gBACpC,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ;aAC5C,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,mBAAmB;QACjB,IAAI,IAAI,CAAC,UAAU;YAAE,OAAM;QAC3B,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,EAAC,IAAI,EAAE,OAAO,EAAC,CAAC,CAAA;IACxC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,aAAa,CAAC,OAAO;QACzB,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAA;QACxC,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;QAE3F,MAAM,QAAQ,GAAG,IAAI,qBAAqB,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;QAC3D,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAA;QACrB,MAAM,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QACvD,MAAM,WAAW,GAAG,IAAI,QAAQ,EAAE,CAAA;QAClC,gDAAgD;QAChD,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAA;QAEnC,MAAM,aAAa,CAAC,eAAe,CAAC,KAAK,IAAI,EAAE;YAC7C,MAAM,OAAO,CAAC,KAAK,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,CAAA;QACtD,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,iBAAiB,CAAC,OAAO;QAC7B,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAA;QACxC,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;QAE3F,MAAM,SAAS,GAAG,aAAa,CAAC,YAAY,EAAE,CAAA;QAC9C,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;QACnC,MAAM,OAAO,GAAG,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,mBAAmB,CAAA;QAC3E,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;QAC9E,MAAM,oBAAoB,GAAG,aAAa,CAAC,uBAAuB,EAAE,CAAA;QACpE,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,wBAAwB,CAAC,EAAE;YACzE,GAAG,EAAE,SAAS;YACd,QAAQ,EAAE,IAAI;YACd,KAAK,EAAE,QAAQ;YACf,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,GAAG,EAAE;gBAClC,8BAA8B,EAAE,oBAAoB,CAAC,IAAI;gBACzD,8BAA8B,EAAE,GAAG,oBAAoB,CAAC,IAAI,EAAE;gBAC9D,qBAAqB,EAAE,cAAc;aACtC,CAAC;SACH,CAAC,CAAA;QAEF,KAAK,CAAC,KAAK,EAAE,CAAA;IACf,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,gBAAgB,CAAC,EAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAC;QACpE,IAAI,CAAC,IAAI,CAAC,cAAc;YAAE,OAAM;QAEhC,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,EAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAC,CAAC,CAAA;QAC5F,CAAC;QAAC,OAAO,WAAW,EAAE,CAAC;YACrB,OAAO,CAAC,KAAK,CAAC,yCAAyC,EAAE,WAAW,CAAC,CAAA;QACvE,CAAC;IACH,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport net from \"net\"\nimport {spawn} from \"node:child_process\"\nimport JsonSocket from \"./json-socket.js\"\nimport BackgroundJobRegistry from \"./job-registry.js\"\nimport configurationResolver from \"../configuration-resolver.js\"\nimport BackgroundJobsStatusReporter from \"./status-reporter.js\"\nimport {randomUUID} from \"crypto\"\n\nexport default class BackgroundJobsWorker {\n  /**\n   * @param {object} [args] - Options.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration.\n   * @param {string} [args.host] - Hostname.\n   * @param {number} [args.port] - Port.\n   * @param {number} [args.maxConcurrentInlineJobs] - Override the\n   *   concurrency cap from `configuration.getBackgroundJobsConfig()`.\n   *   See `BackgroundJobsConfiguration` for what the value means.\n   */\n  constructor({configuration, host, port, maxConcurrentInlineJobs} = {}) {\n    /** @type {Promise<import(\"../configuration.js\").default>} */\n    this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver()\n    /** @type {import(\"../configuration.js\").default | undefined} */\n    this.configuration = undefined\n    this.host = host\n    this.port = port\n    /**\n     * Constructor override for the inline-job concurrency cap. When unset\n     * the cap is read from `configuration.getBackgroundJobsConfig()` in\n     * `start()` (default: 4).\n     * @type {number | undefined}\n     */\n    this.maxConcurrentInlineJobsOverride = typeof maxConcurrentInlineJobs === \"number\" && maxConcurrentInlineJobs >= 1\n      ? maxConcurrentInlineJobs\n      : undefined\n    /**\n     * Resolved cap for inline-job concurrency. Set in `start()`; defaults to\n     * 4 if no configuration value is available.\n     * @type {number}\n     */\n    this.maxConcurrentInlineJobs = this.maxConcurrentInlineJobsOverride || 4\n    this.shouldStop = false\n    this.workerId = randomUUID()\n    /** @type {JsonSocket | undefined} */\n    this.jsonSocket = undefined\n    /** @type {BackgroundJobsStatusReporter | undefined} */\n    this.statusReporter = undefined\n    /**\n     * In-flight inline jobs the worker is currently running. Forked jobs run\n     * in detached child processes so they don't appear here; the worker\n     * doesn't need to wait for them on shutdown — they survive on their own.\n     *\n     * Up to `this.maxConcurrentInlineJobs` of these run in parallel. They\n     * share the worker's process and DB connection pool, so concurrency is\n     * about overlapping I/O waits — use forking for memory isolation across\n     * long-running jobs and for using more cores.\n     * @type {Set<Promise<void>>}\n     */\n    this.inflightInlineJobs = new Set()\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when connected.\n   */\n  async start() {\n    this.configuration = await this.configurationPromise\n    this.configuration.setCurrent()\n    await this.configuration.initialize({type: \"background-jobs-worker\"})\n    await this.configuration.connectBeacon({peerType: \"background-jobs-worker\"})\n\n    // Constructor override wins; otherwise pick up the configured cap.\n    if (typeof this.maxConcurrentInlineJobsOverride !== \"number\") {\n      const config = this.configuration.getBackgroundJobsConfig()\n\n      this.maxConcurrentInlineJobs = config.maxConcurrentInlineJobs || this.maxConcurrentInlineJobs\n    }\n\n    this.statusReporter = new BackgroundJobsStatusReporter({\n      configuration: this.configuration,\n      host: this.host,\n      port: this.port\n    })\n    await this._connect()\n  }\n\n  /**\n   * Gracefully stops the worker: announces draining to the main process so\n   * no new jobs are dispatched, waits for any in-flight inline jobs to\n   * finish (so their results can be reported), then closes the socket and\n   * disconnects from the beacon. Forked jobs are detached child processes\n   * and continue running on their own across the worker exit.\n   *\n   * Pass `{timeoutMs}` to bound how long to wait for in-flight inline jobs\n   * before forcing the socket closed.\n   * @param {object} [args] - Options.\n   * @param {number} [args.timeoutMs] - Max wait for in-flight inline jobs in ms.\n   * @returns {Promise<void>} - Resolves when stopped.\n   */\n  async stop({timeoutMs} = {}) {\n    if (this.shouldStop) return\n    this.shouldStop = true\n\n    // Announce drain so main stops dispatching but keeps the connection\n    // open until we close it ourselves below.\n    if (this.jsonSocket) {\n      try {\n        this.jsonSocket.send({type: \"draining\"})\n      } catch {\n        // Socket may already be closing; nothing to do.\n      }\n    }\n\n    if (this.inflightInlineJobs.size > 0) {\n      const drain = Promise.allSettled([...this.inflightInlineJobs])\n      if (typeof timeoutMs === \"number\" && timeoutMs >= 0) {\n        let timer\n        const timeout = new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs) })\n        await Promise.race([drain, timeout])\n        clearTimeout(timer)\n      } else {\n        await drain\n      }\n    }\n\n    if (this.jsonSocket) this.jsonSocket.close()\n    if (this.configuration) await this.configuration.disconnectBeacon()\n  }\n\n  async _connect() {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\n\n    const config = configuration.getBackgroundJobsConfig()\n    const host = this.host || config.host\n    const port = typeof this.port === \"number\" ? this.port : config.port\n    const socket = net.createConnection({host, port})\n    const jsonSocket = new JsonSocket(socket)\n    this.jsonSocket = jsonSocket\n\n    /** @param {import(\"./types.js\").BackgroundJobSocketMessage} message - Socket message. */\n    jsonSocket.on(\"message\", async (message) => {\n      if (message?.type === \"job\") {\n        await this._handleJob(message.payload)\n      }\n    })\n\n    jsonSocket.on(\"error\", (error) => {\n      console.error(\"Background jobs worker socket error:\", error)\n    })\n\n    jsonSocket.on(\"close\", () => {\n      if (this.shouldStop) return\n      setTimeout(() => { void this._connect() }, 1000)\n    })\n\n    socket.on(\"connect\", () => {\n      jsonSocket.send({type: \"hello\", role: \"worker\", workerId: this.workerId})\n      jsonSocket.send({type: \"ready\"})\n    })\n  }\n\n  /**\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {Promise<void>} - Resolves when done.\n   */\n  async _handleJob(payload) {\n    if (!payload.id) throw new Error(\"Background job payload missing id\")\n    /** @type {import(\"./types.js\").BackgroundJobPayload & {id: string}} */\n    const identifiedPayload = /** @type {any} */ (payload)\n\n    const options = identifiedPayload.options || {}\n    const shouldFork = options.forked !== false\n\n    if (shouldFork) {\n      await this._spawnDetachedJob(identifiedPayload)\n      this._sendReadyIfRunning()\n      return\n    }\n\n    // Inline jobs share the worker's process and DB pool, but each one\n    // is its own async chain — there's no semantic reason to serialize\n    // them. We kick off the job, register it with `inflightInlineJobs`\n    // for shutdown drain, and signal capacity to main:\n    // - If we still have a free slot we ask for the next job right\n    //   away, so a slow job (e.g. a docker alive check that waits 15s\n    //   on a gone server) no longer starves every other inline job.\n    // - When the job finishes, if the worker had been at the cap, we\n    //   ask for the next job to refill the slot.\n    // The bookkeeping in `finally()` ratchets capacity back up\n    // regardless of success or failure.\n    /** @type {Promise<void>} */\n    let inflight\n\n    inflight = this._runInlineJobAndReport(identifiedPayload).finally(() => {\n      this.inflightInlineJobs.delete(inflight)\n\n      if (!this.shouldStop && this.inflightInlineJobs.size === this.maxConcurrentInlineJobs - 1) {\n        this._sendReadyIfRunning()\n      }\n    })\n\n    this.inflightInlineJobs.add(inflight)\n\n    if (this.inflightInlineJobs.size < this.maxConcurrentInlineJobs) {\n      this._sendReadyIfRunning()\n    }\n  }\n\n  /**\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Payload with required id.\n   * @returns {Promise<void>} - Resolves when complete (success or failure reported).\n   */\n  async _runInlineJobAndReport(payload) {\n    try {\n      await this._runJobInline(payload)\n      await this._reportJobResult({\n        jobId: payload.id,\n        status: \"completed\",\n        handedOffAtMs: payload.handedOffAtMs,\n        workerId: payload.workerId || this.workerId\n      })\n    } catch (error) {\n      await this._reportJobResult({\n        jobId: payload.id,\n        status: \"failed\",\n        error,\n        handedOffAtMs: payload.handedOffAtMs,\n        workerId: payload.workerId || this.workerId\n      })\n    }\n  }\n\n  /**\n   * Tells main we're ready for the next job — but only if we haven't been\n   * asked to drain. Once we've sent `draining` we don't want to take more\n   * work.\n   * @returns {void}\n   */\n  _sendReadyIfRunning() {\n    if (this.shouldStop) return\n    this.jsonSocket?.send({type: \"ready\"})\n  }\n\n  /**\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {Promise<void>} - Resolves when done.\n   */\n  async _runJobInline(payload) {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\n\n    const registry = new BackgroundJobRegistry({configuration})\n    await registry.load()\n    const JobClass = registry.getJobByName(payload.jobName)\n    const jobInstance = new JobClass()\n    /** @type {(...args: any[]) => Promise<void>} */\n    const perform = jobInstance.perform\n\n    await configuration.withConnections(async () => {\n      await perform.apply(jobInstance, payload.args || [])\n    })\n  }\n\n  /**\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {Promise<void>} - Resolves when spawned.\n   */\n  async _spawnDetachedJob(payload) {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\n\n    const directory = configuration.getDirectory()\n    const argvCommand = process.argv[1]\n    const command = argvCommand ? argvCommand : `${directory}/bin/velocious.js`\n    const encodedPayload = Buffer.from(JSON.stringify(payload)).toString(\"base64\")\n    const backgroundJobsConfig = configuration.getBackgroundJobsConfig()\n    const child = spawn(process.execPath, [command, \"background-jobs-runner\"], {\n      cwd: directory,\n      detached: true,\n      stdio: \"ignore\",\n      env: Object.assign({}, process.env, {\n        VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,\n        VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`,\n        VELOCIOUS_JOB_PAYLOAD: encodedPayload\n      })\n    })\n\n    child.unref()\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {\"completed\" | \"failed\"} args.status - Status.\n   * @param {unknown} [args.error] - Error.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @param {string} [args.workerId] - Worker id.\n   * @returns {Promise<void>} - Resolves when reported.\n   */\n  async _reportJobResult({jobId, status, error, handedOffAtMs, workerId}) {\n    if (!this.statusReporter) return\n\n    try {\n      await this.statusReporter.reportWithRetry({jobId, status, error, handedOffAtMs, workerId})\n    } catch (reportError) {\n      console.error(\"Background job status reporting failed:\", reportError)\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker.js","sourceRoot":"","sources":["../../../src/background-jobs/worker.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport net from \"net\"\nimport {spawn} from \"node:child_process\"\nimport JsonSocket from \"./json-socket.js\"\nimport BackgroundJobRegistry from \"./job-registry.js\"\nimport configurationResolver from \"../configuration-resolver.js\"\nimport BackgroundJobsStatusReporter from \"./status-reporter.js\"\nimport {randomUUID} from \"crypto\"\n\nexport default class BackgroundJobsWorker {\n  /**\n   * @param {object} [args] - Options.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration.\n   * @param {string} [args.host] - Hostname.\n   * @param {number} [args.port] - Port.\n   * @param {number} [args.maxConcurrentInlineJobs] - Override the\n   *   concurrency cap from `configuration.getBackgroundJobsConfig()`.\n   *   See `BackgroundJobsConfiguration` for what the value means.\n   */\n  constructor({configuration, host, port, maxConcurrentInlineJobs} = {}) {\n    /** @type {Promise<import(\"../configuration.js\").default>} */\n    this.configurationPromise = configuration ? Promise.resolve(configuration) : configurationResolver()\n    /** @type {import(\"../configuration.js\").default | undefined} */\n    this.configuration = undefined\n    this.host = host\n    this.port = port\n    /**\n     * Constructor override for the inline-job concurrency cap. When unset\n     * the cap is read from `configuration.getBackgroundJobsConfig()` in\n     * `start()` (default: 4).\n     * @type {number | undefined}\n     */\n    this.maxConcurrentInlineJobsOverride = typeof maxConcurrentInlineJobs === \"number\" && maxConcurrentInlineJobs >= 1\n      ? maxConcurrentInlineJobs\n      : undefined\n    /**\n     * Resolved cap for inline-job concurrency. Set in `start()`; defaults to\n     * 4 if no configuration value is available.\n     * @type {number}\n     */\n    this.maxConcurrentInlineJobs = this.maxConcurrentInlineJobsOverride || 4\n    this.shouldStop = false\n    this.workerId = randomUUID()\n    /** @type {JsonSocket | undefined} */\n    this.jsonSocket = undefined\n    /** @type {BackgroundJobsStatusReporter | undefined} */\n    this.statusReporter = undefined\n    /**\n     * In-flight inline jobs the worker is currently running. Forked jobs run\n     * in detached child processes so they don't appear here; the worker\n     * doesn't need to wait for them on shutdown — they survive on their own.\n     *\n     * Up to `this.maxConcurrentInlineJobs` of these run in parallel. They\n     * share the worker's process and DB connection pool, so concurrency is\n     * about overlapping I/O waits — use forking for memory isolation across\n     * long-running jobs and for using more cores.\n     * @type {Set<Promise<void>>}\n     */\n    this.inflightInlineJobs = new Set()\n  }\n\n  /**\n   * @returns {Promise<void>} - Resolves when connected.\n   */\n  async start() {\n    this.configuration = await this.configurationPromise\n    this.configuration.setCurrent()\n    await this.configuration.initialize({type: \"background-jobs-worker\"})\n    await this.configuration.connectBeacon({peerType: \"background-jobs-worker\"})\n\n    // Constructor override wins; otherwise pick up the configured cap.\n    if (typeof this.maxConcurrentInlineJobsOverride !== \"number\") {\n      const config = this.configuration.getBackgroundJobsConfig()\n\n      this.maxConcurrentInlineJobs = config.maxConcurrentInlineJobs || this.maxConcurrentInlineJobs\n    }\n\n    this.statusReporter = new BackgroundJobsStatusReporter({\n      configuration: this.configuration,\n      host: this.host,\n      port: this.port\n    })\n    await this._connect()\n  }\n\n  /**\n   * Gracefully stops the worker: announces draining to the main process so\n   * no new jobs are dispatched, waits for any in-flight inline jobs to\n   * finish (so their results can be reported), then closes the socket and\n   * disconnects from the beacon. Forked jobs are detached child processes\n   * and continue running on their own across the worker exit.\n   *\n   * Pass `{timeoutMs}` to bound how long to wait for in-flight inline jobs\n   * before forcing the socket closed.\n   * @param {object} [args] - Options.\n   * @param {number} [args.timeoutMs] - Max wait for in-flight inline jobs in ms.\n   * @returns {Promise<void>} - Resolves when stopped.\n   */\n  async stop({timeoutMs} = {}) {\n    if (this.shouldStop) return\n    this.shouldStop = true\n\n    // Announce drain so main stops dispatching but keeps the connection\n    // open until we close it ourselves below.\n    if (this.jsonSocket) {\n      try {\n        this.jsonSocket.send({type: \"draining\"})\n      } catch {\n        // Socket may already be closing; nothing to do.\n      }\n    }\n\n    if (this.inflightInlineJobs.size > 0) {\n      const drain = Promise.allSettled([...this.inflightInlineJobs])\n      if (typeof timeoutMs === \"number\" && timeoutMs >= 0) {\n        let timer\n        const timeout = new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs) })\n        await Promise.race([drain, timeout])\n        clearTimeout(timer)\n      } else {\n        await drain\n      }\n    }\n\n    if (this.jsonSocket) this.jsonSocket.close()\n    if (this.configuration) await this.configuration.disconnectBeacon()\n  }\n\n  async _connect() {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\n\n    const config = configuration.getBackgroundJobsConfig()\n    const host = this.host || config.host\n    const port = typeof this.port === \"number\" ? this.port : config.port\n    const socket = net.createConnection({host, port})\n    const jsonSocket = new JsonSocket(socket)\n    this.jsonSocket = jsonSocket\n\n    /** @param {import(\"./types.js\").BackgroundJobSocketMessage} message - Socket message. */\n    jsonSocket.on(\"message\", async (message) => {\n      if (message?.type === \"job\") {\n        await this._handleJob(message.payload)\n      }\n    })\n\n    jsonSocket.on(\"error\", (error) => {\n      console.error(\"Background jobs worker socket error:\", error)\n    })\n\n    jsonSocket.on(\"close\", () => {\n      if (this.shouldStop) return\n      setTimeout(() => { void this._connect() }, 1000)\n    })\n\n    socket.on(\"connect\", () => {\n      jsonSocket.send({type: \"hello\", role: \"worker\", workerId: this.workerId})\n      jsonSocket.send({type: \"ready\"})\n    })\n  }\n\n  /**\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {Promise<void>} - Resolves when done.\n   */\n  async _handleJob(payload) {\n    if (!payload.id) throw new Error(\"Background job payload missing id\")\n    /** @type {import(\"./types.js\").BackgroundJobPayload & {id: string}} */\n    const identifiedPayload = /** @type {any} */ (payload)\n\n    const options = identifiedPayload.options || {}\n    const shouldFork = options.forked !== false\n\n    if (shouldFork) {\n      await this._spawnDetachedJob(identifiedPayload)\n      this._sendReadyIfRunning()\n      return\n    }\n\n    // Inline jobs share the worker's process and DB pool, but each one\n    // is its own async chain — there's no semantic reason to serialize\n    // them. We kick off the job, register it with `inflightInlineJobs`\n    // for shutdown drain, and signal capacity to main:\n    // - If we still have a free slot we ask for the next job right\n    //   away, so a slow job (e.g. a docker alive check that waits 15s\n    //   on a gone server) no longer starves every other inline job.\n    // - When the job finishes, if the worker had been at the cap, we\n    //   ask for the next job to refill the slot.\n    // The bookkeeping in `finally()` ratchets capacity back up\n    // regardless of success or failure.\n    /** @type {Promise<void>} */\n    let inflight\n\n    inflight = this._runInlineJobAndReport(identifiedPayload).finally(() => {\n      this.inflightInlineJobs.delete(inflight)\n\n      if (!this.shouldStop && this.inflightInlineJobs.size === this.maxConcurrentInlineJobs - 1) {\n        this._sendReadyIfRunning()\n      }\n    })\n\n    this.inflightInlineJobs.add(inflight)\n\n    if (this.inflightInlineJobs.size < this.maxConcurrentInlineJobs) {\n      this._sendReadyIfRunning()\n    }\n  }\n\n  /**\n   * @param {import(\"./types.js\").BackgroundJobPayload & {id: string}} payload - Payload with required id.\n   * @returns {Promise<void>} - Resolves when complete (success or failure reported).\n   */\n  async _runInlineJobAndReport(payload) {\n    try {\n      await this._runJobInline(payload)\n      await this._reportJobResult({\n        jobId: payload.id,\n        status: \"completed\",\n        handedOffAtMs: payload.handedOffAtMs,\n        workerId: payload.workerId || this.workerId\n      })\n    } catch (error) {\n      await this._reportJobResult({\n        jobId: payload.id,\n        status: \"failed\",\n        error,\n        handedOffAtMs: payload.handedOffAtMs,\n        workerId: payload.workerId || this.workerId\n      })\n    }\n  }\n\n  /**\n   * Tells main we're ready for the next job — but only if we haven't been\n   * asked to drain. Once we've sent `draining` we don't want to take more\n   * work.\n   * @returns {void}\n   */\n  _sendReadyIfRunning() {\n    if (this.shouldStop) return\n    this.jsonSocket?.send({type: \"ready\"})\n  }\n\n  /**\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {Promise<void>} - Resolves when done.\n   */\n  async _runJobInline(payload) {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\n\n    const registry = new BackgroundJobRegistry({configuration})\n    await registry.load()\n    const JobClass = registry.getJobByName(payload.jobName)\n    const jobInstance = new JobClass()\n    /** @type {(...args: any[]) => Promise<void>} */\n    const perform = jobInstance.perform\n\n    await configuration.withConnections(async () => {\n      await perform.apply(jobInstance, payload.args || [])\n    })\n  }\n\n  /**\n   * @param {import(\"./types.js\").BackgroundJobPayload} payload - Payload.\n   * @returns {Promise<void>} - Resolves when spawned.\n   */\n  async _spawnDetachedJob(payload) {\n    const configuration = this.configuration\n    if (!configuration) throw new Error(\"Background jobs worker configuration not initialized\")\n\n    const directory = configuration.getDirectory()\n    const argvCommand = process.argv[1]\n    const command = argvCommand ? argvCommand : `${directory}/bin/velocious.js`\n    const encodedPayload = Buffer.from(JSON.stringify(payload)).toString(\"base64\")\n    const backgroundJobsConfig = configuration.getBackgroundJobsConfig()\n    const child = spawn(process.execPath, [command, \"background-jobs-runner\"], {\n      cwd: directory,\n      detached: true,\n      stdio: \"ignore\",\n      env: Object.assign({}, process.env, {\n        VELOCIOUS_ENV: configuration.getEnvironment(),\n        VELOCIOUS_BACKGROUND_JOBS_HOST: backgroundJobsConfig.host,\n        VELOCIOUS_BACKGROUND_JOBS_PORT: `${backgroundJobsConfig.port}`,\n        VELOCIOUS_JOB_PAYLOAD: encodedPayload\n      })\n    })\n\n    child.unref()\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.jobId - Job id.\n   * @param {\"completed\" | \"failed\"} args.status - Status.\n   * @param {unknown} [args.error] - Error.\n   * @param {number} [args.handedOffAtMs] - Handed off timestamp.\n   * @param {string} [args.workerId] - Worker id.\n   * @returns {Promise<void>} - Resolves when reported.\n   */\n  async _reportJobResult({jobId, status, error, handedOffAtMs, workerId}) {\n    if (!this.statusReporter) return\n\n    try {\n      await this.statusReporter.reportWithRetry({jobId, status, error, handedOffAtMs, workerId})\n    } catch (reportError) {\n      console.error(\"Background job status reporting failed:\", reportError)\n    }\n  }\n}\n"]}

package/build/src/beacon/client.d.ts

@@ -9,6 +9,7 @@ declare const BeaconClient_base: typeof import("eventemitter3").EventEmitter;
  * Lifecycle:
  *   const client = new BeaconClient({host, port, peerType: "server"})
  *   await client.connect()                         // resolves on first successful connect
+ *   await client.waitForReady({timeoutMs: 1000})   // resolves after the daemon hello-ack
  *   client.onBroadcast((message) => { ... })       // every fan-out
  *   client.publish({channel, broadcastParams, body})
  *   await client.close()
@@ -49,6 +50,7 @@ export default class BeaconClient extends BeaconClient_base {
     /** @type {net.Socket | undefined} */
     _socket: net.Socket | undefined;
     _connected: boolean;
+    _ready: boolean;
     _closed: boolean;
     /** @type {NodeJS.Timeout | undefined} */
     _reconnectTimer: NodeJS.Timeout | undefined;
@@ -63,6 +65,8 @@ export default class BeaconClient extends BeaconClient_base {
     getPeerId(): string;
     /** @returns {boolean} - Whether the underlying socket is currently connected. */
     isConnected(): boolean;
+    /** @returns {boolean} - Whether the daemon has acknowledged this peer registration. */
+    isReady(): boolean;
     /**
      * Resolves on the first successful connect. Subsequent calls return
      * the same promise. Subsequent reconnects after a drop are silent —
@@ -73,6 +77,18 @@ export default class BeaconClient extends BeaconClient_base {
      * @returns {Promise<void>}
      */
     connect(): Promise<void>;
+    /**
+     * Resolves after the Beacon daemon has acknowledged this peer's
+     * hello handshake. This is stronger than `isConnected()`: connected
+     * means the TCP socket is open, ready means the daemon has registered
+     * the peer and broadcasts can be routed through the bus.
+     * @param {object} [args] - Options.
+     * @param {number} [args.timeoutMs] - Optional timeout in milliseconds.
+     * @returns {Promise<void>}
+     */
+    waitForReady({ timeoutMs }?: {
+        timeoutMs?: number | undefined;
+    }): Promise<void>;
     /**
      * Publishes a broadcast message to all peers (including this one,
      * unless the daemon is restarted mid-publish).

package/build/src/beacon/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":";AAWA;;GAEG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IACE;;;;;;;;OAQG;IACH,qFAPG;QAAqB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;QACQ,QAAQ;QACR,MAAM;QACN,gBAAgB;QAChB,mBAAmB;KAC3C,EAyBA;IAtBC,aAAgB;IAChB,aAAgB;IAChB,6BAAwB;IACxB,eAAoC;IACpC,iCAA8E;IAC9E,6BAAyE;IACzE,0BAAsD;IACtD,qCAAqC;IACrC,aADW,UAAU,GAAG,SAAS,CACL;IAC5B,qCAAqC;IACrC,SADW,GAAG,CAAC,MAAM,GAAG,SAAS,CACT;IACxB,oBAAuB;IACvB,iBAAoB;IACpB,yCAAyC;IACzC,iBADW,MAAM,CAAC,OAAO,GAAG,SAAS,CACL;IAChC,wCAAwC;IACxC,iBADW,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CACJ;IAChC;;;OAGG;IACH,kBAFU,KAAK,GAAG,SAAS,CAEM;IAGnC,mEAAmE;IACnE,aADc,MAAM,CACc;IAElC,iFAAiF;IACjF,eADc,OAAO,CACmB;IAExC;;;;;;;;OAQG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;OAQG;IACH,4CALG;QAAqB,OAAO,EAApB,MAAM;QACoB,eAAe,EAAzC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACT,IAAI,EAAd,GAAG;KACX,GAAU,OAAO,CAoBnB;IAED;;;;;;OAMG;IACH,qBAHW,sBAAsB,GACpB,MAAM,IAAI,CAKtB;IAED,qEAAqE;IACrE,SADc,OAAO,CAAC,IAAI,CAAC,CAiB1B;IAED;;OAEG;IACH,eAFa,IAAI,CAkEhB;IAED;;OAEG;IACH,sBAFa,IAAI,CAYhB;CACF;qCA/OY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI;uBAPjD,mCAAmC;gBAF1C,UAAU"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":";AAYA;;GAEG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;;;;;;OAQG;IACH,qFAPG;QAAqB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;QACQ,QAAQ;QACR,MAAM;QACN,gBAAgB;QAChB,mBAAmB;KAC3C,EA0BA;IAvBC,aAAgB;IAChB,aAAgB;IAChB,6BAAwB;IACxB,eAAoC;IACpC,iCAA8E;IAC9E,6BAAyE;IACzE,0BAAsD;IACtD,qCAAqC;IACrC,aADW,UAAU,GAAG,SAAS,CACL;IAC5B,qCAAqC;IACrC,SADW,GAAG,CAAC,MAAM,GAAG,SAAS,CACT;IACxB,oBAAuB;IACvB,gBAAmB;IACnB,iBAAoB;IACpB,yCAAyC;IACzC,iBADW,MAAM,CAAC,OAAO,GAAG,SAAS,CACL;IAChC,wCAAwC;IACxC,iBADW,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CACJ;IAChC;;;OAGG;IACH,kBAFU,KAAK,GAAG,SAAS,CAEM;IAGnC,mEAAmE;IACnE,aADc,MAAM,CACc;IAElC,iFAAiF;IACjF,eADc,OAAO,CACmB;IAExC,uFAAuF;IACvF,WADc,OAAO,CACW;IAEhC;;;;;;;;OAQG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;;;;;OAQG;IACH,6BAHG;QAAsB,SAAS;KAC/B,GAAU,OAAO,CAAC,IAAI,CAAC,CA4BzB;IAED;;;;;;;;OAQG;IACH,4CALG;QAAqB,OAAO,EAApB,MAAM;QACoB,eAAe,EAAzC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACT,IAAI,EAAd,GAAG;KACX,GAAU,OAAO,CAoBnB;IAED;;;;;;OAMG;IACH,qBAHW,sBAAsB,GACpB,MAAM,IAAI,CAKtB;IAED,qEAAqE;IACrE,SADc,OAAO,CAAC,IAAI,CAAC,CAiB1B;IAED;;OAEG;IACH,eAFa,IAAI,CAuEhB;IAED;;OAEG;IACH,sBAFa,IAAI,CAYhB;CACF;qCA9RY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI;uBAPjD,mCAAmC;gBAH1C,UAAU"}

package/build/src/beacon/client.js

@@ -1,6 +1,7 @@
 // @ts-check
 import { randomUUID } from "node:crypto";
 import net from "node:net";
+import timeout from "awaitery/build/timeout.js";
 import JsonSocket from "../background-jobs/json-socket.js";
 import EventEmitter from "../utils/event-emitter.js";
 const DEFAULT_RECONNECT_DELAY_MS = 1000;
@@ -15,6 +16,7 @@ const MAX_RECONNECT_DELAY_MS = 30_000;
  * Lifecycle:
  *   const client = new BeaconClient({host, port, peerType: "server"})
  *   await client.connect()                         // resolves on first successful connect
+ *   await client.waitForReady({timeoutMs: 1000})   // resolves after the daemon hello-ack
  *   client.onBroadcast((message) => { ... })       // every fan-out
  *   client.publish({channel, broadcastParams, body})
  *   await client.close()
@@ -49,6 +51,7 @@ export default class BeaconClient extends EventEmitter {
         /** @type {net.Socket | undefined} */
         this._socket = undefined;
         this._connected = false;
+        this._ready = false;
         this._closed = false;
         /** @type {NodeJS.Timeout | undefined} */
         this._reconnectTimer = undefined;
@@ -64,6 +67,8 @@ export default class BeaconClient extends EventEmitter {
     getPeerId() { return this.peerId; }
     /** @returns {boolean} - Whether the underlying socket is currently connected. */
     isConnected() { return this._connected; }
+    /** @returns {boolean} - Whether the daemon has acknowledged this peer registration. */
+    isReady() { return this._ready; }
     /**
      * Resolves on the first successful connect. Subsequent calls return
      * the same promise. Subsequent reconnects after a drop are silent —
@@ -95,6 +100,42 @@ export default class BeaconClient extends EventEmitter {
         this._openSocket();
         return await this._connectPromise;
     }
+    /**
+     * Resolves after the Beacon daemon has acknowledged this peer's
+     * hello handshake. This is stronger than `isConnected()`: connected
+     * means the TCP socket is open, ready means the daemon has registered
+     * the peer and broadcasts can be routed through the bus.
+     * @param {object} [args] - Options.
+     * @param {number} [args.timeoutMs] - Optional timeout in milliseconds.
+     * @returns {Promise<void>}
+     */
+    async waitForReady({ timeoutMs } = {}) {
+        if (this._ready)
+            return;
+        /** @type {() => void} */
+        let cleanup = () => { };
+        const readyPromise = new Promise((resolve) => {
+            const onReady = () => {
+                cleanup();
+                resolve(undefined);
+            };
+            cleanup = () => this.off("ready", onReady);
+            this.on("ready", onReady);
+        });
+        try {
+            if (typeof timeoutMs === "number") {
+                await timeout({ timeout: timeoutMs }, async () => {
+                    await readyPromise;
+                });
+            }
+            else {
+                await readyPromise;
+            }
+        }
+        finally {
+            cleanup();
+        }
+    }
     /**
      * Publishes a broadcast message to all peers (including this one,
      * unless the daemon is restarted mid-publish).
@@ -161,6 +202,7 @@ export default class BeaconClient extends EventEmitter {
         this._jsonSocket = jsonSocket;
         socket.on("connect", () => {
             this._connected = true;
+            this._ready = false;
             this._reconnectDelayMs = this._initialReconnectDelayMs;
             jsonSocket.send({
                 type: "hello",
@@ -171,7 +213,11 @@ export default class BeaconClient extends EventEmitter {
             this.emit("connect");
         });
         jsonSocket.on("message", (/** @type {import("./types.js").BeaconSocketMessage} */ message) => {
-            if (message?.type === "broadcast") {
+            if (message?.type === "hello-ack" && message.peerId === this.peerId) {
+                this._ready = true;
+                this.emit("ready");
+            }
+            else if (message?.type === "broadcast") {
                 this.emit("broadcast", message);
             }
         });
@@ -192,6 +238,7 @@ export default class BeaconClient extends EventEmitter {
         jsonSocket.on("close", () => {
             const wasConnected = this._connected;
             this._connected = false;
+            this._ready = false;
             this._jsonSocket = undefined;
             this._socket = undefined;
             // Explicit close() sets `_closed = true` before ending the socket.
@@ -221,4 +268,4 @@ export default class BeaconClient extends EventEmitter {
         }, delay);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {randomUUID} from \"node:crypto\"\nimport net from \"node:net\"\n\nimport JsonSocket from \"../background-jobs/json-socket.js\"\nimport EventEmitter from \"../utils/event-emitter.js\"\n\nconst DEFAULT_RECONNECT_DELAY_MS = 1000\nconst MAX_RECONNECT_DELAY_MS = 30_000\n\n/**\n * @typedef {function(import(\"./types.js\").BeaconBroadcastMessage): void} BeaconBroadcastHandler\n */\n\n/**\n * BeaconClient connects to a `velocious beacon` daemon and exchanges\n * broadcasts with all peer processes connected to the same daemon.\n *\n * Lifecycle:\n *   const client = new BeaconClient({host, port, peerType: \"server\"})\n *   await client.connect()                         // resolves on first successful connect\n *   client.onBroadcast((message) => { ... })       // every fan-out\n *   client.publish({channel, broadcastParams, body})\n *   await client.close()\n *\n * Reconnect: on socket close (without an explicit `close()` call) the\n * client schedules a reconnect with exponential backoff. While the\n * underlying socket is down, `publish(...)` returns false and the\n * caller can fall back to local-only delivery; subsequent reconnects do\n * not replay missed publishes (Beacon is pubsub, not a queue).\n */\nexport default class BeaconClient extends EventEmitter {\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.host - Beacon host.\n   * @param {number} args.port - Beacon port.\n   * @param {string} [args.peerType] - Optional human-readable peer label.\n   * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).\n   * @param {number} [args.reconnectDelayMs] - Starting reconnect delay in ms.\n   * @param {number} [args.maxReconnectDelayMs] - Maximum reconnect delay in ms.\n   */\n  constructor({host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs}) {\n    super()\n    this.host = host\n    this.port = port\n    this.peerType = peerType\n    this.peerId = peerId || randomUUID()\n    this._initialReconnectDelayMs = reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS\n    this._maxReconnectDelayMs = maxReconnectDelayMs ?? MAX_RECONNECT_DELAY_MS\n    this._reconnectDelayMs = this._initialReconnectDelayMs\n    /** @type {JsonSocket | undefined} */\n    this._jsonSocket = undefined\n    /** @type {net.Socket | undefined} */\n    this._socket = undefined\n    this._connected = false\n    this._closed = false\n    /** @type {NodeJS.Timeout | undefined} */\n    this._reconnectTimer = undefined\n    /** @type {Promise<void> | undefined} */\n    this._connectPromise = undefined\n    /**\n     * Last socket error observed while connected, surfaced as the disconnect reason.\n     * @type {Error | undefined}\n     */\n    this._lastSocketError = undefined\n  }\n\n  /** @returns {string} - The peer id sent on the hello handshake. */\n  getPeerId() { return this.peerId }\n\n  /** @returns {boolean} - Whether the underlying socket is currently connected. */\n  isConnected() { return this._connected }\n\n  /**\n   * Resolves on the first successful connect. Subsequent calls return\n   * the same promise. Subsequent reconnects after a drop are silent —\n   * use `on(\"connect\")` / `on(\"disconnect\", reason)` to observe them.\n   * The `disconnect` listener receives an `Error` reason: either the\n   * underlying socket error, or `Error(\"Beacon broker disconnected\")`\n   * when the close had no preceding error.\n   * @returns {Promise<void>}\n   */\n  async connect() {\n    if (this._closed) throw new Error(\"BeaconClient has been closed\")\n    if (this._connectPromise) return await this._connectPromise\n\n    this._connectPromise = new Promise((resolve, reject) => {\n      const onConnect = () => {\n        this.off(\"connect\", onConnect)\n        this.off(\"connect-error\", onError)\n        resolve()\n      }\n      const onError = (/** @type {Error} */ error) => {\n        this.off(\"connect\", onConnect)\n        this.off(\"connect-error\", onError)\n        reject(error)\n      }\n\n      this.on(\"connect\", onConnect)\n      this.on(\"connect-error\", onError)\n    })\n\n    this._openSocket()\n\n    return await this._connectPromise\n  }\n\n  /**\n   * Publishes a broadcast message to all peers (including this one,\n   * unless the daemon is restarted mid-publish).\n   * @param {object} args - Broadcast args.\n   * @param {string} args.channel - Channel name.\n   * @param {Record<string, any>} args.broadcastParams - Routing params.\n   * @param {any} args.body - Message body.\n   * @returns {boolean} - True if the publish was written to the socket. False if the client is currently disconnected.\n   */\n  publish({channel, broadcastParams, body}) {\n    if (!this._connected || !this._jsonSocket) return false\n\n    /** @type {import(\"./types.js\").BeaconBroadcastMessage} */\n    const message = {\n      type: \"broadcast\",\n      channel,\n      broadcastParams,\n      body,\n      originPeerId: this.peerId\n    }\n\n    try {\n      this._jsonSocket.send(message)\n      return true\n    } catch {\n      return false\n    }\n  }\n\n  /**\n   * Registers a handler called once for every `broadcast` message\n   * received from the daemon (including echoes of this client's own\n   * publishes — synapse-style fan-out).\n   * @param {BeaconBroadcastHandler} handler - Handler.\n   * @returns {() => void} - Unregister function.\n   */\n  onBroadcast(handler) {\n    this.on(\"broadcast\", handler)\n    return () => this.off(\"broadcast\", handler)\n  }\n\n  /** @returns {Promise<void>} - Resolves once the socket is closed. */\n  async close() {\n    this._closed = true\n\n    if (this._reconnectTimer) {\n      clearTimeout(this._reconnectTimer)\n      this._reconnectTimer = undefined\n    }\n\n    if (this._socket) {\n      const socket = this._socket\n\n      await new Promise((resolve) => {\n        socket.once(\"close\", () => resolve(undefined))\n        socket.end()\n      })\n    }\n  }\n\n  /**\n   * @returns {void}\n   */\n  _openSocket() {\n    if (this._closed) return\n\n    const socket = net.createConnection({host: this.host, port: this.port})\n    this._socket = socket\n    const jsonSocket = new JsonSocket(socket)\n    this._jsonSocket = jsonSocket\n\n    socket.on(\"connect\", () => {\n      this._connected = true\n      this._reconnectDelayMs = this._initialReconnectDelayMs\n\n      jsonSocket.send({\n        type: \"hello\",\n        role: \"client\",\n        peerId: this.peerId,\n        peerType: this.peerType\n      })\n\n      this.emit(\"connect\")\n    })\n\n    jsonSocket.on(\"message\", (/** @type {import(\"./types.js\").BeaconSocketMessage} */ message) => {\n      if (message?.type === \"broadcast\") {\n        this.emit(\"broadcast\", message)\n      }\n    })\n\n    jsonSocket.on(\"error\", (error) => {\n      if (!this._connected) {\n        // Initial connect failed — surface to `connect()`'s promise via `connect-error`.\n        // No `error` emit: that channel is for established-session errors; the\n        // initial-connect path is owned by `connect-error`.\n        this.emit(\"connect-error\", error)\n      } else {\n        // Established session error. Cache so the upcoming `close` event can\n        // surface it as the disconnect reason.\n        this._lastSocketError = error\n        this.emit(\"error\", error)\n      }\n    })\n\n    jsonSocket.on(\"close\", () => {\n      const wasConnected = this._connected\n\n      this._connected = false\n      this._jsonSocket = undefined\n      this._socket = undefined\n\n      // Explicit close() sets `_closed = true` before ending the socket.\n      // Don't surface user-initiated teardown as a disconnect \"error\" —\n      // only network-driven drops should be reported.\n      if (wasConnected && !this._closed) {\n        const reason = this._lastSocketError || new Error(\"Beacon broker disconnected\")\n\n        this.emit(\"disconnect\", reason)\n      }\n\n      this._lastSocketError = undefined\n\n      if (this._closed) return\n\n      this._scheduleReconnect()\n    })\n  }\n\n  /**\n   * @returns {void}\n   */\n  _scheduleReconnect() {\n    if (this._reconnectTimer) return\n\n    const delay = this._reconnectDelayMs\n\n    this._reconnectTimer = setTimeout(() => {\n      this._reconnectTimer = undefined\n      this._reconnectDelayMs = Math.min(delay * 2, this._maxReconnectDelayMs)\n      this._openSocket()\n    }, delay)\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/beacon/client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {randomUUID} from \"node:crypto\"\nimport net from \"node:net\"\nimport timeout from \"awaitery/build/timeout.js\"\n\nimport JsonSocket from \"../background-jobs/json-socket.js\"\nimport EventEmitter from \"../utils/event-emitter.js\"\n\nconst DEFAULT_RECONNECT_DELAY_MS = 1000\nconst MAX_RECONNECT_DELAY_MS = 30_000\n\n/**\n * @typedef {function(import(\"./types.js\").BeaconBroadcastMessage): void} BeaconBroadcastHandler\n */\n\n/**\n * BeaconClient connects to a `velocious beacon` daemon and exchanges\n * broadcasts with all peer processes connected to the same daemon.\n *\n * Lifecycle:\n *   const client = new BeaconClient({host, port, peerType: \"server\"})\n *   await client.connect()                         // resolves on first successful connect\n *   await client.waitForReady({timeoutMs: 1000})   // resolves after the daemon hello-ack\n *   client.onBroadcast((message) => { ... })       // every fan-out\n *   client.publish({channel, broadcastParams, body})\n *   await client.close()\n *\n * Reconnect: on socket close (without an explicit `close()` call) the\n * client schedules a reconnect with exponential backoff. While the\n * underlying socket is down, `publish(...)` returns false and the\n * caller can fall back to local-only delivery; subsequent reconnects do\n * not replay missed publishes (Beacon is pubsub, not a queue).\n */\nexport default class BeaconClient extends EventEmitter {\n  /**\n   * @param {object} args - Options.\n   * @param {string} args.host - Beacon host.\n   * @param {number} args.port - Beacon port.\n   * @param {string} [args.peerType] - Optional human-readable peer label.\n   * @param {string} [args.peerId] - Optional explicit peer id (defaults to a random UUID).\n   * @param {number} [args.reconnectDelayMs] - Starting reconnect delay in ms.\n   * @param {number} [args.maxReconnectDelayMs] - Maximum reconnect delay in ms.\n   */\n  constructor({host, port, peerType, peerId, reconnectDelayMs, maxReconnectDelayMs}) {\n    super()\n    this.host = host\n    this.port = port\n    this.peerType = peerType\n    this.peerId = peerId || randomUUID()\n    this._initialReconnectDelayMs = reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS\n    this._maxReconnectDelayMs = maxReconnectDelayMs ?? MAX_RECONNECT_DELAY_MS\n    this._reconnectDelayMs = this._initialReconnectDelayMs\n    /** @type {JsonSocket | undefined} */\n    this._jsonSocket = undefined\n    /** @type {net.Socket | undefined} */\n    this._socket = undefined\n    this._connected = false\n    this._ready = false\n    this._closed = false\n    /** @type {NodeJS.Timeout | undefined} */\n    this._reconnectTimer = undefined\n    /** @type {Promise<void> | undefined} */\n    this._connectPromise = undefined\n    /**\n     * Last socket error observed while connected, surfaced as the disconnect reason.\n     * @type {Error | undefined}\n     */\n    this._lastSocketError = undefined\n  }\n\n  /** @returns {string} - The peer id sent on the hello handshake. */\n  getPeerId() { return this.peerId }\n\n  /** @returns {boolean} - Whether the underlying socket is currently connected. */\n  isConnected() { return this._connected }\n\n  /** @returns {boolean} - Whether the daemon has acknowledged this peer registration. */\n  isReady() { return this._ready }\n\n  /**\n   * Resolves on the first successful connect. Subsequent calls return\n   * the same promise. Subsequent reconnects after a drop are silent —\n   * use `on(\"connect\")` / `on(\"disconnect\", reason)` to observe them.\n   * The `disconnect` listener receives an `Error` reason: either the\n   * underlying socket error, or `Error(\"Beacon broker disconnected\")`\n   * when the close had no preceding error.\n   * @returns {Promise<void>}\n   */\n  async connect() {\n    if (this._closed) throw new Error(\"BeaconClient has been closed\")\n    if (this._connectPromise) return await this._connectPromise\n\n    this._connectPromise = new Promise((resolve, reject) => {\n      const onConnect = () => {\n        this.off(\"connect\", onConnect)\n        this.off(\"connect-error\", onError)\n        resolve()\n      }\n      const onError = (/** @type {Error} */ error) => {\n        this.off(\"connect\", onConnect)\n        this.off(\"connect-error\", onError)\n        reject(error)\n      }\n\n      this.on(\"connect\", onConnect)\n      this.on(\"connect-error\", onError)\n    })\n\n    this._openSocket()\n\n    return await this._connectPromise\n  }\n\n  /**\n   * Resolves after the Beacon daemon has acknowledged this peer's\n   * hello handshake. This is stronger than `isConnected()`: connected\n   * means the TCP socket is open, ready means the daemon has registered\n   * the peer and broadcasts can be routed through the bus.\n   * @param {object} [args] - Options.\n   * @param {number} [args.timeoutMs] - Optional timeout in milliseconds.\n   * @returns {Promise<void>}\n   */\n  async waitForReady({timeoutMs} = {}) {\n    if (this._ready) return\n\n    /** @type {() => void} */\n    let cleanup = () => {}\n    const readyPromise = new Promise((resolve) => {\n      const onReady = () => {\n        cleanup()\n        resolve(undefined)\n      }\n\n      cleanup = () => this.off(\"ready\", onReady)\n      this.on(\"ready\", onReady)\n    })\n\n    try {\n      if (typeof timeoutMs === \"number\") {\n        await timeout({timeout: timeoutMs}, async () => {\n          await readyPromise\n        })\n      } else {\n        await readyPromise\n      }\n    } finally {\n      cleanup()\n    }\n  }\n\n  /**\n   * Publishes a broadcast message to all peers (including this one,\n   * unless the daemon is restarted mid-publish).\n   * @param {object} args - Broadcast args.\n   * @param {string} args.channel - Channel name.\n   * @param {Record<string, any>} args.broadcastParams - Routing params.\n   * @param {any} args.body - Message body.\n   * @returns {boolean} - True if the publish was written to the socket. False if the client is currently disconnected.\n   */\n  publish({channel, broadcastParams, body}) {\n    if (!this._connected || !this._jsonSocket) return false\n\n    /** @type {import(\"./types.js\").BeaconBroadcastMessage} */\n    const message = {\n      type: \"broadcast\",\n      channel,\n      broadcastParams,\n      body,\n      originPeerId: this.peerId\n    }\n\n    try {\n      this._jsonSocket.send(message)\n      return true\n    } catch {\n      return false\n    }\n  }\n\n  /**\n   * Registers a handler called once for every `broadcast` message\n   * received from the daemon (including echoes of this client's own\n   * publishes — synapse-style fan-out).\n   * @param {BeaconBroadcastHandler} handler - Handler.\n   * @returns {() => void} - Unregister function.\n   */\n  onBroadcast(handler) {\n    this.on(\"broadcast\", handler)\n    return () => this.off(\"broadcast\", handler)\n  }\n\n  /** @returns {Promise<void>} - Resolves once the socket is closed. */\n  async close() {\n    this._closed = true\n\n    if (this._reconnectTimer) {\n      clearTimeout(this._reconnectTimer)\n      this._reconnectTimer = undefined\n    }\n\n    if (this._socket) {\n      const socket = this._socket\n\n      await new Promise((resolve) => {\n        socket.once(\"close\", () => resolve(undefined))\n        socket.end()\n      })\n    }\n  }\n\n  /**\n   * @returns {void}\n   */\n  _openSocket() {\n    if (this._closed) return\n\n    const socket = net.createConnection({host: this.host, port: this.port})\n    this._socket = socket\n    const jsonSocket = new JsonSocket(socket)\n    this._jsonSocket = jsonSocket\n\n    socket.on(\"connect\", () => {\n      this._connected = true\n      this._ready = false\n      this._reconnectDelayMs = this._initialReconnectDelayMs\n\n      jsonSocket.send({\n        type: \"hello\",\n        role: \"client\",\n        peerId: this.peerId,\n        peerType: this.peerType\n      })\n\n      this.emit(\"connect\")\n    })\n\n    jsonSocket.on(\"message\", (/** @type {import(\"./types.js\").BeaconSocketMessage} */ message) => {\n      if (message?.type === \"hello-ack\" && message.peerId === this.peerId) {\n        this._ready = true\n        this.emit(\"ready\")\n      } else if (message?.type === \"broadcast\") {\n        this.emit(\"broadcast\", message)\n      }\n    })\n\n    jsonSocket.on(\"error\", (error) => {\n      if (!this._connected) {\n        // Initial connect failed — surface to `connect()`'s promise via `connect-error`.\n        // No `error` emit: that channel is for established-session errors; the\n        // initial-connect path is owned by `connect-error`.\n        this.emit(\"connect-error\", error)\n      } else {\n        // Established session error. Cache so the upcoming `close` event can\n        // surface it as the disconnect reason.\n        this._lastSocketError = error\n        this.emit(\"error\", error)\n      }\n    })\n\n    jsonSocket.on(\"close\", () => {\n      const wasConnected = this._connected\n\n      this._connected = false\n      this._ready = false\n      this._jsonSocket = undefined\n      this._socket = undefined\n\n      // Explicit close() sets `_closed = true` before ending the socket.\n      // Don't surface user-initiated teardown as a disconnect \"error\" —\n      // only network-driven drops should be reported.\n      if (wasConnected && !this._closed) {\n        const reason = this._lastSocketError || new Error(\"Beacon broker disconnected\")\n\n        this.emit(\"disconnect\", reason)\n      }\n\n      this._lastSocketError = undefined\n\n      if (this._closed) return\n\n      this._scheduleReconnect()\n    })\n  }\n\n  /**\n   * @returns {void}\n   */\n  _scheduleReconnect() {\n    if (this._reconnectTimer) return\n\n    const delay = this._reconnectDelayMs\n\n    this._reconnectTimer = setTimeout(() => {\n      this._reconnectTimer = undefined\n      this._reconnectDelayMs = Math.min(delay * 2, this._maxReconnectDelayMs)\n      this._openSocket()\n    }, delay)\n  }\n}\n"]}

package/build/src/beacon/in-process-client.d.ts

@@ -11,7 +11,7 @@ declare const InProcessBeaconClient_base: typeof import("eventemitter3").EventEm
  * `Configuration` can use either client interchangeably.
  *
  * Lifecycle differs from `BeaconClient` in two intentional ways:
- *   - `connect()` resolves immediately; there is no broker to wait for.
+ *   - `connect()` and `waitForReady()` resolve immediately; there is no broker to wait for.
  *   - There is no reconnect loop and no `connect-error` / `disconnect`
  *     event surface, because nothing can fail.
  */
@@ -34,11 +34,18 @@ export default class InProcessBeaconClient extends InProcessBeaconClient_base {
     getPeerId(): string;
     /** @returns {boolean} - Whether the peer is registered with the broker. */
     isConnected(): boolean;
+    /** @returns {boolean} - Whether the peer is ready to publish through the broker. */
+    isReady(): boolean;
     /**
      * Registers with the in-process broker. Idempotent.
      * @returns {Promise<void>}
      */
     connect(): Promise<void>;
+    /**
+     * In-process peers are ready as soon as they are connected.
+     * @returns {Promise<void>}
+     */
+    waitForReady(): Promise<void>;
     /**
      * Publishes a broadcast to every registered peer (including this
      * one). Returns false if `connect()` hasn't been called yet, matching

package/build/src/beacon/in-process-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"in-process-client.d.ts","sourceRoot":"","sources":["../../../src/beacon/in-process-client.js"],"names":[],"mappings":";AAOA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACE;;;;OAIG;IACH,mCAHG;QAAsB,QAAQ;QACR,MAAM;KAC9B,EAQA;IALC,6BAAwB;IACxB,eAAoC;IACpC,oBAAuB;IACvB,uCAAuC;IACvC,aADW,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CACP;IAG9B,mCAAmC;IACnC,aADc,MAAM,CACc;IAElC,2EAA2E;IAC3E,eADc,OAAO,CACmB;IAExC;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;;;;;;;OASG;IACH,4CALG;QAAqB,OAAO,EAApB,MAAM;QACoB,eAAe,EAAzC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACT,IAAI,EAAd,GAAG;KACX,GAAU,OAAO,CAiBnB;IAED;;;;OAIG;IACH,qBAHW,sBAAsB,GACpB,MAAM,IAAI,CAKtB;IAED;;;;OAIG;IACH,2BAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAIhB;IAED,8DAA8D;IAC9D,SADc,OAAO,CAAC,IAAI,CAAC,CAK1B;CACF;qCArGY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI"}
+{"version":3,"file":"in-process-client.d.ts","sourceRoot":"","sources":["../../../src/beacon/in-process-client.js"],"names":[],"mappings":";AAOA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACE;;;;OAIG;IACH,mCAHG;QAAsB,QAAQ;QACR,MAAM;KAC9B,EAQA;IALC,6BAAwB;IACxB,eAAoC;IACpC,oBAAuB;IACvB,uCAAuC;IACvC,aADW,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CACP;IAG9B,mCAAmC;IACnC,aADc,MAAM,CACc;IAElC,2EAA2E;IAC3E,eADc,OAAO,CACmB;IAExC,oFAAoF;IACpF,WADc,OAAO,CACe;IAEpC;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAQzB;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;;;;;OASG;IACH,4CALG;QAAqB,OAAO,EAApB,MAAM;QACoB,eAAe,EAAzC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;QACT,IAAI,EAAd,GAAG;KACX,GAAU,OAAO,CAiBnB;IAED;;;;OAIG;IACH,qBAHW,sBAAsB,GACpB,MAAM,IAAI,CAKtB;IAED;;;;OAIG;IACH,2BAHW,OAAO,YAAY,EAAE,sBAAsB,GACzC,IAAI,CAIhB;IAED,8DAA8D;IAC9D,SADc,OAAO,CAAC,IAAI,CAAC,CAK1B;CACF;qCAhHY,CAAS,IAA2C,EAA3C,OAAO,YAAY,EAAE,sBAAsB,KAAG,IAAI"}