openpond 0.1.0 → 0.2.0

package/dist/chunks/chunk-ZNQEROWP.js

@@ -0,0 +1,254 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+
+// ../../packages/persistence/dist/private-permissions.js
+import { execFileSync } from "node:child_process";
+import { chmodSync, lstatSync } from "node:fs";
+
+// ../../packages/persistence/dist/errors.js
+var PersistenceError = class extends Error {
+  issue;
+  constructor(issue, options) {
+    super(issue.message, options);
+    this.name = "PersistenceError";
+    this.issue = issue;
+  }
+};
+function persistenceIssue(error, filePath) {
+  if (error instanceof PersistenceError)
+    return error.issue;
+  return { code: "STORAGE_UNAVAILABLE", path: filePath, message: "OpenPond could not access its storage.", action: "Check the folder permissions and available disk space, then retry." };
+}
+function isMissing(error) {
+  return error?.code === "ENOENT";
+}
+
+// ../../packages/persistence/dist/windows-powershell.js
+function windowsPowerShellEnvironment(extra = {}) {
+  const env = { ...process.env, ...extra };
+  for (const key of Object.keys(env))
+    if (key.toLowerCase() === "psmodulepath")
+      delete env[key];
+  return env;
+}
+
+// ../../packages/persistence/dist/private-permissions.js
+var secured = /* @__PURE__ */ new Map();
+var setOwnerAcl = [
+  "$ErrorActionPreference='Stop'",
+  "$identity=[System.Security.Principal.WindowsIdentity]::GetCurrent().User",
+  "$acl=New-Object System.Security.AccessControl.DirectorySecurity",
+  "$acl.SetOwner($identity)",
+  "$acl.SetAccessRuleProtection($true,$false)",
+  "$rule=New-Object System.Security.AccessControl.FileSystemAccessRule($identity,'FullControl','ContainerInherit,ObjectInherit','None','Allow')",
+  "$acl.AddAccessRule($rule)",
+  "Set-Acl -LiteralPath $env:OPENPOND_PRIVATE_DIRECTORY -AclObject $acl"
+].join("; ");
+function protectPrivateDirectory(directory) {
+  if (process.platform !== "win32") {
+    chmodSync(directory, 448);
+    return;
+  }
+  const stat = lstatSync(directory);
+  const identity = `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
+  if (secured.get(directory) === identity)
+    return;
+  try {
+    execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", setOwnerAcl], {
+      env: windowsPowerShellEnvironment({ OPENPOND_PRIVATE_DIRECTORY: directory }),
+      stdio: ["ignore", "ignore", "pipe"],
+      timeout: 3e4,
+      windowsHide: true
+    });
+    secured.set(directory, identity);
+  } catch (cause) {
+    throw new PersistenceError({
+      code: "PRIVATE_STORAGE_UNAVAILABLE",
+      path: directory,
+      message: "OpenPond could not restrict this storage folder to its owner.",
+      action: "Use a local folder that supports private access controls, then retry."
+    }, { cause });
+  }
+}
+
+// ../../packages/persistence/dist/path-safety.js
+import { lstatSync as lstatSync2 } from "node:fs";
+import path from "node:path";
+function assertStorageAncestors(file) {
+  let directory = path.resolve(file);
+  while (true) {
+    try {
+      const stat = lstatSync2(directory);
+      const systemAlias = process.platform === "darwin" && ["/tmp", "/var", "/etc"].includes(directory);
+      if (stat.isSymbolicLink() && !systemAlias)
+        throw new PersistenceError({ code: "UNSAFE_STORAGE_PATH", path: directory, message: "A managed storage path passes through a symbolic link.", action: "Use the canonical local folder and keep managed subdirectories inside that home." });
+    } catch (error) {
+      if (!isMissing(error))
+        throw error;
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory)
+      return;
+    directory = parent;
+  }
+}
+
+// ../../packages/persistence/dist/database.js
+import { mkdirSync, chmodSync as chmodSync2, existsSync, lstatSync as lstatSync3 } from "node:fs";
+import path4 from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+// ../../packages/persistence/dist/home-context.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import path2 from "node:path";
+var homes = new AsyncLocalStorage();
+var currentOpenPondHome = () => homes.getStore();
+function withOpenPondHome(home, operation) {
+  return homes.run(path2.resolve(home), operation);
+}
+function bindHomeCallbacks(home, callbacks) {
+  return Object.fromEntries(Object.entries(callbacks).map(([name, value]) => [name, typeof value === "function" ? (...args) => withOpenPondHome(home, () => value(...args)) : value]));
+}
+
+// ../../packages/persistence/dist/home.js
+import os from "node:os";
+import path3 from "node:path";
+function resolveOpenPondHome(options = {}) {
+  const env = options.env ?? process.env;
+  const explicit = options.home?.trim() || (options.env ? void 0 : currentOpenPondHome()) || env.OPENPOND_HOME?.trim();
+  if (explicit)
+    return path3.resolve(expandHome(explicit));
+  for (const name of ["OPENPOND_APP_HOME", "OPENPOND_CONFIG_DIR"]) {
+    if (env[name]?.trim()) {
+      throw new PersistenceError({ code: "RETIRED_HOME_OPTION", path: name, message: `${name} has been replaced by OPENPOND_HOME.`, action: "Set OPENPOND_HOME to the destination home. Use openpond config migrate --source-app-home to import a previous installation." });
+    }
+  }
+  return path3.join(os.homedir(), options.channel === "nightly" ? ".openpond-nightly" : ".openpond");
+}
+function expandHome(value) {
+  return value === "~" ? os.homedir() : value.startsWith("~/") ? path3.join(os.homedir(), value.slice(2)) : value;
+}
+function storagePaths(home = resolveOpenPondHome()) {
+  const root = path3.resolve(home);
+  return {
+    home: root,
+    config: path3.join(root, "config.toml"),
+    marker: path3.join(root, "storage.json"),
+    database: path3.join(root, "state", "state.sqlite"),
+    cache: path3.join(root, "cache", "cache.sqlite"),
+    credentials: path3.join(root, "secrets", "credentials.json"),
+    key: path3.join(root, "secrets", "credentials.key"),
+    token: path3.join(root, "secrets", "server-token"),
+    runtime: path3.join(root, "runtime"),
+    library: path3.join(root, "library"),
+    instructions: path3.join(root, "instructions")
+  };
+}
+function resolveConfigPath(value, root, allowHome = true) {
+  return path3.resolve(root, allowHome ? expandHome(value) : value);
+}
+
+// ../../packages/persistence/dist/database.js
+var PERSISTENCE_TABLES_SQL = `
+CREATE TABLE IF NOT EXISTS scaffold_registrations (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS account_sessions (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS account_selection (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS profile_installations (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS extension_installations (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS client_preferences (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS saved_local_projects (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS codex_sidebar_state (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS browser_tab_state (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS project_trust (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS refiner_bindings (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS refiner_transitions (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS config_run_snapshots (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+CREATE TABLE IF NOT EXISTS provider_connection_state (id TEXT PRIMARY KEY, payload TEXT NOT NULL, revision INTEGER NOT NULL DEFAULT 1);
+`;
+function openStorageDatabase(filePath, readOnly = false) {
+  assertStorageAncestors(path4.dirname(filePath));
+  if (!readOnly) {
+    mkdirSync(path4.dirname(filePath), { recursive: true, mode: 448 });
+    protectPrivateDirectory(path4.dirname(filePath));
+  }
+  if (existsSync(filePath) && lstatSync3(filePath).isSymbolicLink())
+    throw new PersistenceError({ code: "UNSAFE_STORAGE_PATH", path: filePath, message: "Storage database cannot be a symbolic link.", action: "Choose a regular local database file." });
+  const db = new DatabaseSync(filePath, { readOnly });
+  try {
+    db.exec("PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;");
+    if (!readOnly) {
+      db.exec("PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL;");
+      if (process.platform !== "win32")
+        chmodSync2(filePath, 384);
+    }
+    return db;
+  } catch (error) {
+    db.close();
+    throw error;
+  }
+}
+function withLocalDatabase(home, action) {
+  const db = openStorageDatabase(storagePaths(home).database);
+  try {
+    db.exec(PERSISTENCE_TABLES_SQL);
+    return action(db);
+  } finally {
+    db.close();
+  }
+}
+function getLocalRecord(home, table, id) {
+  if (!existsSync(storagePaths(home).database))
+    return null;
+  return withLocalDatabase(home, (db) => {
+    const row = db.prepare(`SELECT payload, revision FROM ${table} WHERE id = ?`).get(id);
+    return row ? { value: JSON.parse(row.payload), revision: row.revision } : null;
+  });
+}
+function listLocalRecords(home, table) {
+  if (!existsSync(storagePaths(home).database))
+    return {};
+  return withLocalDatabase(home, (db) => Object.fromEntries(db.prepare(`SELECT id, payload, revision FROM ${table} ORDER BY id`).all().map((row) => [row.id, { value: JSON.parse(row.payload), revision: row.revision }])));
+}
+function putLocalRecord(home, table, id, value, expectedRevision) {
+  return withLocalDatabase(home, (db) => {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const existing = db.prepare(`SELECT revision FROM ${table} WHERE id = ?`).get(id);
+      if (expectedRevision !== void 0 && expectedRevision !== (existing?.revision ?? null))
+        throw new PersistenceError({ code: "STATE_CONFLICT", path: table, message: "This record changed while it was being edited.", action: "Reload the latest record and retry." });
+      const revision = (existing?.revision ?? 0) + 1;
+      db.prepare(`INSERT INTO ${table} (id, payload, revision) VALUES (?, ?, ?) ON CONFLICT(id) DO UPDATE SET payload=excluded.payload, revision=excluded.revision`).run(id, JSON.stringify(value), revision);
+      db.exec("COMMIT");
+      return revision;
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  });
+}
+function deleteLocalRecord(home, table, id) {
+  withLocalDatabase(home, (db) => {
+    db.prepare(`DELETE FROM ${table} WHERE id = ?`).run(id);
+  });
+}
+
+export {
+  withOpenPondHome,
+  bindHomeCallbacks,
+  PersistenceError,
+  persistenceIssue,
+  isMissing,
+  resolveOpenPondHome,
+  expandHome,
+  storagePaths,
+  resolveConfigPath,
+  windowsPowerShellEnvironment,
+  protectPrivateDirectory,
+  assertStorageAncestors,
+  PERSISTENCE_TABLES_SQL,
+  openStorageDatabase,
+  withLocalDatabase,
+  getLocalRecord,
+  listLocalRecords,
+  putLocalRecord,
+  deleteLocalRecord
+};

package/dist/chunks/{cli-L5VPOV6I.js → cli-D2MUUBEX.js}

@@ -3,14 +3,16 @@ import {
   resolveWebLaunchMessages,
   runOpenPondAppServerCli,
   runOpenPondServerCli
-} from "./chunk-P6JLLWMI.js";
-import "./chunk-5TKZBMQM.js";
-import "./chunk-AN2EYCN3.js";
-import "./chunk-EFET7LB7.js";
-import "./chunk-6G6MDZLM.js";
+} from "./chunk-OCBRPU2K.js";
+import "./chunk-X6F4LBTQ.js";
+import "./chunk-6SMNG6YA.js";
+import "./chunk-KCRCIQPD.js";
+import "./chunk-XA4KBDMY.js";
 import "./chunk-NTK22KJD.js";
 import "./chunk-R3C3MNSI.js";
 import "./chunk-X7ZG4TSW.js";
+import "./chunk-4KA25HUP.js";
+import "./chunk-ZNQEROWP.js";
 import "./chunk-JTHL5XJ2.js";
 import "./chunk-FQS2QL5F.js";
 import "./chunk-UACZUFIA.js";

package/dist/chunks/configuration-command-NR6JYIUD.js

@@ -0,0 +1,187 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  CliUsageError
+} from "./chunk-PS37DB5F.js";
+import {
+  MigrationResolutionsSchema,
+  atomicWriteFile,
+  clearCache,
+  collectArtifactOrphans,
+  configEditorSchema,
+  configRecoveryRevisions,
+  exportRecoveryBackup,
+  exportSettings,
+  fileRevision,
+  initializeHome,
+  patchConfig,
+  readConfig,
+  readOptionalFile,
+  recoverMigration,
+  replaceConfigText,
+  resolveEffectiveConfig,
+  restartMigration,
+  restoreConfigRevision,
+  restoreRecoveryBackup,
+  setProjectTrust,
+  validateConfigText
+} from "./chunk-4KA25HUP.js";
+import {
+  persistenceIssue,
+  resolveOpenPondHome,
+  storagePaths
+} from "./chunk-ZNQEROWP.js";
+import "./chunk-7RIGZB7N.js";
+import "./chunk-FQS2QL5F.js";
+import "./chunk-MUMPWI4O.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/configuration-command.ts
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+var stringOption = (options, name) => typeof options[name] === "string" ? options[name] : void 0;
+function print(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function keyPath(options, fallback) {
+  const explicit = stringOption(options, "keyPath");
+  if (explicit) {
+    const parts = JSON.parse(explicit);
+    if (Array.isArray(parts) && parts.length && parts.every((part) => typeof part === "string" && part.length)) return parts;
+    throw new CliUsageError("--key-path must be a JSON array of key segments.");
+  }
+  if (!fallback) throw new CliUsageError("Specify a setting key, or --key-path for keys containing dots.");
+  return fallback.split(".");
+}
+async function runConfigurationCommand(options, rest) {
+  const home = resolveOpenPondHome({ home: stringOption(options, "home") });
+  const command = rest[0] ?? "get";
+  const file = storagePaths(home).config;
+  if (command === "path") {
+    console.log(file);
+    return;
+  }
+  if (command === "export") {
+    const value = await exportSettings(home), destination = stringOption(options, "file");
+    if (destination) {
+      await atomicWriteFile(path.resolve(destination), JSON.stringify(value, null, 2), { privateParent: false });
+      print({ path: path.resolve(destination), requiresRebinding: value.requiresRebinding });
+    } else print(value);
+    return;
+  }
+  if (command === "backup" || command === "restore") {
+    const file2 = stringOption(options, "file"), keyFile = stringOption(options, "keyFile");
+    if (!file2 || !keyFile) throw new CliUsageError(`config ${command} requires --file <encrypted-backup> and --key-file <separate-32-byte-key-file>.`);
+    const bytes = await readFile(keyFile);
+    const key = bytes.length === 32 ? bytes : Buffer.from(bytes.toString("utf8").trim(), "base64");
+    try {
+      print(command === "backup" ? await exportRecoveryBackup(home, file2, key) : await restoreRecoveryBackup(file2, home, key));
+    } finally {
+      key.fill(0);
+      bytes.fill(0);
+    }
+    return;
+  }
+  if (command === "collect-orphans") {
+    print(await collectArtifactOrphans(home));
+    return;
+  }
+  if (command === "schema") {
+    print(configEditorSchema());
+    return;
+  }
+  if (command === "migrate") {
+    const resolutionFile = stringOption(options, "resolutionFile");
+    const resolutions = resolutionFile ? MigrationResolutionsSchema.parse(JSON.parse(await readFile(resolutionFile, "utf8"))) : void 0;
+    print(await initializeHome(home, { resolutions, sourceAppHome: stringOption(options, "sourceAppHome"), sourceConfig: stringOption(options, "sourceConfig"), sourceBrowserState: stringOption(options, "sourceBrowserState"), dryRun: options.dryRun === true || options.dryRun === "true" }));
+    return;
+  }
+  if (command === "recover") {
+    const revision = stringOption(options, "revision");
+    if (revision) print(await restoreConfigRevision(home, revision, stringOption(options, "expectedRevision") ?? fileRevision(await readOptionalFile(file))));
+    else print(await recoverMigration(home));
+    return;
+  }
+  if (command === "restart-migration") {
+    print(await restartMigration(home));
+    return;
+  }
+  if (command === "effective") {
+    print(await resolveEffectiveConfig(home, { projectRoot: stringOption(options, "projectRoot"), accountId: stringOption(options, "accountId") }));
+    return;
+  }
+  if (command === "trust" || command === "untrust") {
+    const root = stringOption(options, "projectRoot") ?? rest[1];
+    if (!root) throw new CliUsageError("Specify the canonical project root with --project-root.");
+    await setProjectTrust(home, root, stringOption(options, "accountId") ?? "local", command === "trust");
+    print({ root, trusted: command === "trust" });
+    return;
+  }
+  if (command === "revisions") {
+    print(await configRecoveryRevisions(home));
+    return;
+  }
+  if (command === "validate") {
+    const inputFile = stringOption(options, "file") ?? file;
+    validateConfigText(await readFile(inputFile, "utf8"), inputFile, options.project === true || options.project === "true" ? "project" : "user");
+    print({ valid: true, path: inputFile });
+    return;
+  }
+  if (command === "replace") {
+    const source = stringOption(options, "file");
+    if (!source) throw new CliUsageError("config replace requires --file <validated-toml-file>.");
+    print(await replaceConfigText(home, stringOption(options, "expectedRevision") ?? fileRevision(await readOptionalFile(file)), await readFile(source, "utf8")));
+    return;
+  }
+  if (command === "doctor") {
+    const text = await readOptionalFile(file);
+    let issue = null;
+    try {
+      await readConfig(home);
+    } catch (error) {
+      issue = persistenceIssue(error, file);
+    }
+    print({ home, path: file, rawRevision: fileRevision(text), issue, recoverableRevisions: await configRecoveryRevisions(home), migration: await readOptionalFile(path.join(storagePaths(home).runtime, "migration.json")) !== null });
+    if (issue) process.exitCode = 1;
+    return;
+  }
+  await initializeHome(home);
+  if (command === "clear-cache") {
+    await clearCache(home);
+    print({ cleared: true, path: storagePaths(home).cache });
+    return;
+  }
+  const snapshot = await readConfig(home);
+  if (command === "get") {
+    if (!rest[1] && !options.keyPath) {
+      print(snapshot);
+      return;
+    }
+    let value = snapshot.document;
+    for (const key of keyPath(options, rest[1])) value = value && typeof value === "object" ? value[key] : void 0;
+    print(value ?? null);
+    return;
+  }
+  if (command === "set" || command === "unset") {
+    const at = keyPath(options, rest[1]);
+    let value;
+    if (command === "set") {
+      const raw = stringOption(options, "value") ?? rest[2];
+      if (raw === void 0) throw new CliUsageError("config set requires a value. Use JSON for arrays, tables, numbers and booleans.");
+      try {
+        value = JSON.parse(raw);
+      } catch {
+        value = raw;
+      }
+    }
+    print(await patchConfig(
+      home,
+      stringOption(options, "expectedRevision") ?? snapshot.rawRevision,
+      [command === "set" ? { op: "set", path: at, value } : { op: "unset", path: at }]
+    ));
+    return;
+  }
+  throw new CliUsageError(`Unknown config command: ${command}`);
+}
+export {
+  runConfigurationCommand
+};

package/dist/chunks/{continual-FYDKLCO7.js → continual-37CE4LLJ.js}

@@ -1,11 +1,11 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
-import {
-  DEFAULT_LOCAL_TRAINING_API_URL,
-  createLocalAuthenticatedRequest
-} from "./chunk-J7PYGDRY.js";
 import {
   ContinualBenchPanelRoleSchema
 } from "./chunk-R3C3MNSI.js";
+import {
+  DEFAULT_LOCAL_TRAINING_API_URL,
+  createLocalAuthenticatedRequest
+} from "./chunk-26AMV5ZI.js";
 import {
   yaml
 } from "./chunk-X7ZG4TSW.js";

package/dist/chunks/{core-commands-MAN3CSJQ.js → core-commands-SWGIOZLW.js}

@@ -16,15 +16,17 @@ import {
   runTemplateUpdate,
   runToolList,
   runToolRun
-} from "./chunk-CNTM26OW.js";
-import "./chunk-HFPUR4CQ.js";
-import "./chunk-2JABRRNR.js";
+} from "./chunk-K4TZEHAW.js";
+import "./chunk-3VEYNDHN.js";
+import "./chunk-FJ2JGB2N.js";
 import "./chunk-SMNFI2FU.js";
-import "./chunk-N3TGCM7J.js";
+import "./chunk-KSRWKXRB.js";
+import "./chunk-PS37DB5F.js";
+import "./chunk-4KA25HUP.js";
+import "./chunk-ZNQEROWP.js";
+import "./chunk-7RIGZB7N.js";
 import "./chunk-4L3ZJS2T.js";
 import "./chunk-JTHL5XJ2.js";
-import "./chunk-D7BO5Y5J.js";
-import "./chunk-KSRWKXRB.js";
 import "./chunk-FQS2QL5F.js";
 import "./chunk-MUMPWI4O.js";
 import "./chunk-UACZUFIA.js";

package/dist/chunks/database-DEYUZDIM.js

@@ -0,0 +1,20 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  PERSISTENCE_TABLES_SQL,
+  deleteLocalRecord,
+  getLocalRecord,
+  listLocalRecords,
+  openStorageDatabase,
+  putLocalRecord,
+  withLocalDatabase
+} from "./chunk-ZNQEROWP.js";
+import "./chunk-UACZUFIA.js";
+export {
+  PERSISTENCE_TABLES_SQL,
+  deleteLocalRecord,
+  getLocalRecord,
+  listLocalRecords,
+  openStorageDatabase,
+  putLocalRecord,
+  withLocalDatabase
+};

package/dist/chunks/{desktop-test-OE5SST2W.js → desktop-test-QOS7G5NE.js}

@@ -1,16 +1,18 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   runProcessCommand
-} from "./chunk-HFPUR4CQ.js";
+} from "./chunk-3VEYNDHN.js";
+import "./chunk-FJ2JGB2N.js";
+import "./chunk-SMNFI2FU.js";
+import "./chunk-KSRWKXRB.js";
 import {
   CliUsageError
-} from "./chunk-2JABRRNR.js";
-import "./chunk-SMNFI2FU.js";
-import "./chunk-N3TGCM7J.js";
+} from "./chunk-PS37DB5F.js";
+import "./chunk-4KA25HUP.js";
+import "./chunk-ZNQEROWP.js";
+import "./chunk-7RIGZB7N.js";
 import "./chunk-4L3ZJS2T.js";
 import "./chunk-JTHL5XJ2.js";
-import "./chunk-D7BO5Y5J.js";
-import "./chunk-KSRWKXRB.js";
 import "./chunk-FQS2QL5F.js";
 import {
   optionString,