@narumitw/pi-sync 0.49.10 → 0.49.11

package/dist/index.ts

@@ -0,0 +1,668 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  createSyncAttentionController,
+  syncAttentionMatchesConfig
+} from "./chunks/chunk-JNOOSPEW.js";
+import {
+  completeSyncArguments,
+  parseOptions,
+  resolveSyncCommand,
+  setSyncSetupCompletions,
+  splitArgs,
+  usage,
+  validateCommandOptions
+} from "./chunks/chunk-4U6AFLJB.js";
+import {
+  recoverSnapshotTransactionsOnStartup
+} from "./chunks/chunk-3NDD5QPM.js";
+import {
+  unlock,
+  withLock
+} from "./chunks/chunk-LJDSHNS3.js";
+import {
+  SetupPullRequiresUiError,
+  errorMessage,
+  isSyncDecisionRequiredError
+} from "./chunks/chunk-W64NEHXT.js";
+import "./chunks/chunk-RGJ6SOYR.js";
+import "./chunks/chunk-EWX3TPLQ.js";
+import {
+  activeLocalConfigPath,
+  configuredSyncSetupNames,
+  consumeLocalConfigMigrationNotice,
+  createLocalConfigDocument,
+  ensureStateDir,
+  isMissingConfigError,
+  loadConfig,
+  loadPartialConfig,
+  localConfigPath,
+  localConfigTemplate,
+  readLocalConfigObject,
+  readStateForConfig,
+  sessionTokenWarnings,
+  syncSessionsWarnings
+} from "./chunks/chunk-APZVBSM6.js";
+import {
+  migrateLegacyStateDirectory,
+  stateDirectoryMigrationNotice,
+  withStateDirectoryAccess
+} from "./chunks/chunk-F5QL2GPY.js";
+import {
+  RemoteSelectionMismatchError,
+  formatRemoteSelectionMismatch
+} from "./chunks/chunk-YQ6UW7IF.js";
+
+// src/sync-extension.ts
+var STATUS_KEY = "sync";
+var AUTO_SYNC_OPTIONS = {
+  yes: true,
+  force: false,
+  stale: false,
+  silent: true,
+  reload: false,
+  auto: true,
+  args: []
+};
+function sync(pi, dependencies = {}) {
+  const loaders = {
+    setupSwitch: cachedModuleLoader(
+      dependencies.loadSetupSwitch ?? (() => import("./chunks/setup-switch-X3W3FALZ.js"))
+    ),
+    snapshot: cachedModuleLoader(dependencies.loadSnapshot ?? (() => import("./chunks/snapshot-WBSV4MQG.js"))),
+    syncState: cachedModuleLoader(dependencies.loadSyncState ?? (() => import("./chunks/sync-state-36H7ULG2.js"))),
+    operations: cachedModuleLoader(
+      dependencies.loadSyncOperations ?? (() => import("./chunks/sync-operations-MPAFVVHA.js"))
+    )
+  };
+  const attention = createSyncAttentionController();
+  let sessionAbort = new AbortController();
+  let shutdownAbort;
+  pi.registerCommand("sync", {
+    description: "Sync Pi settings through Git, WebDAV, R2, or S3-compatible storage",
+    getArgumentCompletions: completeSyncArguments,
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI) {
+        throw new Error(
+          "/sync requires TUI or RPC mode so results and safety prompts are observable."
+        );
+      }
+      const run = () => handleCommand(args, ctx, sessionAbort.signal, loaders, attention);
+      if (splitArgs(args)[0] === "migrate-state") await run();
+      else await withStateDirectoryAccess(run);
+    }
+  });
+  pi.on("session_start", async (_event, ctx) => {
+    shutdownAbort?.abort(new DOMException("Session replaced", "AbortError"));
+    shutdownAbort = void 0;
+    sessionAbort.abort(new DOMException("Session replaced", "AbortError"));
+    sessionAbort = new AbortController();
+    const signal = sessionAbort.signal;
+    attention.reset(ctx);
+    let decision;
+    try {
+      decision = await withStateDirectoryAccess(() => startSession(ctx, signal, loaders));
+    } catch (error) {
+      if (signal.aborted) return;
+      ctx.ui.notify(`pi-sync state access failed: ${errorMessage(error)}`, "error");
+      return;
+    }
+    if (!decision || signal.aborted) return;
+    attention.set(decision, "sync");
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify(
+        `pi-sync auto sync skipped: ${formatRemoteSelectionMismatch(
+          decision.setupName,
+          decision.localInclude,
+          decision.remoteInclude
+        )}
+RPC review is read-only.`,
+        "warning"
+      );
+    } else if (attention.markOffered()) {
+      await resolveSelectionAttention(ctx, attention, signal, loaders, {
+        cancelLabel: "Later",
+        withStateAccess: withStateDirectoryAccess
+      });
+    }
+    if (!signal.aborted) attention.publish(ctx);
+  });
+  pi.on("session_shutdown", async (event, ctx) => {
+    sessionAbort.abort(new DOMException("Session shut down", "AbortError"));
+    attention.reset(ctx);
+    shutdownAbort?.abort(new DOMException("Session shut down again", "AbortError"));
+    const controller = new AbortController();
+    shutdownAbort = controller;
+    const signal = combineSignals(controller.signal, AbortSignal.timeout(3e4));
+    const reason = typeof event === "object" && event ? event.reason : void 0;
+    try {
+      if (reason !== "reload") {
+        await withStateDirectoryAccess(async () => {
+          if (signal.aborted) return;
+          await autoPushSessions(ctx, signal, loaders);
+        });
+      }
+    } catch (error) {
+      if (!signal.aborted) {
+        ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
+      }
+    } finally {
+      if (shutdownAbort === controller) shutdownAbort = void 0;
+    }
+    if (signal.aborted) return;
+    ctx.ui.setStatus(STATUS_KEY, void 0);
+  });
+}
+async function startSession(ctx, signal, loaders) {
+  if (signal.aborted) return;
+  try {
+    const migrationNotice2 = stateDirectoryMigrationNotice();
+    if (migrationNotice2) ctx.ui.notify(migrationNotice2, "warning");
+  } catch (error) {
+    ctx.ui.notify(`pi-sync state directory requires attention: ${errorMessage(error)}`, "error");
+    return;
+  }
+  try {
+    await recoverSnapshotTransactionsOnStartup();
+    if (signal.aborted) return;
+  } catch (error) {
+    if (signal.aborted) return;
+    ctx.ui.notify(`pi-sync recovery required: ${errorMessage(error)}`, "error");
+    return;
+  }
+  try {
+    setSyncSetupCompletions(await configuredSyncSetupNames());
+    if (signal.aborted) return;
+  } catch {
+    if (signal.aborted) return;
+    setSyncSetupCompletions([]);
+  }
+  const migrationNotice = consumeLocalConfigMigrationNotice();
+  if (migrationNotice) ctx.ui.notify(migrationNotice, "warning");
+  if (signal.aborted) return;
+  return autoSync(ctx, signal, loaders);
+}
+async function handleCommand(rawArgs, ctx, sessionSignal, loaders, attention) {
+  if (!rawArgs.trim()) {
+    try {
+      const { showSyncManager } = await import("./chunks/manager-ui-7E25VWUP.js");
+      if (sessionSignal.aborted) return;
+      await showSyncManager(
+        ctx,
+        (route, signal, onCommit, target) => executeCommand(
+          route,
+          ctx,
+          combineSignals(sessionSignal, signal),
+          loaders,
+          onCommit,
+          target
+        ),
+        sessionSignal,
+        {
+          getAttention: () => attention.current(),
+          onSelectionResolved: (expected) => {
+            if (attention.current() === expected) attention.clear(ctx);
+          }
+        }
+      );
+    } catch (error) {
+      if (sessionSignal.aborted) return;
+      ctx.ui.setStatus(STATUS_KEY, void 0);
+      ctx.ui.notify(errorMessage(error), "error");
+    }
+    if (!sessionSignal.aborted) attention.publish(ctx);
+    return;
+  }
+  const result = await executeCommand(rawArgs, ctx, sessionSignal, loaders);
+  if (result.kind === "decision-required") {
+    ctx.ui.notify(result.decision.directMessage, "error");
+  } else if (result.kind === "remote-selection-required") {
+    const origin = directSelectionOrigin(rawArgs);
+    if (origin) attention.set(result.decision, origin);
+    const deterministic = splitArgs(rawArgs).some((arg) => arg === "--yes" || arg === "-y");
+    if (origin && ctx.mode === "tui" && !deterministic) {
+      await resolveSelectionAttention(ctx, attention, sessionSignal, loaders);
+    } else {
+      ctx.ui.notify(
+        formatRemoteSelectionMismatch(
+          result.decision.setupName,
+          result.decision.localInclude,
+          result.decision.remoteInclude
+        ),
+        "error"
+      );
+    }
+  }
+  await clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, sessionSignal);
+  await reconcileSelectionAttention(ctx, attention, sessionSignal);
+  if (!sessionSignal.aborted) attention.publish(ctx);
+}
+async function clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, signal) {
+  if (result.kind !== "completed" || result.outcome === "cancelled" || signal.aborted) return;
+  const [command, ...rest] = splitArgs(rawArgs);
+  if (command !== "sync" && command !== "pull" && command !== "push") return;
+  const current = attention.current();
+  if (!current) return;
+  try {
+    const options = parseOptions(rest);
+    const setupName = options.setup ?? (await loadConfig()).setupName;
+    if (signal.aborted || attention.current() !== current) return;
+    if (current.decision.setupName === setupName) attention.clear(ctx);
+  } catch {
+  }
+}
+async function reconcileSelectionAttention(ctx, attention, signal) {
+  const current = attention.current();
+  if (!current || signal.aborted) return;
+  try {
+    const config = await loadConfig(current.decision.setupName);
+    if (signal.aborted || attention.current() !== current) return;
+    if (!syncAttentionMatchesConfig(current, config)) attention.clear(ctx);
+  } catch {
+    if (!signal.aborted && attention.current() === current) attention.clear(ctx);
+  }
+}
+function directSelectionOrigin(rawArgs) {
+  const command = splitArgs(rawArgs)[0];
+  return command === "sync" || command === "pull" || command === "push" ? command : void 0;
+}
+async function resolveSelectionAttention(ctx, attention, signal, loaders, options = {}) {
+  const current = attention.current();
+  if (!current || signal.aborted) return;
+  const { dispatchManagerResult } = await import("./chunks/manager-result-dispatcher-YKBLZ7KL.js");
+  if (signal.aborted || attention.current() !== current) return;
+  await dispatchManagerResult(
+    ctx,
+    { kind: "remote-selection-required", decision: current.decision },
+    current.origin,
+    (route, actionSignal, onCommit, target) => {
+      const execute = () => executeRecoveryCommand(
+        route,
+        ctx,
+        combineSignals(signal, actionSignal),
+        loaders,
+        onCommit,
+        target
+      );
+      return options.withStateAccess ? options.withStateAccess(execute) : execute();
+    },
+    signal,
+    {
+      cancelLabel: options.cancelLabel,
+      withStateAccess: options.withStateAccess,
+      onSelectionResolved: () => {
+        if (attention.current() === current) attention.clear(ctx);
+      }
+    }
+  );
+}
+async function executeRecoveryCommand(rawArgs, ctx, signal, loaders, onCommit, setup) {
+  try {
+    const [subcommand, ...rest] = splitArgs(rawArgs);
+    if (subcommand !== "sync" && subcommand !== "pull" && subcommand !== "push") {
+      throw new Error(`Unsupported sync recovery route: ${subcommand ?? "missing"}`);
+    }
+    const options = parseOptions(rest);
+    if (setup !== void 0) options.setup = setup;
+    if (signal) options.signal = signal;
+    if (onCommit) options.onCommit = onCommit;
+    options.reload = false;
+    options.auto = false;
+    validateCommandOptions(subcommand, options);
+    const operations = await loaders.operations();
+    throwIfAborted(options.signal);
+    if (subcommand === "push") {
+      const outcome = await withLock("push", () => operations.push(ctx, options));
+      return { kind: "completed", ...outcome ? { outcome } : {} };
+    }
+    if (subcommand === "pull") {
+      const outcome = await withLock("pull", () => operations.pull(ctx, options));
+      return { kind: "completed", ...outcome ? { outcome } : {} };
+    }
+    await withLock("sync", () => operations.syncBoth(ctx, options));
+    return { kind: "completed" };
+  } catch (error) {
+    if (signal?.aborted) return { kind: "failed" };
+    ctx.ui.setStatus(STATUS_KEY, void 0);
+    if (error instanceof RemoteSelectionMismatchError) {
+      return { kind: "remote-selection-required", decision: error.decision };
+    }
+    if (isSyncDecisionRequiredError(error)) {
+      return { kind: "decision-required", decision: error.decision };
+    }
+    ctx.ui.notify(errorMessage(error), "error");
+    return { kind: "failed" };
+  }
+}
+async function executeCommand(rawArgs, ctx, signal, loaders, onCommit, setup) {
+  try {
+    const command = await resolveSyncCommand(rawArgs, ctx);
+    if (signal?.aborted || !command) return { kind: "completed" };
+    const { subcommand, rest } = command;
+    const options = parseOptions(rest);
+    if (setup !== void 0) options.setup = setup;
+    if (signal) options.signal = signal;
+    if (onCommit) options.onCommit = onCommit;
+    validateCommandOptions(subcommand, options);
+    switch (subcommand) {
+      case "help":
+        ctx.ui.notify(usage(), "info");
+        return { kind: "completed" };
+      case "use": {
+        const { useSyncSetup } = await loaders.setupSwitch();
+        throwIfAborted(options.signal);
+        await useSyncSetup(
+          ctx,
+          options.args[0] ?? "",
+          async (selectedSetup) => {
+            const operations = await loaders.operations();
+            throwIfAborted(options.signal);
+            return withLock(
+              "pull",
+              () => operations.pull(ctx, { ...options, setup: selectedSetup })
+            );
+          },
+          void 0,
+          options.signal
+        );
+        return { kind: "completed" };
+      }
+      case "init":
+        await initConfig(ctx, signal);
+        return { kind: "completed" };
+      case "config":
+        await showConfig(ctx, options);
+        return { kind: "completed" };
+      case "files": {
+        const { showFileSelection } = await import("./chunks/file-selection-4UABOP44.js");
+        throwIfAborted(options.signal);
+        await showFileSelection(ctx, options.setup, options.signal);
+        return { kind: "completed" };
+      }
+      case "status": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await operations.status(ctx, options);
+        return { kind: "completed" };
+      }
+      case "diff": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await operations.diff(ctx, options);
+        return { kind: "completed" };
+      }
+      case "doctor": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await operations.doctor(ctx, options);
+        return { kind: "completed" };
+      }
+      case "push": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        const outcome = await withLock("push", () => operations.push(ctx, options));
+        return { kind: "completed", ...outcome ? { outcome } : {} };
+      }
+      case "pull": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        const outcome = await withLock("pull", () => operations.pull(ctx, options));
+        return { kind: "completed", ...outcome ? { outcome } : {} };
+      }
+      case "sync": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await withLock("sync", () => operations.syncBoth(ctx, options));
+        return { kind: "completed" };
+      }
+      case "history": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await operations.history(ctx, options);
+        return { kind: "completed" };
+      }
+      case "rollback": {
+        const operations = await loaders.operations();
+        throwIfAborted(options.signal);
+        await withLock("rollback", () => operations.rollback(ctx, options));
+        return { kind: "completed" };
+      }
+      case "migrate-state":
+        await migrateStateDirectory(ctx, options);
+        return { kind: "completed" };
+      case "unlock":
+        await unlock(ctx, options);
+        return { kind: "completed" };
+      default:
+        ctx.ui.notify(`Unknown /sync command: ${subcommand}
+
+${usage()}`, "warning");
+        return { kind: "failed" };
+    }
+  } catch (error) {
+    if (signal?.aborted) return { kind: "failed" };
+    ctx.ui.setStatus(STATUS_KEY, void 0);
+    if (error instanceof SetupPullRequiresUiError) throw error;
+    if (error instanceof RemoteSelectionMismatchError) {
+      return { kind: "remote-selection-required", decision: error.decision };
+    }
+    if (isSyncDecisionRequiredError(error)) {
+      return { kind: "decision-required", decision: error.decision };
+    }
+    ctx.ui.notify(errorMessage(error), "error");
+    return { kind: "failed" };
+  }
+}
+async function migrateStateDirectory(ctx, options) {
+  const notice = stateDirectoryMigrationNotice();
+  if (!notice) {
+    ctx.ui.notify("pi-sync already uses the canonical pi-sync/ state directory.", "info");
+    return;
+  }
+  if (!options.yes && !await ctx.ui.confirm(
+    "Migrate pi-sync state directory",
+    "Confirm that every other Pi process is closed. pi-sync will atomically rename .pisync/ to pi-sync/ without merging or deleting either root.",
+    { signal: options.signal }
+  )) {
+    ctx.ui.notify("pi-sync state migration cancelled.", "info");
+    return;
+  }
+  throwIfAborted(options.signal);
+  const result = await migrateLegacyStateDirectory();
+  throwIfAborted(options.signal);
+  if (result.status === "ready") {
+    ctx.ui.notify("pi-sync already uses the canonical pi-sync/ state directory.", "info");
+    return;
+  }
+  ctx.ui.notify(result.message, result.status === "migrated" ? "info" : "warning");
+}
+async function autoSync(ctx, signal, loaders) {
+  try {
+    const partial = await loadPartialConfig();
+    throwIfAborted(signal);
+    if (!partial.automatic) return;
+    await ensureStateDir();
+    throwIfAborted(signal);
+    await loadConfig();
+    throwIfAborted(signal);
+    const operations = await loaders.operations();
+    throwIfAborted(signal);
+    await withLock("auto-sync", () => {
+      throwIfAborted(signal);
+      return operations.syncBoth(ctx, { ...AUTO_SYNC_OPTIONS, signal });
+    });
+  } catch (error) {
+    if (signal.aborted || isMissingConfigError(error)) return;
+    ctx.ui.setStatus(STATUS_KEY, void 0);
+    if (error instanceof RemoteSelectionMismatchError) return error.decision;
+    ctx.ui.notify(`pi-sync auto sync skipped: ${errorMessage(error)}`, "warning");
+  }
+}
+async function autoPushSessions(ctx, signal, loaders) {
+  try {
+    const partial = await loadPartialConfig();
+    throwIfAborted(signal);
+    if (!partial.automatic) return;
+    if (!partial.include.includes("sessions")) return;
+    await ensureStateDir();
+    throwIfAborted(signal);
+    const config = await loadConfig();
+    throwIfAborted(signal);
+    if (!config.include.includes("sessions")) return;
+    const [operations, snapshotModule, syncStateModule] = await Promise.all([
+      loaders.operations(),
+      loaders.snapshot(),
+      loaders.syncState()
+    ]);
+    throwIfAborted(signal);
+    await withLock("auto-session-push", async () => {
+      throwIfAborted(signal);
+      const state = await readStateForConfig(config);
+      throwIfAborted(signal);
+      const local = await snapshotModule.createSnapshot(
+        config.snapshotIdentity,
+        snapshotOptionsForContext(ctx, config)
+      );
+      throwIfAborted(signal);
+      if (!syncStateModule.hasLocalChanges(local, state, config)) return;
+      await operations.push(ctx, { ...AUTO_SYNC_OPTIONS, signal }, { config, state, local });
+    });
+  } catch (error) {
+    if (signal.aborted || isMissingConfigError(error)) return;
+    ctx.ui.setStatus(STATUS_KEY, void 0);
+    ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
+  }
+}
+async function initConfig(ctx, signal) {
+  const configPath = localConfigPath();
+  if (await readLocalConfigObject()) {
+    ctx.ui.notify(`Config already exists: ${await activeLocalConfigPath()}`, "info");
+    return;
+  }
+  if (ctx.mode === "tui") {
+    const { showSetupWizard } = await import("./chunks/manager-ui-7E25VWUP.js");
+    throwIfAborted(signal);
+    await showSetupWizard(ctx, signal);
+    return;
+  }
+  await createLocalConfigDocument(localConfigTemplate());
+  ctx.ui.notify(
+    `Created ${configPath}. Add a storage connection and sync setup before syncing.`,
+    "info"
+  );
+}
+async function showConfig(ctx, options) {
+  const config = await loadConfig(options.setup);
+  const warnings = [
+    ...config.backend.type === "s3" ? sessionTokenWarnings(config.backend.profile) : [],
+    ...syncSessionsWarnings(config)
+  ];
+  const storageLines = configStorageLines(config);
+  ctx.ui.notify(
+    [
+      "pi-sync config:",
+      `sync setup: ${config.setupName}`,
+      `storage connection: ${config.connectionName}`,
+      ...storageLines,
+      `storage path: ${config.storagePath}`,
+      `automatic sync: ${config.automatic ? "enabled" : "disabled"}`,
+      `included content: ${config.include.join(", ") || "none"}`,
+      `sessions: ${config.include.includes("sessions") ? "included" : "not included"}`,
+      `settings file: ${localConfigPath()}`,
+      ...warnings
+    ].join("\n"),
+    warnings.length > 0 ? "warning" : "info"
+  );
+}
+function configStorageLines(config) {
+  switch (config.backend.type) {
+    case "git":
+      return [
+        "kind: git",
+        `remote: ${displayGitRemote(config.backend.profile.remote)}`,
+        "authentication: existing Git/SSH credentials (not stored)",
+        `branch: ${config.backend.destination.branch}`
+      ];
+    case "webdav":
+      return [
+        "kind: webdav",
+        `url: ${displayWebDavUrl(config.backend.profile.url, config.backend.profile.username)}`,
+        "username: configured (value hidden)",
+        "password: configured"
+      ];
+    case "s3":
+      return [
+        "kind: s3",
+        `endpoint: ${config.backend.profile.endpoint}`,
+        `bucket: ${config.backend.destination.bucket}`,
+        `region: ${config.backend.profile.region}`,
+        "access key id: configured",
+        "secret access key: configured",
+        `session token: ${config.backend.profile.sessionToken ? "configured" : "not configured"}`
+      ];
+  }
+}
+function displayGitRemote(value) {
+  if (!value) return "missing";
+  try {
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return value.replace(/^(?:[^@\s]+@)?(?<host>[^:]+):.+$/u, "$<host>:\u2026");
+  }
+}
+function displayWebDavUrl(value, username) {
+  if (!value) return "missing";
+  try {
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return username ? `${url.origin}/\u2026` : `${url.origin}${url.pathname}`;
+  } catch {
+    return "invalid (value hidden)";
+  }
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
+}
+function combineSignals(primary, secondary) {
+  return secondary ? AbortSignal.any([primary, secondary]) : primary;
+}
+function snapshotOptionsForContext(ctx, config) {
+  return {
+    include: config.include,
+    sessionDir: sessionDirFromContext(ctx)
+  };
+}
+function sessionDirFromContext(ctx) {
+  const manager = ctx.sessionManager;
+  const usesDefaultSessionDir = manager.usesDefaultSessionDir;
+  if (typeof usesDefaultSessionDir === "function" && usesDefaultSessionDir.call(manager)) {
+    return void 0;
+  }
+  const getSessionDir = manager.getSessionDir;
+  return typeof getSessionDir === "function" ? getSessionDir.call(manager) : void 0;
+}
+function cachedModuleLoader(load) {
+  let pending;
+  return () => {
+    if (!pending) {
+      pending = load().catch((error) => {
+        pending = void 0;
+        throw error;
+      });
+    }
+    return pending;
+  };
+}
+export {
+  sync as default
+};
+//# sourceMappingURL=index.ts.map