@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-3C26DPFK.js

@@ -0,0 +1,566 @@
+import {
+  classifyFailureEnvelope
+} from "./chunk-NWRUSEXG.js";
+import {
+  runSemanticPrompt
+} from "./chunk-G2PTLLEL.js";
+import {
+  signalCoordinator
+} from "./chunk-72YTZMAM.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  mkPoeticTempDirSync
+} from "./chunk-C57KJOUQ.js";
+import {
+  atomicWriteJson
+} from "./chunk-A3YGID55.js";
+import {
+  getRuntimeEnv
+} from "./chunk-ENRGKNR5.js";
+import {
+  mergeExecutionContextEnvOverrides
+} from "./chunk-UI2F6DJ5.js";
+import {
+  debugLog,
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import {
+  POETIC_ALLOW_MOCK_PROVIDERS,
+  POETIC_MOCK_PROVIDERS,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/core/safety/recursion-tracker.ts
+import { chmodSync, existsSync, rmSync, unlinkSync } from "fs";
+import { chmod, mkdir, readFile, rm, unlink } from "fs/promises";
+import { join } from "path";
+var RecursionTracker = class {
+  stateDir;
+  stateFile;
+  maxDepth;
+  currentState = null;
+  previousStateFile;
+  cleanupHandlers = [];
+  /**
+   * Number of live, unbalanced `enter()` calls in THIS process. The tracker is a
+   * per-process singleton, so overlapping in-process competitions share one
+   * instance. Only the FIRST `enter()`
+   * establishes the depth/state file and only the LAST `exit()` tears it down;
+   * intermediate calls just adjust this count. This makes enter()/exit() safe to
+   * call from independent concurrent invocations without one clearing another's
+   * state. NOTE: the cross-PROCESS recursion DEPTH (the exponential-spawn guard)
+   * is unchanged — it is still derived once, on the first entry, from the parent
+   * state file; this counter only governs local teardown ordering.
+   */
+  activeEntries = 0;
+  /**
+   * Single-flight guard for first-entry establishment. The first concurrent
+   * `enter()` that finds no `currentState` runs the establishment work (read
+   * parent state file → derive depth → write our state file → set the child env
+   * pointer) exactly once; any other entrant that arrives while it is in flight
+   * awaits THIS promise instead of re-deriving depth. Without it, two concurrent
+   * first entries would both pass the `currentState === null` check and the
+   * second could read the first's just-written state file as its "parent",
+   * inflating depth to 1 for same-process concurrency. Cleared once settled so a
+   * later entry can retry if establishment failed.
+   */
+  establishmentInFlight = null;
+  constructor(maxDepth = 2) {
+    this.stateDir = mkPoeticTempDirSync("recursion");
+    chmodSync(this.stateDir, 448);
+    this.stateFile = join(this.stateDir, `recursion-${process.pid}.json`);
+    this.maxDepth = maxDepth;
+    this.registerCleanupHandlers();
+  }
+  /**
+   * Initialize recursion tracking for this process.
+   * Checks if we're exceeding recursion limits.
+   *
+   * @throws Error if recursion depth exceeded
+   * @returns Current depth after increment
+   */
+  async enter() {
+    this.activeEntries += 1;
+    try {
+      if (this.currentState) {
+        return this.currentState.depth;
+      }
+      if (!this.establishmentInFlight) {
+        this.establishmentInFlight = this.establish();
+      }
+      try {
+        const state = await this.establishmentInFlight;
+        return state.depth;
+      } finally {
+        this.establishmentInFlight = null;
+      }
+    } catch (err) {
+      this.activeEntries -= 1;
+      throw err;
+    }
+  }
+  /**
+   * One-time first-entry establishment: read the parent state file, derive this
+   * process's depth, enforce the recursion limit, persist our state, and point
+   * children at it. Runs at most once concurrently (guarded by
+   * `establishmentInFlight`); the result is shared by all concurrent first
+   * entrants so they observe the same depth.
+   */
+  async establish() {
+    await this.ensureStateDir();
+    const parentStateFile = getRuntimeEnv("POETIC_RECURSION_STATE_FILE");
+    let parentState = null;
+    if (parentStateFile) {
+      try {
+        const content = await readFile(parentStateFile, "utf8");
+        parentState = parseJsonWithContext(content, "parent recursion state file");
+      } catch (_err) {
+        parentState = null;
+      }
+    }
+    const currentDepth = parentState ? parentState.depth + 1 : 0;
+    if (currentDepth >= this.maxDepth) {
+      throw new Error(
+        `Alert: RECURSION LIMIT EXCEEDED
+
+Maximum recursion depth: ${this.maxDepth}
+Current depth: ${currentDepth}
+Parent PIDs: ${parentState?.parentPids.join(" \u2192 ") || "none"}
+
+This safety limit prevents exponential process growth that could crash your system.
+Poetic detected nested parallel execution or recursive task spawning.
+
+Solution:
+- Use --fan-out only at the top level, not in sub-agents
+- Check if your task accidentally spawns nested Poetic commands
+- Increase limit with POETIC_MAX_RECURSION_DEPTH env var (not recommended)
+`
+      );
+    }
+    const state = {
+      depth: currentDepth,
+      maxDepth: this.maxDepth,
+      parentPids: [...parentState?.parentPids || [], process.pid],
+      timestamp: Date.now()
+    };
+    this.currentState = state;
+    await atomicWriteJson(this.stateFile, state);
+    this.previousStateFile = parentStateFile;
+    mergeExecutionContextEnvOverrides({
+      POETIC_RECURSION_STATE_FILE: this.stateFile
+    });
+    return state;
+  }
+  /** Active state-file pointer to propagate to child execution contexts. */
+  getStateFilePath() {
+    return this.currentState ? this.stateFile : void 0;
+  }
+  /**
+   * Clean up recursion state for this process.
+   * Called automatically on process exit.
+   *
+   * Ref-counted: balances one `enter()`. When more than one live entry remains
+   * (concurrent/nested in-process invocations), this only decrements the count
+   * and returns WITHOUT tearing down, so one invocation cannot clear state that
+   * another still depends on. Only the last balancing `exit()` removes the state
+   * file and restores the parent env pointer.
+   *
+   * @param opts.force - Tear down immediately regardless of the live-entry count
+   *   (used by full-reset and signal/process-exit cleanup, where the whole
+   *   process is being reset or terminated). Default false.
+   */
+  async exit(opts) {
+    if (!opts?.force && this.activeEntries > 1) {
+      this.activeEntries -= 1;
+      return;
+    }
+    this.activeEntries = 0;
+    this.establishmentInFlight = null;
+    if (this.currentState) {
+      mergeExecutionContextEnvOverrides({
+        POETIC_RECURSION_STATE_FILE: this.previousStateFile
+      });
+      this.previousStateFile = void 0;
+    }
+    if (this.stateFile) {
+      try {
+        await unlink(this.stateFile);
+      } catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT") {
+          this.currentState = null;
+          return;
+        }
+        emitWarning(
+          "WS-003",
+          {
+            subsystem: "safety",
+            executionPhase: "cleanup"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              error: err instanceof Error ? err.message : String(err),
+              operation: "cleanupRecursionState",
+              stateFile: this.stateFile
+            }
+          }
+        );
+      }
+    }
+    this.currentState = null;
+  }
+  /**
+   * Get current recursion depth.
+   * Returns 0 if not yet entered.
+   */
+  getDepth() {
+    return this.currentState?.depth ?? 0;
+  }
+  /**
+   * Get maximum allowed recursion depth.
+   */
+  getMaxDepth() {
+    return this.maxDepth;
+  }
+  /**
+   * Get parent process PIDs for debugging.
+   */
+  getParentPids() {
+    return this.currentState?.parentPids ?? [];
+  }
+  /**
+   * Check if we can safely spawn child processes.
+   * Returns true if we're below recursion limit.
+   */
+  canSpawnChildren() {
+    const currentDepth = this.currentState?.depth ?? 0;
+    return currentDepth < this.maxDepth - 1;
+  }
+  /**
+   * Ensure state directory exists with secure permissions.
+   */
+  async ensureStateDir() {
+    if (!existsSync(this.stateDir)) {
+      await mkdir(this.stateDir, { recursive: true });
+      await chmod(this.stateDir, 448);
+    }
+  }
+  /**
+   * Register cleanup handlers for process exit.
+   */
+  registerCleanupHandlers() {
+    signalCoordinator.register("RecursionTracker", async () => {
+      await this.exit({ force: true });
+    });
+    const exitHandler = () => {
+      if (this.stateFile && existsSync(this.stateFile)) {
+        try {
+          unlinkSync(this.stateFile);
+        } catch {
+        }
+      }
+    };
+    process.on("exit", exitHandler);
+    this.cleanupHandlers = [() => process.off("exit", exitHandler)];
+  }
+  /**
+   * Clean up resources and remove event listeners.
+   * Also removes the temporary directory created in constructor.
+   */
+  close() {
+    for (const cleanup of this.cleanupHandlers) {
+      try {
+        cleanup();
+      } catch (_error) {
+      }
+    }
+    this.cleanupHandlers = [];
+    if (this.stateDir && existsSync(this.stateDir)) {
+      try {
+        rmSync(this.stateDir, { recursive: true, force: true });
+      } catch (_error) {
+      }
+    }
+  }
+  /**
+   * Async cleanup for temporary directory.
+   * Preferred over close() when async context is available.
+   */
+  async closeAsync() {
+    for (const cleanup of this.cleanupHandlers) {
+      try {
+        cleanup();
+      } catch (_error) {
+      }
+    }
+    this.cleanupHandlers = [];
+    if (this.stateDir && existsSync(this.stateDir)) {
+      try {
+        await rm(this.stateDir, { recursive: true, force: true });
+      } catch (_error) {
+      }
+    }
+  }
+};
+var _globalRecursionTracker = null;
+var DEFAULT_MAX_RECURSION_DEPTH = 2;
+function parseMaxRecursionDepthEnv(value) {
+  if (value === void 0) {
+    return DEFAULT_MAX_RECURSION_DEPTH;
+  }
+  const normalized = value.trim();
+  if (!/^\d+$/.test(normalized)) {
+    return DEFAULT_MAX_RECURSION_DEPTH;
+  }
+  const parsed = Number(normalized);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_RECURSION_DEPTH;
+}
+function resolveMaxRecursionDepth(override) {
+  if (override !== void 0) {
+    return Number.isSafeInteger(override) ? override : DEFAULT_MAX_RECURSION_DEPTH;
+  }
+  return parseMaxRecursionDepthEnv(getRuntimeEnv("POETIC_MAX_RECURSION_DEPTH"));
+}
+function getGlobalRecursionTracker(maxDepth) {
+  if (!_globalRecursionTracker) {
+    const depth = resolveMaxRecursionDepth(maxDepth);
+    _globalRecursionTracker = new RecursionTracker(depth);
+  }
+  return _globalRecursionTracker;
+}
+async function resetGlobalRecursionTracker() {
+  if (_globalRecursionTracker) {
+    await _globalRecursionTracker.exit({ force: true });
+  }
+}
+var globalRecursionTracker = new Proxy({}, {
+  get(_target, prop) {
+    if (prop === "reset") {
+      return resetGlobalRecursionTracker;
+    }
+    const tracker = getGlobalRecursionTracker();
+    const value = tracker[prop];
+    return typeof value === "function" ? value.bind(tracker) : value;
+  }
+});
+
+// src/orchestrator/autoloop-recovery.ts
+var TERMINAL_ENVIRONMENT_FAILURES = /* @__PURE__ */ new Set([
+  "auth_unavailable",
+  "cli_missing",
+  "quota_exhausted",
+  "model_unavailable",
+  "sandbox_denied",
+  "invalid_configuration"
+]);
+var TRANSIENT_FAILURES = /* @__PURE__ */ new Set([
+  "idle_terminated",
+  "startup_timeout",
+  "transport_error",
+  "output_malformed",
+  "rate_limited"
+]);
+function isPositiveClassification(failure) {
+  return failure.confidence === "high" && (failure.evidenceSource === "typed" || failure.evidenceSource === "parsed");
+}
+function deriveDirectAutoloopRecovery(failure, options = {}) {
+  if (failure.category === "user_cancelled" && isPositiveClassification(failure)) {
+    return "operator_stop";
+  }
+  if (options.deliveryRescueEligible === true) {
+    return "delivery_rescue";
+  }
+  if (isPositiveClassification(failure) && TERMINAL_ENVIRONMENT_FAILURES.has(failure.category)) {
+    return "terminal_stop";
+  }
+  if (isPositiveClassification(failure) && TRANSIENT_FAILURES.has(failure.category) && failure.retryable === true && failure.mutationState === "none-observed") {
+    return "transport_retry";
+  }
+  return "agent_correction";
+}
+function serializeDirectAutoloopFailureRecovery(failure, disposition) {
+  return {
+    schemaVersion: 1,
+    failure: {
+      category: failure.category,
+      evidenceSource: failure.evidenceSource,
+      executionPhase: failure.executionPhase,
+      mutationState: failure.mutationState,
+      retryable: failure.retryable,
+      failoverEligible: failure.failoverEligible,
+      confidence: failure.confidence
+    },
+    recovery: { disposition }
+  };
+}
+var DirectAutoloopExecutionFailure = class extends Error {
+  failureEnvelope;
+  constructor(error, failureEnvelope, detail = "") {
+    super(`${error.message}${detail}`, { cause: error });
+    this.name = "DirectAutoloopExecutionFailure";
+    this.failureEnvelope = failureEnvelope;
+  }
+};
+function createDirectAutoloopCancellationFailure(error, executionPhase, mutationState = executionPhase === "post-run" ? "none-observed" : "unknown") {
+  return new DirectAutoloopExecutionFailure(
+    error,
+    classifyFailureEnvelope(
+      { reason: "cancelled", message: error.message },
+      { executionPhase, mutationState }
+    )
+  );
+}
+function createDirectAutoloopProviderFailure(error, filesModifiedCount, changedFilesReadable, detail = "") {
+  const mutationState = filesModifiedCount > 0 ? "observed" : changedFilesReadable ? "none-observed" : "unknown";
+  return new DirectAutoloopExecutionFailure(
+    error,
+    classifyFailureEnvelope(error, { executionPhase: "post-run", mutationState }),
+    detail
+  );
+}
+function getCarriedDirectAutoloopFailureEnvelope(error) {
+  return error instanceof DirectAutoloopExecutionFailure ? error.failureEnvelope : void 0;
+}
+
+// src/core/validation/semantic-progress-rater.ts
+function clampTimeoutToDeadline(configuredTimeoutMs, deadlineMs) {
+  if (deadlineMs == null) {
+    return configuredTimeoutMs;
+  }
+  const remainingMs = Math.max(0, deadlineMs - Date.now());
+  if (configuredTimeoutMs == null) {
+    return remainingMs;
+  }
+  return Math.min(configuredTimeoutMs, remainingMs);
+}
+function generateProgressPrompt(task, gitDiff) {
+  return `You are evaluating whether code changes move closer to completing a task.
+
+Task: ${task}
+
+Git Diff:
+\`\`\`diff
+${gitDiff}
+\`\`\`
+
+Questions:
+1. Do these changes move closer to completing the task? (yes/no)
+2. Confidence (0-100%): How confident are you in this assessment?
+3. Brief reasoning (1-2 sentences)
+
+Respond in this exact format:
+MOVED_CLOSER: yes|no
+CONFIDENCE: 0-100
+REASONING: your brief explanation`;
+}
+function parseProgressResponse(responseText) {
+  const movedCloserMatch = responseText.match(/MOVED_CLOSER:\s*(yes|no)/i);
+  if (!movedCloserMatch?.[1]) {
+    throw new Error("Semantic progress response missing MOVED_CLOSER field");
+  }
+  const movedCloser = movedCloserMatch[1].toLowerCase() === "yes";
+  const confidenceMatch = responseText.match(/CONFIDENCE:\s*(\d+)/);
+  if (!confidenceMatch?.[1]) {
+    throw new Error("Semantic progress response missing CONFIDENCE field");
+  }
+  const confidencePercent = Number.parseInt(confidenceMatch[1], 10);
+  if (!Number.isFinite(confidencePercent) || confidencePercent < 0 || confidencePercent > 100) {
+    throw new Error(`Semantic progress response CONFIDENCE out of range: ${confidenceMatch[1]}`);
+  }
+  const confidence = Math.max(0, Math.min(1, confidencePercent / 100));
+  const reasoningMatch = responseText.match(/REASONING:\s*(.+?)(?:\n|$)/s);
+  const reasoning = reasoningMatch?.[1]?.trim() || "No reasoning provided";
+  return {
+    movedCloser,
+    confidence,
+    reasoning
+  };
+}
+async function rateProgress(task, gitDiff, options = {}) {
+  debugLog("[ProgressRater] Evaluating progress for task...");
+  debugLog(`[ProgressRater] Task: ${task.substring(0, 100)}...`);
+  debugLog(`[ProgressRater] Diff size: ${gitDiff.length} characters`);
+  if (!gitDiff || gitDiff.trim().length === 0) {
+    debugLog("[ProgressRater] Empty git diff - no progress made");
+    return {
+      movedCloser: false,
+      confidence: 1,
+      reasoning: "No changes made (empty git diff)"
+    };
+  }
+  if (!task || task.trim().length === 0) {
+    debugLog("[ProgressRater] Empty task - cannot evaluate progress");
+    return {
+      movedCloser: false,
+      confidence: 0.5,
+      reasoning: "Cannot evaluate progress without task description"
+    };
+  }
+  if (options.abortSignal?.aborted) {
+    throw new Error("Semantic progress evaluation aborted before provider launch");
+  }
+  if (options.deadlineMs !== void 0 && options.deadlineMs <= Date.now()) {
+    throw new Error("Semantic progress evaluation deadline exhausted before provider launch");
+  }
+  if (readEnv(POETIC_MOCK_PROVIDERS).value === "1" && readEnv(POETIC_ALLOW_MOCK_PROVIDERS).value === true) {
+    debugLog("[ProgressRater] Mock provider mode - accepting non-empty diff as progress");
+    return {
+      movedCloser: true,
+      confidence: 0.95,
+      reasoning: "Mock provider mode accepted a non-empty diff as semantic progress"
+    };
+  }
+  if (!options.provider || !options.workingDir) {
+    throw new Error(
+      "rateProgress requires provider and workingDir when evaluating non-empty inputs"
+    );
+  }
+  const prompt = generateProgressPrompt(task, gitDiff);
+  const timeoutMs = clampTimeoutToDeadline(options.timeoutMs, options.deadlineMs);
+  if (options.deadlineMs !== void 0 && timeoutMs === 0) {
+    throw new Error("Semantic progress evaluation deadline exhausted before provider launch");
+  }
+  const providerResult = await runSemanticPrompt({
+    provider: options.provider,
+    prompt,
+    workingDir: options.workingDir,
+    profile: options.profile,
+    model: options.model,
+    timeoutMs,
+    deadlineMs: options.deadlineMs,
+    abortSignal: options.abortSignal,
+    workspaceMode: options.workspaceMode,
+    allowedTools: options.allowedTools,
+    tools: options.tools,
+    disallowedTools: options.disallowedTools,
+    executionIntent: "analysis"
+  });
+  const stdout = (providerResult.stdout ?? "").trim();
+  if (!stdout) {
+    throw new Error("Semantic progress provider returned empty output");
+  }
+  const result = parseProgressResponse(stdout);
+  debugLog(
+    `[ProgressRater] Result: ${result.movedCloser ? "moved closer" : "no progress"} (confidence: ${result.confidence.toFixed(2)})`
+  );
+  debugLog(`[ProgressRater] Reasoning: ${result.reasoning}`);
+  return result;
+}
+function isSignificantProgress(result, minConfidence = 0.7) {
+  return result.movedCloser && result.confidence >= minConfidence;
+}
+
+export {
+  globalRecursionTracker,
+  deriveDirectAutoloopRecovery,
+  serializeDirectAutoloopFailureRecovery,
+  createDirectAutoloopCancellationFailure,
+  createDirectAutoloopProviderFailure,
+  getCarriedDirectAutoloopFailureEnvelope,
+  rateProgress,
+  isSignificantProgress
+};
+//# sourceMappingURL=chunk-3C26DPFK.js.map

