pidnap 0.0.0-dev.4 → 0.0.0-dev.5

package/dist/index.d.mts

@@ -1,8 +1,229 @@
-import { A as ProcessStateSchema, C as RestartingProcessOptionsSchema, D as ProcessDefinition, E as LazyProcess, M as logger, O as ProcessDefinitionSchema, S as RestartingProcessOptions, T as RestartingProcessStateSchema, _ as CrashLoopConfig, a as TaskListState, b as RestartPolicySchema, c as CronProcess, d as CronProcessState, f as CronProcessStateSchema, g as BackoffStrategySchema, h as BackoffStrategy, i as TaskList, j as Logger, k as ProcessState, l as CronProcessOptions, m as RetryConfigSchema, n as NamedProcessDefinitionSchema, o as TaskState, p as RetryConfig, r as TaskEntry, s as TaskStateSchema, t as NamedProcessDefinition, u as CronProcessOptionsSchema, v as CrashLoopConfigSchema, w as RestartingProcessState, x as RestartingProcess, y as RestartPolicy } from "./task-list-CIdbB3wM.mjs";
 import * as v from "valibot";
 
+//#region src/logger.d.ts
+type LoggerConfig = {
+  name: string;
+  stdout?: boolean;
+  logFile?: string;
+  prefix?: string;
+};
+declare const logger: (_config: LoggerConfig) => {
+  info: (...args: any[]) => void;
+  error: (...args: any[]) => void;
+  warn: (...args: any[]) => void;
+  debug: (...args: any[]) => void;
+  child: (suffix: string, overrides?: Partial<Omit<LoggerConfig, "name">>) => /*elided*/any;
+  withPrefix: (prefix: string) => /*elided*/any;
+};
+type Logger = ReturnType<typeof logger>;
+//#endregion
+//#region src/lazy-process.d.ts
+declare const ProcessDefinition: v.ObjectSchema<{
+  readonly command: v.StringSchema<undefined>;
+  readonly args: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+  readonly cwd: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly env: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+}, undefined>;
+type ProcessDefinition = v.InferOutput<typeof ProcessDefinition>;
+declare const ProcessState: v.PicklistSchema<["idle", "starting", "running", "stopping", "stopped", "error"], undefined>;
+type ProcessState = v.InferOutput<typeof ProcessState>;
+declare class LazyProcess {
+  readonly name: string;
+  definition: ProcessDefinition;
+  private logger;
+  private childProcess;
+  private _state;
+  private processExit;
+  exitCode: number | null;
+  constructor(name: string, definition: ProcessDefinition, logger: Logger);
+  get state(): ProcessState;
+  start(): Promise<void>;
+  stop(timeout?: number): Promise<void>;
+  reset(): Promise<void>;
+  updateDefinition(definition: ProcessDefinition): void;
+  waitForExit(): Promise<ProcessState>;
+  private cleanup;
+}
+//#endregion
+//#region src/task-list.d.ts
+declare const TaskStateSchema: v.PicklistSchema<["pending", "running", "completed", "failed", "skipped"], undefined>;
+type TaskState = v.InferOutput<typeof TaskStateSchema>;
+declare const NamedProcessDefinitionSchema: v.ObjectSchema<{
+  readonly name: v.StringSchema<undefined>;
+  readonly process: v.ObjectSchema<{
+    readonly command: v.StringSchema<undefined>;
+    readonly args: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    readonly cwd: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly env: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+  }, undefined>;
+}, undefined>;
+type NamedProcessDefinition = v.InferOutput<typeof NamedProcessDefinitionSchema>;
+interface TaskEntry {
+  id: string;
+  processes: NamedProcessDefinition[];
+  state: TaskState;
+}
+type TaskListState = "idle" | "running" | "stopped";
+declare class TaskList {
+  readonly name: string;
+  private _tasks;
+  private _state;
+  private logger;
+  private logFileResolver?;
+  private taskIdCounter;
+  private runningProcesses;
+  private stopRequested;
+  private runLoopPromise;
+  constructor(name: string, logger: Logger, initialTasks?: (NamedProcessDefinition | NamedProcessDefinition[])[], logFileResolver?: (processName: string) => string | undefined);
+  get state(): TaskListState;
+  get tasks(): ReadonlyArray<TaskEntry>;
+  removeTaskByTarget(target: string | number): TaskEntry;
+  /**
+   * Add a single process or parallel processes as a new task
+   * @returns The unique task ID
+   */
+  addTask(task: NamedProcessDefinition | NamedProcessDefinition[]): string;
+  /**
+   * Begin executing pending tasks
+   */
+  start(): void;
+  /**
+   * Wait until the TaskList becomes idle (all pending tasks completed)
+   */
+  waitUntilIdle(): Promise<void>;
+  /**
+   * Stop execution and mark remaining tasks as skipped
+   */
+  stop(timeout?: number): Promise<void>;
+  private runLoop;
+  private executeTask;
+  private waitForProcess;
+}
+//#endregion
+//#region src/cron-process.d.ts
+declare const RetryConfig: v.ObjectSchema<{
+  readonly maxRetries: v.NumberSchema<undefined>;
+  readonly delayMs: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+type RetryConfig = v.InferOutput<typeof RetryConfig>;
+declare const CronProcessOptions: v.ObjectSchema<{
+  readonly schedule: v.StringSchema<undefined>;
+  readonly retry: v.OptionalSchema<v.ObjectSchema<{
+    readonly maxRetries: v.NumberSchema<undefined>;
+    readonly delayMs: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  readonly runOnStart: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+}, undefined>;
+type CronProcessOptions = v.InferOutput<typeof CronProcessOptions>;
+declare const CronProcessState: v.PicklistSchema<["idle", "scheduled", "running", "retrying", "queued", "stopping", "stopped"], undefined>;
+type CronProcessState = v.InferOutput<typeof CronProcessState>;
+declare class CronProcess {
+  readonly name: string;
+  readonly lazyProcess: LazyProcess;
+  private options;
+  private logger;
+  private cronJob;
+  private _state;
+  private _runCount;
+  private _failCount;
+  private currentRetryAttempt;
+  private queuedRun;
+  private stopRequested;
+  private retryTimeout;
+  constructor(name: string, definition: ProcessDefinition, options: CronProcessOptions, logger: Logger);
+  get state(): CronProcessState;
+  get runCount(): number;
+  get failCount(): number;
+  get nextRun(): Date | null;
+  start(): void;
+  stop(timeout?: number): Promise<void>;
+  trigger(): Promise<void>;
+  private onCronTick;
+  private executeJob;
+  private runJobWithRetry;
+  private handleJobComplete;
+}
+//#endregion
+//#region src/restarting-process.d.ts
+declare const RestartPolicy: v.PicklistSchema<["always", "on-failure", "never", "unless-stopped", "on-success"], undefined>;
+type RestartPolicy = v.InferOutput<typeof RestartPolicy>;
+declare const BackoffStrategy: v.UnionSchema<[v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"fixed", undefined>;
+  readonly delayMs: v.NumberSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"exponential", undefined>;
+  readonly initialDelayMs: v.NumberSchema<undefined>;
+  readonly maxDelayMs: v.NumberSchema<undefined>;
+  readonly multiplier: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>], undefined>;
+type BackoffStrategy = v.InferOutput<typeof BackoffStrategy>;
+declare const CrashLoopConfig: v.ObjectSchema<{
+  readonly maxRestarts: v.NumberSchema<undefined>;
+  readonly windowMs: v.NumberSchema<undefined>;
+  readonly backoffMs: v.NumberSchema<undefined>;
+}, undefined>;
+type CrashLoopConfig = v.InferOutput<typeof CrashLoopConfig>;
+declare const RestartingProcessOptions: v.ObjectSchema<{
+  readonly restartPolicy: v.PicklistSchema<["always", "on-failure", "never", "unless-stopped", "on-success"], undefined>;
+  readonly backoff: v.OptionalSchema<v.UnionSchema<[v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"fixed", undefined>;
+    readonly delayMs: v.NumberSchema<undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"exponential", undefined>;
+    readonly initialDelayMs: v.NumberSchema<undefined>;
+    readonly maxDelayMs: v.NumberSchema<undefined>;
+    readonly multiplier: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+  }, undefined>], undefined>, undefined>;
+  readonly crashLoop: v.OptionalSchema<v.ObjectSchema<{
+    readonly maxRestarts: v.NumberSchema<undefined>;
+    readonly windowMs: v.NumberSchema<undefined>;
+    readonly backoffMs: v.NumberSchema<undefined>;
+  }, undefined>, undefined>;
+  readonly minUptimeMs: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+  readonly maxTotalRestarts: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+type RestartingProcessOptions = v.InferOutput<typeof RestartingProcessOptions>;
+declare const RestartingProcessState: v.PicklistSchema<["idle", "running", "restarting", "stopping", "stopped", "crash-loop-backoff", "max-restarts-reached"], undefined>;
+type RestartingProcessState = v.InferOutput<typeof RestartingProcessState>;
+declare class RestartingProcess {
+  readonly name: string;
+  readonly lazyProcess: LazyProcess;
+  private options;
+  private logger;
+  private _state;
+  private _restartCount;
+  private restartTimestamps;
+  private consecutiveFailures;
+  private lastStartTime;
+  private stopRequested;
+  private pendingDelayTimeout;
+  constructor(name: string, definition: ProcessDefinition, options: RestartingProcessOptions, logger: Logger);
+  get state(): RestartingProcessState;
+  get restarts(): number;
+  start(): void;
+  stop(timeout?: number): Promise<void>;
+  restart(force?: boolean): Promise<void>;
+  /**
+   * Update process definition and optionally restart with new config
+   */
+  reload(newDefinition: ProcessDefinition, restartImmediately?: boolean): Promise<void>;
+  /**
+   * Update restart options
+   */
+  updateOptions(newOptions: Partial<RestartingProcessOptions>): void;
+  private resetCounters;
+  private startProcess;
+  private handleProcessExit;
+  private shouldRestart;
+  private isInCrashLoop;
+  private calculateDelay;
+  private scheduleRestart;
+  private scheduleCrashLoopRecovery;
+  private delay;
+}
+//#endregion
 //#region src/manager.d.ts
-declare const ManagerConfigSchema: v.ObjectSchema<{
+declare const ManagerConfig: v.ObjectSchema<{
   readonly http: v.OptionalSchema<v.ObjectSchema<{
     readonly host: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly port: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
@@ -11,7 +232,7 @@ declare const ManagerConfigSchema: v.ObjectSchema<{
   readonly cwd: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
   readonly logDir: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
   readonly env: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
-  readonly envFiles: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+  readonly envFile: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
   readonly tasks: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
     readonly name: v.StringSchema<undefined>;
     readonly definition: v.ObjectSchema<{
@@ -69,92 +290,66 @@ declare const ManagerConfigSchema: v.ObjectSchema<{
     }, undefined>, undefined>;
     readonly envFile: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly envReloadDelay: v.OptionalSchema<v.UnionSchema<[v.NumberSchema<undefined>, v.BooleanSchema<undefined>, v.LiteralSchema<"immediately", undefined>], undefined>, undefined>;
-    readonly port: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
   }, undefined>, undefined>, undefined>;
 }, undefined>;
-type ManagerConfig = v.InferOutput<typeof ManagerConfigSchema>;
+type ManagerConfig = v.InferOutput<typeof ManagerConfig>;
 //#endregion
 //#region src/env-manager.d.ts
-type EnvChangeCallback = (changedKeys: string[]) => void;
+type EnvChangeEvent = {
+  type: "global";
+} | {
+  type: "process";
+  key: string;
+};
+type EnvChangeCallback = (event: EnvChangeEvent) => void;
 interface EnvManagerConfig {
-  /**
-   * Directory to search for .env files
-   * Defaults to process.cwd()
-   */
-  cwd?: string;
-  /**
-   * Explicit env file paths to load
-   * Key is the identifier (e.g., "global", "app1")
-   * Value is the file path relative to cwd or absolute
-   */
-  files?: Record<string, string>;
-  /**
-   * Enable file watching for env files
-   * Defaults to false
-   */
-  watch?: boolean;
+  cwd: string;
+  globalEnvFile?: string;
+  customEnvFiles?: Record<string, string>;
 }
 declare class EnvManager {
+  private config;
+  private globalEnv;
+  private globalEnvPath;
   private env;
-  private cwd;
-  private watchEnabled;
   private watchers;
-  private fileToKeys;
+  private fileToKey;
   private changeCallbacks;
-  private reloadDebounceTimers;
-  constructor(config?: EnvManagerConfig);
-  registerFile(key: string, filePath: string): void;
-  getEnvForKey(key: string): Record<string, string>;
+  private cwdWatcher;
+  private customKeys;
+  constructor(config: EnvManagerConfig);
   /**
-   * Load .env and .env.* files from the cwd
+   * Register a custom env file for a key.
+   * Once registered, auto-discovered .env.{key} files will be ignored for this key.
    */
-  private loadEnvFilesFromCwd;
+  registerFile(key: string, filePath: string): void;
   /**
-   * Load a single env file and store it in the map
+   * Check if a key has a custom env file registered
    */
-  private loadEnvFile;
+  hasCustomFile(key: string): boolean;
   /**
-   * Watch a file for changes
+   * Load custom env files from config
    */
+  private loadCustomEnvFiles;
+  getEnvVars(key: string): Record<string, string>;
+  private loadEnvFilesFromCwd;
+  private parseEnvFile;
+  private getEnvKeySuffix;
+  private loadGlobalEnv;
+  private loadEnvFile;
   private watchFile;
   /**
-   * Handle file change with debouncing
+   * Watch cwd for new .env.* files
    */
+  private watchCwdForNewFiles;
   private handleFileChange;
-  /**
-   * Reload a file and notify callbacks
-   */
-  private reloadFile;
-  /**
-   * Register a callback to be called when env files change
-   * Returns a function to unregister the callback
-   */
+  private handleFileDelete;
+  private handleNewFile;
+  private notifyCallbacks;
   onChange(callback: EnvChangeCallback): () => void;
-  /**
-   * Stop watching all files and cleanup
-   */
-  dispose(): void;
-  /**
-   * Get environment variables for a specific process
-   * Merges global env with process-specific env
-   * Process-specific env variables override global ones
-   */
-  getEnvVars(processKey?: string): Record<string, string>;
-  /**
-   * Get all loaded env maps (for debugging/inspection)
-   */
-  getAllEnv(): ReadonlyMap<string, Record<string, string>>;
+  close(): void;
 }
 //#endregion
-//#region src/tree-kill.d.ts
-/**
- * Kill a process and all its descendants (children, grandchildren, etc.)
- * @param pid - The process ID to kill
- * @param signal - The signal to send (default: SIGTERM)
- * @returns Promise that resolves when all processes have been signaled
- */
-declare function treeKill(pid: number, signal?: NodeJS.Signals): Promise<void>;
-//#endregion
 //#region src/index.d.ts
 declare function defineConfig(config: ManagerConfig): {
   http?: {
@@ -167,9 +362,7 @@ declare function defineConfig(config: ManagerConfig): {
   env?: {
     [x: string]: string;
   } | undefined;
-  envFiles?: {
-    [x: string]: string;
-  } | undefined;
+  envFile?: string | undefined;
   tasks?: {
     name: string;
     definition: {
@@ -233,9 +426,8 @@ declare function defineConfig(config: ManagerConfig): {
     } | undefined;
     envFile?: string | undefined;
     envReloadDelay?: number | boolean | "immediately" | undefined;
-    port?: number | undefined;
   }[] | undefined;
 };
 //#endregion
-export { BackoffStrategy, BackoffStrategySchema, CrashLoopConfig, CrashLoopConfigSchema, CronProcess, CronProcessOptions, CronProcessOptionsSchema, CronProcessState, CronProcessStateSchema, EnvChangeCallback, EnvManager, EnvManagerConfig, LazyProcess, Logger, NamedProcessDefinition, NamedProcessDefinitionSchema, ProcessDefinition, ProcessDefinitionSchema, ProcessState, ProcessStateSchema, RestartPolicy, RestartPolicySchema, RestartingProcess, RestartingProcessOptions, RestartingProcessOptionsSchema, RestartingProcessState, RestartingProcessStateSchema, RetryConfig, RetryConfigSchema, TaskEntry, TaskList, TaskListState, TaskState, TaskStateSchema, defineConfig, logger, treeKill };
+export { BackoffStrategy, CrashLoopConfig, CronProcess, CronProcessOptions, CronProcessState, EnvChangeCallback, EnvChangeEvent, EnvManager, EnvManagerConfig, LazyProcess, Logger, NamedProcessDefinition, NamedProcessDefinitionSchema, ProcessDefinition, ProcessState, RestartPolicy, RestartingProcess, RestartingProcessOptions, RestartingProcessState, RetryConfig, TaskEntry, TaskList, TaskListState, TaskState, TaskStateSchema, defineConfig, logger };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/manager.ts","../src/env-manager.ts","../src/tree-kill.ts","../src/index.ts"],"mappings":";;;;cAgEa,mBAAA,EAAmB,CAAA,CAAA,YAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAWpB,aAAA,GAAgB,CAAA,CAAE,WAAA,QAAmB,mBAAA;;;KCtErC,iBAAA,IAAqB,WAAA;AAAA,UAEhB,gBAAA;;;ADyDjB;;ECpDE,GAAA;;;;;;EAOA,KAAA,GAAQ,MAAA;;;;;EAMR,KAAA;AAAA;AAAA,cAGW,UAAA;EAAA,QACH,GAAA;EAAA,QACA,GAAA;EAAA,QACA,YAAA;EAAA,QACA,QAAA;EAAA,QACA,UAAA;EAAA,QACA,eAAA;EAAA,QACA,oBAAA;cAEI,MAAA,GAAQ,gBAAA;EAepB,YAAA,CAAa,GAAA,UAAa,QAAA;EAI1B,YAAA,CAAa,GAAA,WAAc,MAAA;;;;UAOnB,mBAAA;;;;UA6BA,WAAA;;;;UA8BA,SAAA;;;;UAiBA,gBAAA;;;;UAmBA,UAAA;;;;;EA6BR,QAAA,CAAS,QAAA,EAAU,iBAAA;;;;EAUnB,OAAA,CAAA;;;;;;EAsBA,UAAA,CAAW,UAAA,YAAsB,MAAA;;;;EAcjC,SAAA,CAAA,GAAa,WAAA,SAAoB,MAAA;AAAA;;;;;;;ADzKnC;;iBEtDsB,QAAA,CAAS,GAAA,UAAa,MAAA,GAAQ,MAAA,CAAO,OAAA,GAAsB,OAAA;;;iBCRjE,YAAA,CAAa,MAAA,EAAQ,aAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/logger.ts","../src/lazy-process.ts","../src/task-list.ts","../src/cron-process.ts","../src/restarting-process.ts","../src/manager.ts","../src/env-manager.ts","../src/index.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { _ as ProcessDefinitionSchema, a as TaskStateSchema, c as CronProcessStateSchema, d as CrashLoopConfigSchema, f as RestartPolicySchema, g as LazyProcess, h as RestartingProcessStateSchema, i as TaskList, l as RetryConfigSchema, m as RestartingProcessOptionsSchema, n as EnvManager, o as CronProcess, p as RestartingProcess, r as NamedProcessDefinitionSchema, s as CronProcessOptionsSchema, t as logger, u as BackoffStrategySchema, v as ProcessStateSchema, y as treeKill } from "./logger-BIJzGqk3.mjs";
+import { _ as ProcessDefinition, a as TaskStateSchema, c as CronProcessState, d as CrashLoopConfig, f as RestartPolicy, g as LazyProcess, h as RestartingProcessState, i as TaskList, l as RetryConfig, m as RestartingProcessOptions, n as EnvManager, o as CronProcess, p as RestartingProcess, r as NamedProcessDefinitionSchema, s as CronProcessOptions, t as logger, u as BackoffStrategy, v as ProcessState } from "./logger-BU2RmetS.mjs";
 
 //#region src/index.ts
 function defineConfig(config) {
@@ -6,5 +6,5 @@ function defineConfig(config) {
 }
 
 //#endregion
-export { BackoffStrategySchema, CrashLoopConfigSchema, CronProcess, CronProcessOptionsSchema, CronProcessStateSchema, EnvManager, LazyProcess, NamedProcessDefinitionSchema, ProcessDefinitionSchema, ProcessStateSchema, RestartPolicySchema, RestartingProcess, RestartingProcessOptionsSchema, RestartingProcessStateSchema, RetryConfigSchema, TaskList, TaskStateSchema, defineConfig, logger, treeKill };
+export { BackoffStrategy, CrashLoopConfig, CronProcess, CronProcessOptions, CronProcessState, EnvManager, LazyProcess, NamedProcessDefinitionSchema, ProcessDefinition, ProcessState, RestartPolicy, RestartingProcess, RestartingProcessOptions, RestartingProcessState, RetryConfig, TaskList, TaskStateSchema, defineConfig, logger };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { ManagerConfig } from \"./manager.ts\";\n\nexport function defineConfig(config: ManagerConfig) {\n  return config;\n}\n\nexport * from \"./restarting-process.ts\";\nexport * from \"./cron-process.ts\";\nexport * from \"./task-list.ts\";\nexport * from \"./lazy-process.ts\";\nexport * from \"./env-manager.ts\";\nexport * from \"./logger.ts\";\nexport * from \"./tree-kill.ts\";\n"],"mappings":";;;AAEA,SAAgB,aAAa,QAAuB;AAClD,QAAO"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { ManagerConfig } from \"./manager.ts\";\n\nexport function defineConfig(config: ManagerConfig) {\n  return config;\n}\n\nexport * from \"./restarting-process.ts\";\nexport * from \"./cron-process.ts\";\nexport * from \"./task-list.ts\";\nexport * from \"./lazy-process.ts\";\nexport * from \"./env-manager.ts\";\nexport * from \"./logger.ts\";\n"],"mappings":";;;AAEA,SAAgB,aAAa,QAAuB;AAClD,QAAO"}