@fulmenhq/tsfulmen 0.3.3 → 0.4.1

package/dist/chunk-QGTNV4U2.js

@@ -0,0 +1,985 @@
+import { getSignal, supportsSignal, isWindows, isPOSIX } from './chunk-24BAF63H.js';
+import { buildRuntimeInfo } from './chunk-HY6JQOFN.js';
+import { FoundryCatalogError } from './chunk-3HISR2XI.js';
+
+// src/foundry/signals/config-reload-endpoint.ts
+function createConfigReloadEndpoint(options) {
+  const { loader, validator, onReload: onReload2, auth, rateLimit, logger, telemetry } = options;
+  return async (payload, req) => {
+    const correlationId = payload.correlation_id ?? generateCorrelationId();
+    const authResult = await auth(req);
+    if (!authResult.authenticated) {
+      if (logger) {
+        logger.warn("Config reload endpoint: authentication failed", {
+          correlation_id: correlationId,
+          reason: authResult.reason
+        });
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.config.http_endpoint.auth_failed", {
+          correlation_id: correlationId
+        });
+      }
+      return {
+        status: "error",
+        error: "authentication_failed",
+        message: authResult.reason || "Authentication required",
+        statusCode: 401
+      };
+    }
+    const identity = authResult.identity || "unknown";
+    if (rateLimit) {
+      const rateLimitResult = await rateLimit(identity);
+      if (!rateLimitResult.allowed) {
+        if (logger) {
+          logger.warn("Config reload endpoint: rate limit exceeded", {
+            correlation_id: correlationId,
+            identity
+          });
+        }
+        if (telemetry) {
+          telemetry.emit("fulmen.config.http_endpoint.rate_limited", {
+            correlation_id: correlationId
+          });
+        }
+        return {
+          status: "error",
+          error: "rate_limit_exceeded",
+          message: "Rate limit exceeded. Please try again later.",
+          statusCode: 429
+        };
+      }
+    }
+    if (telemetry) {
+      telemetry.emit("fulmen.config.http_endpoint.reload_requested", {
+        correlation_id: correlationId
+      });
+    }
+    try {
+      const config = await loader();
+      if (validator) {
+        const validation = await validator(config);
+        if (!validation.valid) {
+          if (logger) {
+            logger.warn("Config reload endpoint: validation failed", {
+              correlation_id: correlationId,
+              error_count: validation.errors?.length ?? 0
+            });
+          }
+          if (telemetry) {
+            telemetry.emit("fulmen.config.http_endpoint.reload_rejected", {
+              correlation_id: correlationId,
+              reason: "validation_failed"
+            });
+          }
+          return {
+            status: "error",
+            error: "validation_failed",
+            message: "Configuration validation failed",
+            validation_errors: validation.errors,
+            statusCode: 422
+          };
+        }
+      }
+      if (onReload2) {
+        await onReload2(config);
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.config.http_endpoint.reload_accepted", {
+          correlation_id: correlationId
+        });
+      }
+      if (logger) {
+        logger.info("Config reload endpoint: reload accepted", {
+          correlation_id: correlationId,
+          reason: payload.reason
+        });
+      }
+      return {
+        status: "reloaded",
+        correlation_id: correlationId,
+        message: "Configuration reloaded",
+        statusCode: 200
+      };
+    } catch (error) {
+      if (logger) {
+        logger.warn("Config reload endpoint: reload failed", {
+          correlation_id: correlationId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.config.http_endpoint.reload_error", {
+          correlation_id: correlationId,
+          error_type: error instanceof Error ? error.constructor.name : "unknown"
+        });
+      }
+      return {
+        status: "error",
+        error: "reload_failed",
+        message: error instanceof Error ? error.message : String(error),
+        statusCode: 500
+      };
+    }
+  };
+}
+function generateCorrelationId() {
+  return `cfg-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+
+// src/foundry/signals/control-discovery-endpoint.ts
+function createControlDiscoveryEndpoint(options) {
+  const { identity, version, endpoints, auth, authSummary, logger, telemetry } = options;
+  return async (req) => {
+    if (auth) {
+      const authResult = await auth(req);
+      if (!authResult.authenticated) {
+        if (logger) {
+          logger.warn("Control discovery endpoint: authentication failed", {
+            reason: authResult.reason
+          });
+        }
+        if (telemetry) {
+          telemetry.emit("fulmen.control.discovery.auth_failed", {
+            service: identity.app.binary_name
+          });
+        }
+        return {
+          status: "error",
+          error: "authentication_failed",
+          message: authResult.reason || "Authentication required",
+          statusCode: 401
+        };
+      }
+    }
+    if (telemetry) {
+      telemetry.emit("fulmen.control.discovery.served", {
+        service: identity.app.binary_name
+      });
+    }
+    const runtime = buildRuntimeInfo({ identity, version });
+    return {
+      status: "ok",
+      service: {
+        name: identity.app.binary_name,
+        vendor: identity.app.vendor,
+        version
+      },
+      runtime: {
+        name: runtime.runtime.name,
+        version: runtime.runtime.version,
+        platform: runtime.platform.os,
+        arch: runtime.platform.arch
+      },
+      auth_summary: authSummary,
+      endpoints,
+      statusCode: 200
+    };
+  };
+}
+
+// src/foundry/signals/convenience.ts
+async function onShutdown(manager, handler, options = {}) {
+  await manager.register("SIGTERM", handler, options);
+  await manager.register("SIGINT", handler, options);
+}
+async function onReload(manager, handler, options = {}) {
+  await manager.register("SIGHUP", handler, options);
+}
+async function onUSR1(manager, handler, options = {}) {
+  await manager.register("SIGUSR1", handler, options);
+}
+async function onUSR2(manager, handler, options = {}) {
+  await manager.register("SIGUSR2", handler, options);
+}
+async function onEmergencyQuit(manager, handler, options = {}) {
+  await manager.register("SIGQUIT", handler, options);
+}
+async function onAnyShutdown(manager, handler, options = {}) {
+  await manager.register("SIGTERM", handler, options);
+  await manager.register("SIGINT", handler, options);
+  await manager.register("SIGQUIT", handler, options);
+}
+
+// src/foundry/signals/double-tap.ts
+async function createDoubleTapTracker(signalName, config = {}) {
+  const signal = await getSignal(signalName);
+  const defaultWindowMs = signal?.double_tap_window_seconds ? signal.double_tap_window_seconds * 1e3 : 2e3;
+  const defaultExitCode = signal?.double_tap_exit_code || 130;
+  const defaultHintMessage = signal?.double_tap_message || "Press Ctrl+C again within 2s to force quit";
+  return {
+    firstTapTime: null,
+    windowMs: config.windowMs ?? defaultWindowMs,
+    exitCode: config.exitCode ?? defaultExitCode,
+    hintMessage: config.hintMessage ?? defaultHintMessage,
+    logger: config.logger,
+    testMode: config.testMode ?? false
+  };
+}
+function handleDoubleTap(state) {
+  const now = Date.now();
+  if (state.firstTapTime === null) {
+    state.firstTapTime = now;
+    if (state.logger) {
+      state.logger.info(state.hintMessage);
+    } else {
+      console.log(state.hintMessage);
+    }
+    return false;
+  }
+  const elapsed = now - state.firstTapTime;
+  if (elapsed < state.windowMs) {
+    if (state.logger) {
+      state.logger.info("Force quitting...");
+    } else {
+      console.log("Force quitting...");
+    }
+    if (!state.testMode) {
+      process.exit(state.exitCode);
+    }
+    return true;
+  }
+  state.firstTapTime = now;
+  if (state.logger) {
+    state.logger.info(state.hintMessage);
+  } else {
+    console.log(state.hintMessage);
+  }
+  return false;
+}
+function resetDoubleTap(state) {
+  state.firstTapTime = null;
+}
+function isWithinWindow(state) {
+  if (state.firstTapTime === null) {
+    return false;
+  }
+  const elapsed = Date.now() - state.firstTapTime;
+  return elapsed < state.windowMs;
+}
+function getWindowTimeRemaining(state) {
+  if (state.firstTapTime === null) {
+    return null;
+  }
+  const elapsed = Date.now() - state.firstTapTime;
+  const remaining = state.windowMs - elapsed;
+  return remaining > 0 ? remaining : null;
+}
+
+// src/foundry/signals/windows.ts
+var defaultLogger = {
+  info(message, meta) {
+    if (meta) {
+      console.info(message, meta);
+    } else {
+      console.info(message);
+    }
+  },
+  warn(message, meta) {
+    if (meta) {
+      console.warn(message, meta);
+    } else {
+      console.warn(message);
+    }
+  }
+};
+async function handleWindowsFallback(signalName, options = {}) {
+  const signal = await getSignal(signalName);
+  if (!signal) {
+    return {
+      supported: false,
+      logged: false
+    };
+  }
+  if (signal.windows_event !== null) {
+    return {
+      supported: true,
+      logged: false
+    };
+  }
+  const fallback = signal.windows_fallback;
+  if (!fallback) {
+    return {
+      supported: false,
+      logged: false
+    };
+  }
+  if (options.silent) {
+    return {
+      supported: false,
+      fallback,
+      logged: false
+    };
+  }
+  const logger = options.logger || defaultLogger;
+  const telemetry = options.telemetry;
+  const logMeta = {
+    signal: signal.name,
+    platform: "windows",
+    fallback: fallback.fallback_behavior,
+    operation_hint: fallback.operation_hint
+  };
+  logger.info(fallback.log_message, logMeta);
+  if (telemetry) {
+    telemetry.emit(fallback.telemetry_event, fallback.telemetry_tags);
+  }
+  return {
+    supported: false,
+    fallback,
+    logged: true
+  };
+}
+async function getFallbackMetadata(signalName) {
+  const signal = await getSignal(signalName);
+  if (!signal || !signal.windows_fallback) {
+    return null;
+  }
+  return signal.windows_fallback;
+}
+async function requiresFallback(signalName) {
+  const signal = await getSignal(signalName);
+  if (!signal) {
+    return false;
+  }
+  return signal.windows_event === null && signal.windows_fallback !== void 0;
+}
+async function getHttpFallbackGuidance(signalName) {
+  const fallback = await getFallbackMetadata(signalName);
+  if (!fallback || fallback.fallback_behavior !== "http_admin_endpoint") {
+    return null;
+  }
+  return fallback.operation_hint;
+}
+
+// src/foundry/signals/guards.ts
+async function ensureSupported(signalName, options = {}) {
+  const { includeGuidance = true } = options;
+  const signal = await getSignal(signalName);
+  if (!signal) {
+    throw FoundryCatalogError.invalidSchema(
+      "signals",
+      `Signal "${signalName}" not found in catalog. Valid signals: SIGTERM, SIGINT, SIGHUP, SIGQUIT, SIGPIPE, SIGALRM, SIGUSR1, SIGUSR2`
+    );
+  }
+  const supported = await supportsSignal(signalName);
+  if (supported) {
+    return;
+  }
+  let message = `Signal ${signal.name} is not supported on this platform`;
+  if (isWindows() && includeGuidance) {
+    const fallback = await getFallbackMetadata(signalName);
+    if (fallback) {
+      message += `. ${fallback.log_message}`;
+      switch (fallback.fallback_behavior) {
+        case "http_admin_endpoint":
+          message += `. Use HTTP endpoint: ${fallback.operation_hint}`;
+          break;
+        case "exception_handling":
+          message += `. Alternative: ${fallback.operation_hint}`;
+          break;
+        case "timer_api":
+          message += `. Alternative: ${fallback.operation_hint}`;
+          break;
+      }
+    }
+  }
+  throw FoundryCatalogError.invalidSchema("signals", message);
+}
+function ensureSignalExitCodesSupported() {
+  if (!isPOSIX()) {
+    throw FoundryCatalogError.invalidSchema(
+      "signals",
+      "Signal-based exit codes (128+N pattern) are not supported on this platform. Windows does not propagate signal numbers via exit codes. Use explicit exit codes or monitor via HTTP admin endpoint."
+    );
+  }
+}
+function ensurePOSIX() {
+  if (!isPOSIX()) {
+    throw FoundryCatalogError.invalidSchema(
+      "signals",
+      "This operation requires a POSIX-compliant platform (Linux, macOS, FreeBSD). Current platform does not support native signal handling."
+    );
+  }
+}
+function ensureWindows() {
+  if (!isWindows()) {
+    throw FoundryCatalogError.invalidSchema(
+      "signals",
+      "This operation requires Windows platform. Current platform uses native signals."
+    );
+  }
+}
+
+// src/foundry/signals/http-helper.ts
+function createSignalEndpoint(options) {
+  const { manager, auth, rateLimit, logger, telemetry, allowedSignals } = options;
+  return async (payload, req) => {
+    const correlationId = payload.correlation_id ?? generateCorrelationId2();
+    const authResult = await auth(req);
+    if (!authResult.authenticated) {
+      if (logger) {
+        logger.warn("Signal endpoint: authentication failed", {
+          correlation_id: correlationId,
+          reason: authResult.reason
+        });
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.signal.http_endpoint.auth_failed", {
+          correlation_id: correlationId
+        });
+      }
+      return {
+        status: "error",
+        error: "authentication_failed",
+        message: authResult.reason || "Authentication required",
+        statusCode: 401
+      };
+    }
+    const identity = authResult.identity || "unknown";
+    if (!payload.signal) {
+      return {
+        status: "error",
+        error: "invalid_request",
+        message: "Signal name is required",
+        statusCode: 400
+      };
+    }
+    const signalName = normalizeSignalName(payload.signal);
+    const defaultAllowed = [
+      "SIGHUP",
+      "SIGTERM",
+      "SIGINT",
+      "SIGQUIT",
+      "SIGUSR1",
+      "SIGUSR2",
+      "SIGPIPE",
+      "SIGALRM"
+    ];
+    const allowed = (allowedSignals || defaultAllowed).map((s) => normalizeSignalName(s));
+    if (!allowed.includes(signalName)) {
+      return {
+        status: "error",
+        error: "invalid_signal",
+        message: `Signal '${payload.signal}' is not recognized. Valid signals: ${allowed.join(", ")}`,
+        valid_signals: allowed,
+        statusCode: 400
+      };
+    }
+    const supported = await supportsSignal(signalName);
+    if (!supported) {
+      return {
+        status: "error",
+        error: "signal_not_supported",
+        message: `Signal ${signalName} is not supported on this platform`,
+        statusCode: 400
+      };
+    }
+    if (rateLimit) {
+      const rateLimitResult = await rateLimit(identity, signalName);
+      if (!rateLimitResult.allowed) {
+        if (logger) {
+          logger.warn("Signal endpoint: rate limit exceeded", {
+            correlation_id: correlationId,
+            identity,
+            signal: signalName
+          });
+        }
+        if (telemetry) {
+          telemetry.emit("fulmen.signal.http_endpoint.rate_limited", {
+            correlation_id: correlationId,
+            signal: signalName
+          });
+        }
+        return {
+          status: "error",
+          error: "rate_limit_exceeded",
+          message: "Rate limit exceeded. Please try again later.",
+          statusCode: 429
+        };
+      }
+    }
+    if (logger) {
+      logger.info("Signal endpoint: signal received", {
+        correlation_id: correlationId,
+        identity,
+        signal: signalName,
+        reason: payload.reason
+      });
+    }
+    if (telemetry) {
+      telemetry.emit("fulmen.signal.http_endpoint.signal_received", {
+        correlation_id: correlationId,
+        signal: signalName
+      });
+    }
+    void manager.trigger(signalName).catch((error) => {
+      if (logger) {
+        logger.warn("Signal handler execution failed", {
+          correlation_id: correlationId,
+          signal: signalName,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+    return {
+      status: "accepted",
+      signal: signalName,
+      correlation_id: correlationId,
+      message: "Signal will be processed asynchronously",
+      statusCode: 202
+    };
+  };
+}
+function normalizeSignalName(signal) {
+  const upper = signal.toUpperCase();
+  if (upper.startsWith("SIG")) {
+    return upper;
+  }
+  return `SIG${upper}`;
+}
+function generateCorrelationId2() {
+  return `sig-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+function createBearerTokenAuth(expectedToken) {
+  return (req) => {
+    const headers = req.headers;
+    const authHeader = headers?.authorization || headers?.Authorization;
+    if (!authHeader) {
+      return {
+        authenticated: false,
+        reason: "Missing Authorization header"
+      };
+    }
+    const [scheme, token] = authHeader.split(" ");
+    if (scheme !== "Bearer" || token !== expectedToken) {
+      return {
+        authenticated: false,
+        reason: "Invalid bearer token"
+      };
+    }
+    return {
+      authenticated: true,
+      identity: "bearer-token-user"
+    };
+  };
+}
+function createSimpleRateLimiter(requestsPerMinute) {
+  const requests = /* @__PURE__ */ new Map();
+  const windowMs = 6e4;
+  return (identity) => {
+    const now = Date.now();
+    const key = identity;
+    let timestamps = requests.get(key) || [];
+    timestamps = timestamps.filter((ts) => now - ts < windowMs);
+    if (timestamps.length >= requestsPerMinute) {
+      const oldestTimestamp = Math.min(...timestamps);
+      const resetAt = oldestTimestamp + windowMs;
+      return {
+        allowed: false,
+        remaining: 0,
+        reset_at: resetAt
+      };
+    }
+    timestamps.push(now);
+    requests.set(key, timestamps);
+    return {
+      allowed: true,
+      remaining: requestsPerMinute - timestamps.length,
+      reset_at: now + windowMs
+    };
+  };
+}
+
+// src/foundry/signals/manager.ts
+var SignalManager = class {
+  handlers = /* @__PURE__ */ new Map();
+  nativeListeners = /* @__PURE__ */ new Map();
+  options;
+  handlerIdCounter = 0;
+  doubleTapTrackers = /* @__PURE__ */ new Map();
+  shuttingDown = false;
+  constructor(options = {}) {
+    this.options = {
+      defaultTimeoutMs: options.defaultTimeoutMs ?? 3e4,
+      timeoutBehavior: options.timeoutBehavior ?? "log_and_continue",
+      testMode: options.testMode ?? false,
+      doubleTapWindowMs: options.doubleTapWindowMs ?? 2e3,
+      doubleTapExitCode: options.doubleTapExitCode ?? 130,
+      logger: options.logger,
+      telemetry: options.telemetry
+    };
+  }
+  /**
+   * Register a signal handler
+   *
+   * @param signal - Signal name (e.g., "SIGTERM") or NodeJS.Signals
+   * @param handler - Handler function
+   * @param options - Handler options
+   */
+  async register(signal, handler, options = {}) {
+    const signalName = typeof signal === "string" ? signal : signal;
+    const supported = await supportsSignal(signalName);
+    if (!supported) {
+      if (isWindows()) {
+        await handleWindowsFallback(signalName, {
+          logger: this.options.logger,
+          telemetry: this.options.telemetry
+        });
+      }
+      return;
+    }
+    if (!this.handlers.has(signalName)) {
+      this.handlers.set(signalName, []);
+    }
+    const registration = {
+      signal: signalName,
+      handler,
+      priority: options.priority ?? 0,
+      timeoutMs: options.timeoutMs ?? this.options.defaultTimeoutMs,
+      id: options.id ?? `handler-${++this.handlerIdCounter}`,
+      registeredAt: Date.now()
+    };
+    const handlers = this.handlers.get(signalName);
+    if (!handlers) {
+      throw new Error(`Handler list not initialized for signal ${signalName}`);
+    }
+    handlers.push(registration);
+    handlers.sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+      return a.registeredAt - b.registeredAt;
+    });
+    if (!this.nativeListeners.has(signalName)) {
+      await this.registerNativeListener(signalName);
+    }
+    if (this.options.logger) {
+      this.options.logger.info(`Signal handler registered: ${signalName}`, {
+        handler_id: registration.id,
+        priority: registration.priority,
+        timeout_ms: registration.timeoutMs
+      });
+    }
+    if (this.options.telemetry) {
+      this.options.telemetry.emit("fulmen.signal.handler_registered", {
+        signal: signalName,
+        handler_id: registration.id,
+        priority: String(registration.priority)
+      });
+    }
+  }
+  /**
+   * Register native Node.js signal listener
+   */
+  async registerNativeListener(signalName) {
+    const signal = await getSignal(signalName);
+    if (!signal) {
+      return;
+    }
+    const useDoubleTap = signal.default_behavior === "graceful_shutdown_with_double_tap";
+    if (useDoubleTap) {
+      const tracker = await createDoubleTapTracker(signalName, {
+        windowMs: this.options.doubleTapWindowMs,
+        exitCode: this.options.doubleTapExitCode,
+        logger: this.options.logger,
+        testMode: this.options.testMode
+      });
+      this.doubleTapTrackers.set(signalName, tracker);
+    }
+    const listener = async (sig) => {
+      if (useDoubleTap) {
+        const tracker = this.doubleTapTrackers.get(signalName);
+        if (tracker) {
+          const forceQuit = handleDoubleTap(tracker);
+          if (forceQuit) {
+            return;
+          }
+        }
+      }
+      await this.executeHandlers(signalName, sig);
+    };
+    process.on(signalName, listener);
+    this.nativeListeners.set(signalName, listener);
+  }
+  /**
+   * Execute all registered handlers for a signal
+   */
+  async executeHandlers(signalName, signal) {
+    const handlers = this.handlers.get(signalName);
+    if (!handlers || handlers.length === 0) {
+      return;
+    }
+    this.shuttingDown = true;
+    if (this.options.logger) {
+      this.options.logger.info(`Signal received: ${signalName}`, {
+        handler_count: handlers.length
+      });
+    }
+    for (const registration of handlers) {
+      try {
+        await this.executeWithTimeout(registration, signal);
+      } catch (error) {
+        if (this.options.logger) {
+          this.options.logger.warn(`Signal handler failed: ${signalName}`, {
+            handler_id: registration.id,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+        if (this.options.telemetry) {
+          this.options.telemetry.emit("fulmen.signal.handler_error", {
+            signal: signalName,
+            handler_id: registration.id,
+            error_type: error instanceof Error ? error.constructor.name : "unknown"
+          });
+        }
+        if (this.options.timeoutBehavior === "force_exit") {
+          const exitCode = (await getSignal(signalName))?.exit_code ?? 1;
+          if (!this.options.testMode) {
+            process.exit(exitCode);
+          }
+          return;
+        }
+      }
+    }
+    const tracker = this.doubleTapTrackers.get(signalName);
+    if (tracker) {
+      resetDoubleTap(tracker);
+    }
+  }
+  /**
+   * Execute a handler with timeout enforcement
+   */
+  async executeWithTimeout(registration, signal) {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Handler timeout exceeded: ${registration.timeoutMs}ms`));
+      }, registration.timeoutMs);
+    });
+    const handlerPromise = Promise.resolve(registration.handler(signal));
+    try {
+      await Promise.race([handlerPromise, timeoutPromise]);
+      if (this.options.telemetry) {
+        this.options.telemetry.emit("fulmen.signal.handler_completed", {
+          signal: registration.signal,
+          handler_id: registration.id
+        });
+      }
+    } catch (error) {
+      if (this.options.telemetry) {
+        this.options.telemetry.emit("fulmen.signal.handler_timeout", {
+          signal: registration.signal,
+          handler_id: registration.id,
+          timeout_ms: String(registration.timeoutMs)
+        });
+      }
+      throw error;
+    }
+  }
+  /**
+   * Unregister a signal handler
+   *
+   * @param signal - Signal name
+   * @param handler - Handler to remove (if not provided, removes all handlers)
+   */
+  unregister(signal, handler) {
+    const handlers = this.handlers.get(signal);
+    if (!handlers) {
+      return;
+    }
+    if (handler) {
+      const index = handlers.findIndex((h) => h.handler === handler);
+      if (index !== -1) {
+        handlers.splice(index, 1);
+      }
+    } else {
+      handlers.length = 0;
+    }
+    if (handlers.length === 0) {
+      const listener = this.nativeListeners.get(signal);
+      if (listener) {
+        process.off(signal, listener);
+        this.nativeListeners.delete(signal);
+      }
+      this.handlers.delete(signal);
+    }
+  }
+  /**
+   * Check if a signal has registered handlers
+   */
+  isRegistered(signal) {
+    const handlers = this.handlers.get(signal);
+    return handlers !== void 0 && handlers.length > 0;
+  }
+  /**
+   * Get handler count for a signal
+   */
+  getHandlerCount(signal) {
+    const handlers = this.handlers.get(signal);
+    return handlers?.length ?? 0;
+  }
+  /**
+   * Trigger signal handlers manually (for testing)
+   *
+   * @param signal - Signal name
+   */
+  async trigger(signal) {
+    const handlers = this.handlers.get(signal);
+    if (!handlers || handlers.length === 0) {
+      return;
+    }
+    await this.executeHandlers(signal, signal);
+  }
+  /**
+   * Shutdown the signal manager and cleanup all handlers
+   */
+  async shutdown() {
+    for (const [signal, listener] of this.nativeListeners.entries()) {
+      process.off(signal, listener);
+    }
+    this.nativeListeners.clear();
+    this.handlers.clear();
+    this.doubleTapTrackers.clear();
+    this.shuttingDown = false;
+  }
+  /**
+   * Check if manager is currently shutting down
+   */
+  isShuttingDown() {
+    return this.shuttingDown;
+  }
+};
+function createSignalManager(options = {}) {
+  return new SignalManager(options);
+}
+
+// src/foundry/signals/reload.ts
+function createConfigReloadHandler(options) {
+  const {
+    loader,
+    validator,
+    onValidated,
+    exitCode = 129,
+    logger,
+    telemetry,
+    testMode = false
+  } = options;
+  return async () => {
+    if (logger) {
+      logger.info("Config reload requested (SIGHUP)");
+    }
+    if (telemetry) {
+      telemetry.emit("fulmen.signal.config_reload_requested", {
+        signal: "SIGHUP"
+      });
+    }
+    try {
+      const newConfig = await loader();
+      const result = await validator(newConfig);
+      if (!result.valid) {
+        if (logger) {
+          logger.warn("Config validation failed - continuing with current config", {
+            error_count: result.errors?.length ?? 0,
+            errors: result.errors
+          });
+        }
+        if (telemetry) {
+          telemetry.emit("fulmen.signal.config_reload_rejected", {
+            signal: "SIGHUP",
+            reason: "validation_failed",
+            error_count: String(result.errors?.length ?? 0)
+          });
+        }
+        return;
+      }
+      if (logger) {
+        logger.info("Config validation succeeded - exiting for restart");
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.signal.config_reload_accepted", {
+          signal: "SIGHUP"
+        });
+      }
+      if (onValidated) {
+        await onValidated(newConfig);
+      }
+      if (!testMode) {
+        process.exit(exitCode);
+      }
+    } catch (error) {
+      if (logger) {
+        logger.warn("Config reload failed with error - continuing with current config", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      if (telemetry) {
+        telemetry.emit("fulmen.signal.config_reload_error", {
+          signal: "SIGHUP",
+          error_type: error instanceof Error ? error.constructor.name : "unknown"
+        });
+      }
+    }
+  };
+}
+var ConfigReloadTracker = class {
+  failures = 0;
+  lastFailureTime = null;
+  maxFailures;
+  logger;
+  telemetry;
+  constructor(options) {
+    this.maxFailures = options.maxFailures ?? 3;
+    this.logger = options.logger;
+    this.telemetry = options.telemetry;
+  }
+  /**
+   * Record a reload failure
+   *
+   * @returns true if threshold exceeded, false otherwise
+   */
+  recordFailure() {
+    this.failures++;
+    this.lastFailureTime = Date.now();
+    if (this.failures >= this.maxFailures) {
+      if (this.logger) {
+        this.logger.warn(
+          `${this.failures} consecutive config reload failures - check config source`,
+          {
+            failure_count: this.failures,
+            threshold: this.maxFailures
+          }
+        );
+      }
+      if (this.telemetry) {
+        this.telemetry.emit("fulmen.signal.config_reload_threshold_exceeded", {
+          failure_count: String(this.failures),
+          threshold: String(this.maxFailures)
+        });
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Record a successful reload (resets counter)
+   */
+  recordSuccess() {
+    this.failures = 0;
+    this.lastFailureTime = null;
+  }
+  /**
+   * Get current failure count
+   */
+  getFailureCount() {
+    return this.failures;
+  }
+  /**
+   * Get last failure timestamp
+   */
+  getLastFailureTime() {
+    return this.lastFailureTime;
+  }
+};
+
+export { ConfigReloadTracker, SignalManager, createBearerTokenAuth, createConfigReloadEndpoint, createConfigReloadHandler, createControlDiscoveryEndpoint, createDoubleTapTracker, createSignalEndpoint, createSignalManager, createSimpleRateLimiter, ensurePOSIX, ensureSignalExitCodesSupported, ensureSupported, ensureWindows, getFallbackMetadata, getHttpFallbackGuidance, getWindowTimeRemaining, handleDoubleTap, handleWindowsFallback, isWithinWindow, onAnyShutdown, onEmergencyQuit, onReload, onShutdown, onUSR1, onUSR2, requiresFallback, resetDoubleTap };
+//# sourceMappingURL=chunk-QGTNV4U2.js.map
+//# sourceMappingURL=chunk-QGTNV4U2.js.map