@jeffusion/bungee-core 5.6.0 → 5.6.2

package/dist/main.js

@@ -8126,10 +8126,10 @@ function parseNormalizeCompileAggregate(input, options) {
   if (!hasLogicalConfiguration) {
     context.add("required", "logical_configuration", "Required field is missing");
   }
-  const pluginActivations = parsePluginActivations(root.plugin_activations, "plugin_activations" in root, context, options?.availablePlugins ?? (options ? new Set(options.pluginSchemas.keys()) : undefined));
+  let pluginActivations = parsePluginActivations(root.plugin_activations, "plugin_activations" in root, context, options?.availablePlugins ?? (options ? new Set(options.pluginSchemas.keys()) : undefined));
   if (options?.pluginDependencies) {
     try {
-      options.pluginDependencies.assertClosed(pluginActivations.map(({ plugin_name }) => plugin_name));
+      pluginActivations = options.pluginDependencies.closure(pluginActivations.map(({ plugin_name }) => plugin_name)).map((plugin_name) => ({ plugin_name })).sort(comparePluginNames);
     } catch (error) {
       context.add("invalid_value", "plugin_activations", error instanceof Error ? error.message : String(error));
     }
@@ -12455,7 +12455,7 @@ class PluginDependencyGraph {
   }
 }
 function updatePluginActivations(graph, activated, name, enable) {
-  const active = new Set(activated);
+  const active = new Set(graph.closure(activated));
   graph.dependenciesOf(name);
   if (enable) {
     for (const dependency of graph.closure([name]))
@@ -12479,7 +12479,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@jeffusion/bungee-core",
-    version: "5.6.0",
+    version: "5.6.2",
     description: "Bungee reverse proxy core engine",
     main: "./dist/main.js",
     types: "./dist/main.d.ts",
@@ -188233,8 +188233,6 @@ function restoreWorkerTransportRequest(request, transportSecret) {
     }
   }
   const headers = new Headers(request.headers);
-  if (identity)
-    headers.delete("authorization");
   const strippedHeaders = [];
   headers.forEach((_value, name) => {
     if (name.startsWith("x-bungee-internal-") || name === "x-bungee-next-authorization") {
@@ -211624,8 +211622,6 @@ async function proxyRequest(requestSnapshot, route, upstream, requestLog, config
     stripCredentialHeaders(hookHeaders, managedCredential.policy);
   stripHopHeaders(hookHeaders);
   const finalTargetUrl = new URL(targetUrlForRequest.href);
-  if (attemptOptions?.beforeSend)
-    hookHeaders.delete("authorization");
   const credentialExpectedPath = finalTargetUrl.pathname;
   let credentialRequest;
   if (managedCredential) {
@@ -222853,10 +222849,38 @@ var init_drain_workers = __esm(() => {
 function validStatus(value) {
   return typeof value.retired_id === "string" && RETIRED_ID.test(value.retired_id) && Number.isSafeInteger(value.pending) && value.pending >= 0 && typeof value.complete === "boolean" && Number.isSafeInteger(value.remaining_ms) && value.remaining_ms >= 0 && (!value.complete || value.pending === 0);
 }
+function waitBeforePoll(scheduler, delay, signal) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let timeout;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      bestEffort(() => timeout?.cancel());
+      signal?.removeEventListener("abort", abort);
+      resolve(value);
+    };
+    const abort = () => finish("cancelled");
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) {
+      abort();
+      return;
+    }
+    try {
+      timeout = scheduler.schedule(delay, () => finish("poll"));
+    } catch {
+      finish("unavailable");
+    }
+    if (settled)
+      bestEffort(() => timeout?.cancel());
+  });
+}
 async function waitForAdmissionHandoff(prepared, scheduler, hasRetiredWorkers, signal) {
   if (!hasRetiredWorkers && prepared.handoffStatus === undefined)
     return { kind: "complete" };
   let retiredId = null;
+  let statusFailures = 0;
   while (true) {
     if (signal?.aborted)
       return { kind: "unknown", reason: "cancelled" };
@@ -222873,26 +222897,19 @@ async function waitForAdmissionHandoff(prepared, scheduler, hasRetiredWorkers, s
         return { kind: "complete" };
       if (status.remaining_ms === 0)
         return { kind: "unknown", reason: "expired" };
-      const resumed = await new Promise((resolve) => {
-        let settled = false;
-        const finish = (value) => {
-          if (settled)
-            return;
-          settled = true;
-          timeout.cancel();
-          signal?.removeEventListener("abort", abort);
-          resolve(value);
-        };
-        const timeout = scheduler.schedule(Math.max(1, Math.min(100, status.remaining_ms)), () => finish(true));
-        const abort = () => finish(false);
-        signal?.addEventListener("abort", abort, { once: true });
-        if (signal?.aborted)
-          abort();
-      });
-      if (!resumed)
+      const resumed = await waitBeforePoll(scheduler, Math.max(1, Math.min(100, status.remaining_ms)), signal);
+      if (resumed !== "poll")
+        return { kind: "unknown", reason: resumed };
+    } catch (error) {
+      if (signal?.aborted)
         return { kind: "unknown", reason: "cancelled" };
-    } catch {
-      return { kind: "unknown", reason: signal?.aborted ? "cancelled" : "unavailable" };
+      const code = typeof error === "object" && error !== null ? error.code : undefined;
+      const retryable = code === undefined || ["network", "timeout", "unavailable", "control_recovering", "outcome_unknown"].includes(String(code));
+      if (!retryable || ++statusFailures > 2)
+        return { kind: "unknown", reason: "unavailable" };
+      const resumed = await waitBeforePoll(scheduler, 100, signal);
+      if (resumed !== "poll")
+        return { kind: "unknown", reason: resumed };
     }
   }
 }
@@ -223026,14 +223043,15 @@ function command(active, attempt, pluginCatalogHash) {
 function failureDetail(failures) {
   return failures.map(({ slot, code }) => `${slot}:${code}`).join(", ").slice(0, 512) || "publication failed";
 }
-function publicationPhase(options, active, phase, boundary) {
+function publicationPhase(options, active, phase, boundary, handoffReason) {
   try {
     (options.stderr ?? process.stderr).write(`${JSON.stringify({
       event: "publication_phase",
       phase,
       boundary,
       mutation_id: active.operation.mutation_id,
-      revision: active.snapshot.revision
+      revision: active.snapshot.revision,
+      ...handoffReason === undefined ? {} : { handoff_reason: handoffReason }
     })}
 `);
   } catch {}
@@ -223324,10 +223342,22 @@ async function runPublication(options, active, oldWorkers) {
       }
       throw error;
     }
-    const handoff = await waitForAdmissionHandoff(preparedAdmission, options.scheduler, oldWorkers.length > 0, options.signal);
+    publicationPhase(options, refreshed, "admission.handoff", "enter");
+    let handoff;
+    try {
+      handoff = await waitForAdmissionHandoff(preparedAdmission, options.scheduler, oldWorkers.length > 0, options.signal);
+    } finally {
+      publicationPhase(options, refreshed, "admission.handoff", "exit", handoff?.kind === "unknown" ? handoff.reason : undefined);
+    }
     if (handoff.kind === "unknown")
       return retiredOutcomeUnknown(options, oldWorkers, new Error(`retired ingress handoff is unknown: ${handoff.reason}`));
-    const drainEvidence = await drainWorkersUntilKnown(oldWorkers, options.scheduler, publicationPolicy, () => throwIfPublicationCancelled(options.signal, admissionCommitMayHaveBeenSent));
+    publicationPhase(options, refreshed, "drainWorkers", "enter");
+    let drainEvidence;
+    try {
+      drainEvidence = await drainWorkersUntilKnown(oldWorkers, options.scheduler, publicationPolicy, () => throwIfPublicationCancelled(options.signal, admissionCommitMayHaveBeenSent));
+    } finally {
+      publicationPhase(options, refreshed, "drainWorkers", "exit");
+    }
     throwIfPublicationCancelled(options.signal, admissionCommitMayHaveBeenSent);
     const failuresDuringDrain = drainFailures(drainEvidence);
     const recoveringWithoutOldOwnership = options.recoveringMaster && oldWorkers.length === 0 && await options.confirmPreviousWorkersExited?.(options.owned.serving()) !== true;
@@ -225434,7 +225464,7 @@ async function togglePluginActivation(request, pluginName, enable, options) {
       return json({ error: "unauthorized" }, 401);
     const activations = active.aggregate.plugin_activations;
     const activated = activations.some((activation) => activation.plugin_name === pluginName);
-    if (activated === enable)
+    if (!options.pluginDependencies && activated === enable)
       return unchangedMutationResponse(options, active.revision);
     let nextActivations;
     if (options.pluginDependencies) {
@@ -225447,6 +225477,8 @@ async function togglePluginActivation(request, pluginName, enable, options) {
     } else {
       nextActivations = enable ? [...activations, { plugin_name: pluginName }].sort((left, right) => left.plugin_name.localeCompare(right.plugin_name)) : activations.filter((activation) => activation.plugin_name !== pluginName);
     }
+    if (nextActivations.length === activations.length && nextActivations.every((value, index) => value.plugin_name === activations[index]?.plugin_name))
+      return unchangedMutationResponse(options, active.revision);
     const next = { ...active.aggregate, plugin_activations: nextActivations };
     return commitConfigurationMutation(request, options, {
       active,
@@ -225481,12 +225513,15 @@ async function importConfig(request, options) {
     const active = activeResult;
     if (!await options.managementAuth?.recheck(request) || !matchesCurrentAuth(request, active, options))
       return json({ error: "unauthorized" }, 401);
-    const parsed = options.parseAggregate(envelope.aggregate);
+    const exported = parseNormalizeCompileAggregate(envelope.aggregate);
+    if (!exported.ok)
+      return json({ error: "invalid_configuration", errors: exported.errors }, 422);
+    if (envelope.content_hash !== hashConfigurationContent(exported.value))
+      return json({ error: "invalid_snapshot" }, 400);
+    const parsed = options.parseAggregate(exported.value);
     if (!parsed.ok)
       return json({ error: "invalid_configuration", errors: parsed.errors }, 422);
     freezeJson3(parsed.value);
-    if (envelope.content_hash !== hashConfigurationContent(parsed.value))
-      return json({ error: "invalid_snapshot" }, 400);
     return commitConfigurationMutation(request, options, {
       active,
       next: parsed.value,
@@ -225727,6 +225762,7 @@ var init_control_api = __esm(() => {
   init_config_storage();
   init_repository_validation();
   init_content_hash();
+  init_aggregate();
   init_plugin_name();
   init_logger();
   init_error_chain();
@@ -228420,6 +228456,39 @@ var init_master_plugin_catalog_api = __esm(() => {
   ];
 });
 
+// src/master-runtime/reconcile-plugin-dependencies.ts
+import { randomUUID as randomUUID17 } from "crypto";
+function reconcilePluginDependencies(repository, options, workerCount, now, managementProviders) {
+  const current = repository.getSnapshot();
+  if (!options.pluginDependencies)
+    return current;
+  const required = options.pluginDependencies.closure(current.aggregate.plugin_activations.map((value) => value.plugin_name));
+  if (required.length === current.aggregate.plugin_activations.length)
+    return current;
+  const parsed = parseNormalizeCompileAggregate(current.aggregate, options);
+  if (!parsed.ok)
+    throw new ConfigRepositoryError("invalid_configuration", "configuration dependency reconciliation failed", parsed.errors);
+  const active = new Set(current.aggregate.plugin_activations.map((value) => value.plugin_name));
+  if (required.some((name) => managementProviders.has(name) && !active.has(name))) {
+    throw new ConfigRepositoryError("invalid_configuration", "dependency activation changes management authentication; enable the provider through management setup before upgrading");
+  }
+  const result = repository.commit({
+    mutation_id: randomUUID17(),
+    expected_revision: current.revision,
+    aggregate: parsed.value,
+    kind: "config",
+    created_at: now,
+    target_worker_slots: Array.from({ length: workerCount }, (_, slot) => slot)
+  });
+  if (result.kind !== "committed") {
+    throw new ConfigRepositoryError("invalid_operation", `configuration dependency reconciliation blocked: ${result.kind}`);
+  }
+  return result.snapshot;
+}
+var init_reconcile_plugin_dependencies = __esm(() => {
+  init_config_storage();
+});
+
 // src/ui/assets.ts
 function decodeBase64Asset(content) {
   return new Blob([Uint8Array.from(atob(content), (character) => character.charCodeAt(0))]);
@@ -228917,7 +228986,7 @@ var init_daemon_control2 = __esm(() => {
 
 // src/master-runtime/composition.ts
 import { AsyncLocalStorage } from "async_hooks";
-import { randomUUID as randomUUID17, createHash as createHash6 } from "crypto";
+import { randomUUID as randomUUID18, createHash as createHash6 } from "crypto";
 import { resolve as resolve14 } from "path";
 function cleanupWorkersAfterStartupFailure(factory, disposition) {
   if (disposition === undefined || disposition.kind === "shutdown_safe_empty") {
@@ -229098,7 +229167,7 @@ class DurableRouteProtections {
       const previous = this.state?.get(name), value = { plugin: name, routeIds: [...routeIds] };
       if (this.state && JSON.stringify(previous?.value) !== JSON.stringify(value))
         this.state.execute({
-          commandId: randomUUID17(),
+          commandId: randomUUID18(),
           mutations: [{ key: name, expectedVersion: previous?.version ?? 0, value }]
         });
       if (routeIds.length)
@@ -229153,7 +229222,7 @@ async function startMasterComposition(dependencies, daemonBootstrap = null) {
       if (createClaim === undefined || bootstrap.claimControllerWithCapability === undefined) {
         throw new MasterRuntimeError("startup_incomplete", "supervision claim is unavailable");
       }
-      supervisionState = bootstrap.claimControllerWithCapability(createClaim(configLock, accessLock), randomUUID17(), dependencies.clock.now());
+      supervisionState = bootstrap.claimControllerWithCapability(createClaim(configLock, accessLock), randomUUID18(), dependencies.clock.now());
       await bootstrap.close();
       resources.repository = null;
     }
@@ -229182,6 +229251,10 @@ async function startMasterComposition(dependencies, daemonBootstrap = null) {
     if (dependencies.createIngressController !== undefined && supervisionState === null) {
       throw new MasterRuntimeError("startup_incomplete", "supervision state was not claimed");
     }
+    if (compileOptions.pluginDependencies) {
+      const managementProviders = new Set((catalog.records?.() ?? []).filter((record) => record.manifest.management).map((record) => record.name));
+      reconcilePluginDependencies(resources.repository, compileOptions, options.workerCount, dependencies.clock.now(), managementProviders);
+    }
     const configDatabase = resources.repository.getDatabase?.();
     const accessDatabase = resources.stats?.getDatabase?.();
     const secretStores = configDatabase === undefined ? {
@@ -229198,10 +229271,10 @@ async function startMasterComposition(dependencies, daemonBootstrap = null) {
     const rpcIdentityState = durableState?.forNamespace("core-master-state-rpc");
     let rpcIdentity = rpcIdentityState?.get("identity");
     if (rpcIdentityState && !rpcIdentity) {
-      rpcIdentity = rpcIdentityState.execute({ commandId: randomUUID17(), mutations: [{ key: "identity", expectedVersion: 0, value: { process_instance_id: supervisionState?.instance_id ?? randomUUID17(), boot_nonce: randomUUID17() } }] })[0];
+      rpcIdentity = rpcIdentityState.execute({ commandId: randomUUID18(), mutations: [{ key: "identity", expectedVersion: 0, value: { process_instance_id: supervisionState?.instance_id ?? randomUUID18(), boot_nonce: randomUUID18() } }] })[0];
     }
     const stableIdentity = rpcIdentity?.value;
-    const masterStateIdentity = { role: "ingress", process_instance_id: stableIdentity?.process_instance_id ?? randomUUID17(), boot_nonce: stableIdentity?.boot_nonce ?? randomUUID17() };
+    const masterStateIdentity = { role: "ingress", process_instance_id: stableIdentity?.process_instance_id ?? randomUUID18(), boot_nonce: stableIdentity?.boot_nonce ?? randomUUID18() };
     let publishPolicy = async () => false;
     const managementOrigin = parseManagementOrigin(process.env.BUNGEE_PUBLIC_ORIGIN);
     const trustedProxyAddresses = parseTrustedManagementProxies(process.env.BUNGEE_TRUSTED_MANAGEMENT_PROXIES);
@@ -229296,7 +229369,7 @@ async function startMasterComposition(dependencies, daemonBootstrap = null) {
         stateLeases.set(record.key, record.value);
     const saveStateLease = (id, lease) => {
       const previous = leaseState?.get(id);
-      leaseState?.execute({ commandId: randomUUID17(), mutations: [{ key: id, expectedVersion: previous?.version ?? 0, value: lease ? { ...lease } : null }] });
+      leaseState?.execute({ commandId: randomUUID18(), mutations: [{ key: id, expectedVersion: previous?.version ?? 0, value: lease ? { ...lease } : null }] });
       if (lease)
         stateLeases.set(id, lease);
       else
@@ -229371,7 +229444,7 @@ async function startMasterComposition(dependencies, daemonBootstrap = null) {
             if (!lease)
               saveStateLease(id, { worker: workerId, principal, plugin: call.plugin });
             if (!requestLease)
-              requestLeaseState?.execute({ commandId: randomUUID17(), mutations: [{ key: requestLeaseId, expectedVersion: 0, value: { worker: workerId, principal, plugin: call.plugin } }] });
+              requestLeaseState?.execute({ commandId: randomUUID18(), mutations: [{ key: requestLeaseId, expectedVersion: 0, value: { worker: workerId, principal, plugin: call.plugin } }] });
           }
           if (call.method === "settle")
             await resources.ingressController.freezePluginKey(call.plugin, call.target.principal.keyId);
@@ -230747,6 +230820,7 @@ var init_composition = __esm(() => {
   init_plugin_control();
   init_master_http_bridge();
   init_master_plugin_catalog_api();
+  init_reconcile_plugin_dependencies();
   init_server();
   init_daemon_control2();
   NO_INGRESS_STARTUP_FAILURE_DISPOSITION = Object.freeze({
@@ -230799,7 +230873,6 @@ function privateRequestHeaders(request, transportSecret, trustedPeer, identity)
   }
   if (identity) {
     const wire = JSON.stringify(identity);
-    headers.delete("authorization");
     headers.set(INTERNAL_DATA_IDENTITY_HEADER, wire);
     headers.set(INTERNAL_DATA_IDENTITY_MAC_HEADER, signDataIdentity(wire, request.method, request.url, transportSecret));
   }
@@ -230837,7 +230910,7 @@ var init_headers = __esm(() => {
 });
 
 // src/public-listener/forwarding.ts
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 function errorResponse4(status) {
   const error = status === 503 ? "service_unavailable" : status === 502 ? "bad_gateway" : "client_closed_request";
   const headers = new Headers(JSON_HEADERS6);
@@ -230859,7 +230932,7 @@ async function forwardToSelectedWorker(request, options, trustedPeer) {
     });
   }
   const principal = options.authenticate?.(request) ?? ANONYMOUS_PRINCIPAL;
-  const identity = { requestId: randomUUID18(), principal };
+  const identity = { requestId: randomUUID19(), principal };
   const lease = options.admission.acquire();
   const worker = lease.worker;
   if (worker === null) {
@@ -230893,7 +230966,7 @@ async function forwardToSelectedWorker(request, options, trustedPeer) {
     try {
       logger.warn({ ingressForwarding: {
         phase: "private_response_headers",
-        correlation_id: randomUUID18(),
+        correlation_id: randomUUID19(),
         error_code: errorCode,
         elapsed_ms: Math.max(0, Math.round(performance.now() - startedAt))
       } }, "Ingress private request forwarding failed");
@@ -231157,7 +231230,7 @@ var init_admission_registry2 = __esm(() => {
 });
 
 // src/ingress/supervision-http.ts
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 function optionalAdmission(value) {
   return value === null ? null : parseAdmissionSet(value);
 }
@@ -231716,7 +231789,7 @@ class IngressControllerClient {
     }
     return value;
   }
-  async challenge(authority, requestId = randomUUID19(), sequence = 1, signal) {
+  async challenge(authority, requestId = randomUUID20(), sequence = 1, signal) {
     if (signal?.aborted)
       throw signal.reason;
     this.statusRequestSequence = Math.max(this.statusRequestSequence, sequence + 1);
@@ -231731,7 +231804,7 @@ class IngressControllerClient {
   async status(authority, sequence = this.statusRequestSequence, signal) {
     if (signal?.aborted)
       throw signal.reason;
-    const requestId = randomUUID19();
+    const requestId = randomUUID20();
     const message = signSupervisionMessage({
       protocol: "bungee-supervision-v1",
       kind: "status",
@@ -231749,13 +231822,13 @@ class IngressControllerClient {
       throw signal.reason;
     return this.verifyStatus(response, authority, requestId);
   }
-  async fence(authority, sequence, requestId = randomUUID19(), signal) {
+  async fence(authority, sequence, requestId = randomUUID20(), signal) {
     const response = await this.command(authority, sequence, "/admission/fence", null, requestId, signal);
     if (signal?.aborted)
       throw signal.reason;
     return this.verifyStatus(response, authority, requestId);
   }
-  async attach(challenge, authority, sequence = 1, requestId = randomUUID19(), signal) {
+  async attach(challenge, authority, sequence = 1, requestId = randomUUID20(), signal) {
     if (signal?.aborted)
       throw signal.reason;
     this.statusRequestSequence = Math.max(this.statusRequestSequence, sequence + 1);
@@ -231774,7 +231847,7 @@ class IngressControllerClient {
       throw signal.reason;
     return this.verifyStatus(response, authority, requestId);
   }
-  async lease(authority, leaseExpiresAt, sequence, requestId = randomUUID19(), signal) {
+  async lease(authority, leaseExpiresAt, sequence, requestId = randomUUID20(), signal) {
     if (signal?.aborted)
       throw signal.reason;
     this.statusRequestSequence = Math.max(this.statusRequestSequence, sequence + 1);
@@ -231793,7 +231866,7 @@ class IngressControllerClient {
       throw signal.reason;
     return this.verifyStatus(response, authority, requestId);
   }
-  async command(authority, sequence, path, body, requestId = randomUUID19(), signal) {
+  async command(authority, sequence, path, body, requestId = randomUUID20(), signal) {
     if (signal?.aborted)
       throw signal.reason;
     this.statusRequestSequence = Math.max(this.statusRequestSequence, sequence + 1);
@@ -232251,7 +232324,7 @@ var init_ingress2 = __esm(async () => {
 });
 
 // src/master-runtime/supervised-worker-client.ts
-import { randomUUID as randomUUID20 } from "crypto";
+import { randomUUID as randomUUID21 } from "crypto";
 function plain8(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
     throw new WorkerControllerClientError("protocol", "supervision response must be a plain object");
@@ -232730,7 +232803,7 @@ class WorkerControllerClient {
       try {
         if (this.stopped || this.terminating || controller.signal.aborted || Date.now() >= deadline)
           throw new WorkerControllerClientError("timeout", "worker runtime snapshot timed out");
-        const requestId = randomUUID20();
+        const requestId = randomUUID21();
         const sequence = this.nextSequence();
         const message = signSupervisionMessage({
           protocol: "bungee-supervision-v1",
@@ -232756,7 +232829,7 @@ class WorkerControllerClient {
     }, controller.signal, deadline).finally(finish);
   }
   async challenge(signal = this.ordinaryAbort.signal) {
-    const requestId = randomUUID20();
+    const requestId = randomUUID21();
     const sequence = this.nextSequence();
     const response = plain8(await this.fetchJson("/__supervision/challenge", {
       controller_epoch: this.options.authority.controller_epoch,
@@ -232772,7 +232845,7 @@ class WorkerControllerClient {
   }
   async attachOnce(signal = this.ordinaryAbort.signal) {
     const challengeNonce = await this.challenge(signal);
-    const attachId = randomUUID20();
+    const attachId = randomUUID21();
     const attachSequence = this.nextSequence();
     const attach = signSupervisionMessage({
       protocol: "bungee-supervision-v1",
@@ -232799,7 +232872,7 @@ class WorkerControllerClient {
         throw error;
       }
     }
-    const leaseId = randomUUID20();
+    const leaseId = randomUUID21();
     const leaseSequence = this.nextSequence();
     const leaseStartedAt = performance.now();
     const lease = signSupervisionMessage({
@@ -232844,7 +232917,7 @@ class WorkerControllerClient {
     }, delayMs);
   }
   async renewOnce(signal = this.ordinaryAbort.signal) {
-    const requestId = randomUUID20();
+    const requestId = randomUUID21();
     const sequence = this.nextSequence();
     const leaseStartedAt = performance.now();
     const lease = signSupervisionMessage({
@@ -232889,12 +232962,11 @@ class WorkerControllerClient {
     return this.enqueueRenewal((signal) => this.renewOnce(signal));
   }
   status(timeoutMs = this.timeoutMs) {
-    const budget = this.leaseDeadlineAt === null ? timeoutMs : Math.max(1, Math.min(timeoutMs, this.leaseDeadlineAt - performance.now()));
-    const deadline = performance.now() + budget;
+    const deadline = performance.now() + timeoutMs;
     return this.enqueue(() => deadline <= performance.now() ? Promise.reject(new WorkerControllerClientError("timeout", "worker status deadline expired")) : this.statusOnce(this.ordinaryAbort.signal, deadline));
   }
   async statusOnce(signal = this.ordinaryAbort.signal, deadline) {
-    const requestId = randomUUID20();
+    const requestId = randomUUID21();
     const sequence = this.nextSequence();
     const message = signSupervisionMessage({
       protocol: "bungee-supervision-v1",
@@ -232927,7 +232999,7 @@ class WorkerControllerClient {
     });
   }
   async commandOnce(path, body, signal, allowTerminating = false, deadline) {
-    const requestId = randomUUID20();
+    const requestId = randomUUID21();
     const sequence = this.nextSequence();
     const message = signSupervisionMessage({
       protocol: "bungee-supervision-v1",
@@ -232976,7 +233048,7 @@ class WorkerControllerClient {
     for (const controller of this.runtimeControllers)
       controller.abort("disconnected");
     if (expireLease && !this.terminating && this.state === "attached") {
-      const requestId = randomUUID20();
+      const requestId = randomUUID21();
       const sequence = this.nextSequence();
       const lease = signSupervisionMessage({
         protocol: "bungee-supervision-v1",
@@ -233214,6 +233286,7 @@ class SupervisedConfigWorkerProcessAdapter {
   stopped = false;
   drainPoll = null;
   drainCommand = null;
+  drainStatusFailureReported = false;
   exitPublication = null;
   kernelBootId;
   constructor(options) {
@@ -233416,7 +233489,23 @@ class SupervisedConfigWorkerProcessAdapter {
     return status;
   }
   async drainStatus(timeoutMs) {
-    const status = await this.status(timeoutMs);
+    const startedAt = performance.now();
+    let status;
+    try {
+      status = await this.status(timeoutMs);
+      this.drainStatusFailureReported = false;
+    } catch (error) {
+      if (!this.drainStatusFailureReported) {
+        this.drainStatusFailureReported = true;
+        recordShutdownFailure("worker_drain_status", {
+          pid: this.pid,
+          origin: this.origin,
+          elapsedMs: shutdownElapsedMs(startedAt),
+          ...timeoutMs === undefined ? {} : { timeoutMs }
+        }, error);
+      }
+      throw error;
+    }
     if (status.evidence.kind === "draining" && status.evidence.message?.status === "worker-draining") {
       return status.evidence.message;
     }
@@ -233468,27 +233557,42 @@ class SupervisedConfigWorkerProcessAdapter {
       throw new Error("supervised worker control message is unsupported");
     if (message.command === "drain-worker")
       this.drainCommand = message;
+    const startedAt = performance.now();
     let deadline;
-    if (message.command === "drain-worker") {
-      if (message.start_boot_id !== this.kernelBootId)
-        throw new Error("worker start deadline boot identity is unknown or mismatched");
-      const remaining = BigInt(message.start_deadline_ns) - process.hrtime.bigint();
-      if (remaining <= 0n)
-        throw new Error("worker drain start deadline expired before control dispatch");
-      deadline = performance.now() + Number((remaining + 999999n) / 1000000n);
-    }
-    const client = await this.readyClient();
-    if (deadline !== undefined && performance.now() >= deadline) {
-      this.followDrain(client, message);
-      throw new Error("worker drain start deadline expired before control dispatch");
-    }
     try {
-      const status = message.command === "drain-worker" ? await client.drain(message, deadline) : await client.start(message);
-      this.lastStatus = status;
-      this.publish(status.evidence.message);
-    } finally {
-      if (message.command === "drain-worker")
+      if (message.command === "drain-worker") {
+        if (message.start_boot_id !== this.kernelBootId)
+          throw new Error("worker start deadline boot identity is unknown or mismatched");
+        const remaining = BigInt(message.start_deadline_ns) - process.hrtime.bigint();
+        deadline = performance.now() + Number((remaining + 999999n) / 1000000n);
+        if (remaining <= 0n)
+          throw new Error("worker drain start deadline expired before control dispatch");
+      }
+      const client = await this.readyClient();
+      if (deadline !== undefined && performance.now() >= deadline) {
         this.followDrain(client, message);
+        throw new Error("worker drain start deadline expired before control dispatch");
+      }
+      try {
+        const status = message.command === "drain-worker" ? await client.drain(message, deadline) : await client.start(message);
+        this.lastStatus = status;
+        this.publish(status.evidence.message);
+      } finally {
+        if (message.command === "drain-worker")
+          this.followDrain(client, message);
+      }
+    } catch (error) {
+      if (message.command === "drain-worker") {
+        recordShutdownFailure("worker_drain_command", {
+          pid: this.pid,
+          origin: this.origin,
+          elapsedMs: shutdownElapsedMs(startedAt),
+          timeoutMs: message.policy.drain_start_timeout_ms,
+          deadlineExceeded: deadline !== undefined && performance.now() >= deadline,
+          commandOutcome: "failed"
+        }, error);
+      }
+      throw error;
     }
   }
   followDrain(client, command) {
@@ -235409,7 +235513,7 @@ var init_management_listener = __esm(() => {
 });
 
 // src/ingress/master-controller.ts
-import { randomUUID as randomUUID21 } from "crypto";
+import { randomUUID as randomUUID22 } from "crypto";
 import { spawn as spawnChild2 } from "child_process";
 function immutableRegistry(registry) {
   const immutableAdmission = (set) => set === null ? null : Object.freeze({
@@ -235493,7 +235597,7 @@ class MasterIngressController {
     requirePositive(this.startupTimeoutMs, "startupTimeoutMs");
     requirePositive(this.leaseDurationMs, "leaseDurationMs");
     this.authority = { controller_epoch: options.controllerEpoch, controller_id: options.controllerId };
-    this.childCredential = deriveSupervisionProcessKey(options.rootKey, options.instanceId, "ingress", randomUUID21(), randomUUID21());
+    this.childCredential = deriveSupervisionProcessKey(options.rootKey, options.instanceId, "ingress", randomUUID22(), randomUUID22());
     this.fetch = options.fetch ?? fetch;
     this.identityControl = options.processIdentity ?? DEFAULT_INGRESS_PROCESS_IDENTITY;
     this.probeSleep = options.probeSleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
@@ -235988,8 +236092,6 @@ class MasterIngressController {
       evidence.lastProbe = probe;
       if (probe === "dead" || probe === "mismatch")
         return probe;
-      if (probe === "unknown")
-        return "unverified";
       const remaining = deadline - this.now();
       if (remaining <= 0)
         break;
@@ -236050,7 +236152,7 @@ class MasterIngressController {
     const lifecycle = this.lifecycleGeneration;
     if (!this.isRecoveryEligible(lifecycle))
       return null;
-    this.childCredential = deriveSupervisionProcessKey(this.options.rootKey, this.options.instanceId, "ingress", randomUUID21(), randomUUID21());
+    this.childCredential = deriveSupervisionProcessKey(this.options.rootKey, this.options.instanceId, "ingress", randomUUID22(), randomUUID22());
     const childEnvironment = { ...this.options.environment ?? process.env };
     for (const name of [
       "BUNGEE_PLUGIN_SECRETS_KEY",
@@ -236080,9 +236182,9 @@ class MasterIngressController {
       throw this.mapDiscoveryFailure(cause);
     }
     this.assertRecoveryEligible(lifecycle);
-    const challenge = await client.challenge(this.authority, randomUUID21(), 1, signal);
+    const challenge = await client.challenge(this.authority, randomUUID22(), 1, signal);
     this.assertRecoveryEligible(lifecycle);
-    await client.attach(challenge, this.authority, this.nextSequence(signal), randomUUID21(), signal);
+    await client.attach(challenge, this.authority, this.nextSequence(signal), randomUUID22(), signal);
     this.assertRecoveryEligible(lifecycle);
     const attachedStatus = await client.status(this.authority, this.nextSequence(signal), signal);
     this.assertRecoveryEligible(lifecycle);
@@ -236393,10 +236495,10 @@ class MasterIngressController {
     await client.identity(signal);
     if (!this.isRecoveryEligible(lifecycle))
       return null;
-    const challenge = await client.challenge(this.authority, randomUUID21(), 1, signal);
+    const challenge = await client.challenge(this.authority, randomUUID22(), 1, signal);
     if (!this.isRecoveryEligible(lifecycle))
       return null;
-    await client.attach(challenge, this.authority, this.nextSequence(signal), randomUUID21(), signal);
+    await client.attach(challenge, this.authority, this.nextSequence(signal), randomUUID22(), signal);
     if (!this.isRecoveryEligible(lifecycle))
       return null;
     const attachedStatus = await client.status(this.authority, this.nextSequence(signal), signal);
@@ -237103,7 +237205,7 @@ var init_master_controller = __esm(() => {
 });
 
 // src/master.ts
-import { randomUUID as randomUUID22 } from "crypto";
+import { randomUUID as randomUUID23 } from "crypto";
 import { resolve as resolve17 } from "path";
 function environment() {
   return Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined));
@@ -237187,7 +237289,7 @@ var init_master = __esm(async () => {
     deriveTransportSecret: deriveWorkerTransportSecret,
     resolveWorkerLaunch,
     createWorkerFactory: (options) => new SupervisedConfigWorkerFactory(options),
-    createMasterGeneration: randomUUID22,
+    createMasterGeneration: randomUUID23,
     createCoordinator: (options) => new MasterConfigPublicationCoordinator(options),
     createManagementListener,
     createControllerClaim: mintControllerClaimCapability,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jeffusion/bungee-core",
-  "version": "5.6.0",
+  "version": "5.6.2",
   "description": "Bungee reverse proxy core engine",
   "main": "./dist/main.js",
   "types": "./dist/main.d.ts",
@@ -12,7 +12,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@jeffusion/bungee-types": "^5.6.0",
+    "@jeffusion/bungee-types": "^5.6.2",
     "@types/lodash-es": "^4.17.12",
     "acorn": "^8.15.0",
     "canonicalize": "3.0.0",