privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-E66Z2TI7.mjs

@@ -0,0 +1,203 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/pi-background-tasks/src/core/lazy-module.ts?ext=pi-background-tasks
+var SynchronousActivationCloseFence = class {
+  static {
+    __name(this, "SynchronousActivationCloseFence");
+  }
+  closed = false;
+  callbacks = /* @__PURE__ */ new Set();
+  add(callback) {
+    this.callbacks.add(callback);
+    if (this.closed) callback();
+  }
+  close() {
+    this.closed = true;
+    const failures = [];
+    for (const callback of this.callbacks) {
+      try {
+        callback();
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(
+        failures,
+        `synchronous activation close barrier failed in ${String(failures.length)} callback(s)`
+      );
+    }
+  }
+};
+var MODULE_ID_MAX_CHARS = 120;
+var CAUSE_MAX_CHARS = 480;
+var CLOSE_REASON_MAX_CHARS = 160;
+function boundedSingleLine(value, maximum) {
+  const singleLine = value.replace(/\s+/gu, " ").trim();
+  if (singleLine.length <= maximum) return singleLine;
+  return `${singleLine.slice(0, maximum)}\u2026`;
+}
+__name(boundedSingleLine, "boundedSingleLine");
+function boundedModuleId(moduleId) {
+  const bounded = boundedSingleLine(moduleId, MODULE_ID_MAX_CHARS);
+  return bounded.length > 0 ? bounded : "unnamed-module";
+}
+__name(boundedModuleId, "boundedModuleId");
+function causeText(error) {
+  if (error instanceof Error) {
+    const message = error.message.trim();
+    return boundedSingleLine(
+      message.length > 0 ? `${error.name}: ${message}` : error.name,
+      CAUSE_MAX_CHARS
+    );
+  }
+  return boundedSingleLine(String(error), CAUSE_MAX_CHARS);
+}
+__name(causeText, "causeText");
+var LazyModuleLoadError = class extends Error {
+  static {
+    __name(this, "LazyModuleLoadError");
+  }
+  code = "lazy_module_load_failed";
+  moduleId;
+  constructor(moduleId, error) {
+    const cause = causeText(error);
+    super(`lazy_module_load_failed: deferred module ${moduleId} could not load: ${cause}`);
+    this.name = "LazyModuleLoadError";
+    this.moduleId = moduleId;
+  }
+};
+var LazyModuleClosedError = class extends Error {
+  static {
+    __name(this, "LazyModuleClosedError");
+  }
+  code = "lazy_module_closed";
+  moduleId;
+  constructor(moduleId, reason) {
+    super(
+      `lazy_module_closed: deferred module ${moduleId} belongs to a closed activation (${boundedSingleLine(reason, CLOSE_REASON_MAX_CHARS) || "closed"})`
+    );
+    this.name = "LazyModuleClosedError";
+    this.moduleId = moduleId;
+  }
+};
+var LazyModule = class {
+  static {
+    __name(this, "LazyModule");
+  }
+  moduleId;
+  importer;
+  currentState = "unloaded";
+  activationGeneration = 0;
+  loadingPromise;
+  loadedValue;
+  loadFailure;
+  closedFailure;
+  constructor(moduleId, importer) {
+    this.moduleId = boundedModuleId(moduleId);
+    this.importer = importer;
+  }
+  get state() {
+    return this.currentState;
+  }
+  /** Synchronously and permanently close this activation. */
+  close(reason = "activation closed") {
+    if (this.currentState === "closed") return;
+    this.activationGeneration += 1;
+    this.currentState = "closed";
+    this.loadedValue = void 0;
+    this.loadingPromise = void 0;
+    this.loadFailure = void 0;
+    this.closedFailure = new LazyModuleClosedError(this.moduleId, reason);
+  }
+  /** Assert immediately before an activation-owned side effect. */
+  assertOpen(expectedGeneration = this.activationGeneration) {
+    if (this.currentState === "closed" || expectedGeneration !== this.activationGeneration) {
+      throw this.closedError();
+    }
+  }
+  load() {
+    const generation = this.activationGeneration;
+    try {
+      this.assertOpen(generation);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    if (this.currentState === "loaded") {
+      const loaded = this.loadedValue;
+      if (loaded === void 0) {
+        return Promise.reject(
+          new Error(`lazy_module_invariant: ${this.moduleId} is loaded without a value`)
+        );
+      }
+      return Promise.resolve(loaded.value);
+    }
+    if (this.currentState === "failed") {
+      const failure = this.loadFailure;
+      if (failure === void 0) {
+        return Promise.reject(
+          new Error(`lazy_module_invariant: ${this.moduleId} failed without an error`)
+        );
+      }
+      return Promise.reject(failure);
+    }
+    if (this.currentState === "loading") {
+      const pending2 = this.loadingPromise;
+      if (pending2 === void 0) {
+        return Promise.reject(
+          new Error(`lazy_module_invariant: ${this.moduleId} is loading without a promise`)
+        );
+      }
+      return pending2;
+    }
+    this.currentState = "loading";
+    const pending = Promise.resolve().then(() => {
+      this.assertOpen(generation);
+      return this.importer();
+    }).then(
+      (value) => {
+        this.assertOpen(generation);
+        this.loadedValue = { value };
+        this.loadingPromise = void 0;
+        this.currentState = "loaded";
+        return value;
+      },
+      (error) => {
+        this.assertOpen(generation);
+        const failure = new LazyModuleLoadError(this.moduleId, error);
+        this.loadFailure = failure;
+        this.loadingPromise = void 0;
+        this.currentState = "failed";
+        throw failure;
+      }
+    );
+    this.loadingPromise = pending;
+    return pending;
+  }
+  /**
+   * Load once, then invoke this caller's operation independently after the
+   * final generation check. Only module loading is shared between callers.
+   */
+  async run(operation) {
+    const generation = this.activationGeneration;
+    this.assertOpen(generation);
+    const module = await this.load();
+    this.assertOpen(generation);
+    return operation(module);
+  }
+  closedError() {
+    const failure = this.closedFailure;
+    if (failure !== void 0) return failure;
+    const created = new LazyModuleClosedError(this.moduleId, "activation closed");
+    this.closedFailure = created;
+    return created;
+  }
+};
+
+export {
+  SynchronousActivationCloseFence,
+  LazyModule
+};