package/dist/chunk-3FLXLLB7.js

@@ -0,0 +1,26 @@
+import {
+  createEngineMetadata
+} from "./chunk-GHHFDU2U.js";
+
+// src/core/providers/opencode/metadata.ts
+var metadata = createEngineMetadata(
+  {
+    id: "opencode",
+    name: "OpenCode",
+    description: "Open source AI coding agent via OpenCode CLI",
+    cliCommand: "opencode",
+    cliBinary: "opencode",
+    installCommand: "curl -fsSL https://opencode.ai/install | bash",
+    authHint: "opencode auth login",
+    setupCommand: "poetic provider setup --providers opencode",
+    docsPath: "docs/PROVIDER_SETUP.md",
+    docsAnchor: "opencode-cli",
+    experimental: false
+  },
+  ["installCommand", "experimental"]
+);
+
+export {
+  metadata
+};
+//# sourceMappingURL=chunk-3FLXLLB7.js.map

package/dist/chunk-3FOZ2VHV.js

@@ -0,0 +1,100 @@
+import {
+  getDefaultPaths
+} from "./chunk-UUH2RVKS.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/steering/user-agents.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+
+// src/core/steering/template.ts
+import { createHash } from "crypto";
+var DEFAULT_USER_AGENTS_TEMPLATE = `# Poetic Global Instructions
+
+These instructions are injected by Poetic for provider runs on this machine.
+Keep them short, durable, and broadly applicable across repositories.
+
+- Read existing code before modifying it. Check for existing helpers and local patterns.
+- Prefer standard well-known solutions. Avoid adding algorithmic or data-structure complexity for small inputs unless the task explicitly justifies it.
+`;
+var DEFAULT_USER_AGENTS_TEMPLATE_SHA256 = createHash("sha256").update(DEFAULT_USER_AGENTS_TEMPLATE).digest("hex");
+
+// src/core/steering/user-agents.ts
+var unreadableWarnings = /* @__PURE__ */ new Set();
+var cachedUserGlobal = null;
+function sha256Text(text) {
+  return createHash2("sha256").update(text).digest("hex");
+}
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function getUserAgentsPath() {
+  const override = process.env.POETIC_AGENTS_FILE?.trim();
+  if (override) return override;
+  return join(getDefaultPaths().userConfigDir, "AGENTS.md");
+}
+function warnUnreadableAgentsFile(path, error) {
+  if (unreadableWarnings.has(path)) return;
+  unreadableWarnings.add(path);
+  emitWarning(
+    "CFG-001",
+    {
+      taskId: "runtime-steering",
+      subsystem: "steering",
+      executionPhase: "setup"
+    },
+    {
+      severity: "WARN" /* WARN */,
+      metadata: {
+        operation: "loadUserGlobalAgents",
+        path,
+        error: error instanceof Error ? error.message : String(error)
+      }
+    }
+  );
+}
+function loadUserGlobalAgentsFile() {
+  const path = getUserAgentsPath();
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const stats = statSync(path);
+    if (!stats.isFile()) {
+      throw new Error("Path exists but is not a regular file");
+    }
+    if (cachedUserGlobal?.path === path && cachedUserGlobal.mtimeMs === stats.mtimeMs) {
+      return cachedUserGlobal.loaded;
+    }
+    const text = readFileSync(path, "utf8");
+    const sha256 = sha256Text(text);
+    const loaded = {
+      text,
+      source: {
+        kind: "user-global",
+        path,
+        mtime: stats.mtimeMs,
+        sha256,
+        bytes: byteLength(text),
+        editedByUser: sha256 !== DEFAULT_USER_AGENTS_TEMPLATE_SHA256
+      }
+    };
+    cachedUserGlobal = { path, mtimeMs: stats.mtimeMs, loaded };
+    return loaded;
+  } catch (error) {
+    warnUnreadableAgentsFile(path, error);
+    return null;
+  }
+}
+
+export {
+  DEFAULT_USER_AGENTS_TEMPLATE,
+  sha256Text,
+  byteLength,
+  getUserAgentsPath,
+  loadUserGlobalAgentsFile
+};
+//# sourceMappingURL=chunk-3FOZ2VHV.js.map