openship 0.6.0 → 0.6.5

package/dist/chunk-XRNRT37W.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  composeHostChannel,
+  composeHostChannelExpected,
+  composePaths,
+  thisHost
+} from "./chunk-QLX7NBEA.js";
+import {
+  HOST_CHANNEL_BLOCKED,
+  HOST_CHANNEL_NOT_PROVISIONED,
+  HOST_CHANNEL_OPT_OUT,
+  HOST_CHANNEL_RECHECK,
+  HOST_CHANNEL_SYMPTOM,
+  HOST_CHANNEL_UNAFFECTED,
+  HOST_CHANNEL_UNPROVISIONED,
+  explainHostChannelCause,
+  firewallAllowSteps,
+  firewallManager,
+  firewallPersists,
+  hostChannelRuleScope,
+  hostFirewallRule,
+  hostFirewallRuleRemoval,
+  wrapText
+} from "./chunk-LEYSL46B.js";
+
+// src/lib/host-channel-preflight.ts
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+import { confirm, isCancel } from "@clack/prompts";
+var INDENT = "  ";
+function dimWrapped(text, width = 84) {
+  return wrapText(text, width).map((l) => chalk.dim(`${INDENT}${l}
+`)).join("");
+}
+function blockedTail() {
+  return "\n" + dimWrapped(HOST_CHANNEL_RECHECK) + dimWrapped(HOST_CHANNEL_OPT_OUT);
+}
+var PROBE_SCRIPT = `const net = require("node:net");
+const s = net.connect({ host: process.env.OPENSHIP_PROBE_HOST, port: Number(process.env.OPENSHIP_PROBE_PORT) });
+const done = (m) => { console.log("openship-probe:" + m); try { s.destroy(); } catch {} process.exit(0); };
+s.setTimeout(Number(process.env.OPENSHIP_PROBE_TIMEOUT || 4000));
+s.on("connect", () => done("open"));
+s.on("timeout", () => done("timeout"));
+s.on("error", (e) => done("error:" + (e && e.code ? e.code : String(e && e.message))));`;
+async function realProbe(host, port) {
+  const r = spawnSync(
+    "docker",
+    [
+      "compose",
+      "-f",
+      composePaths.file,
+      "exec",
+      "-T",
+      "-e",
+      `OPENSHIP_PROBE_HOST=${host}`,
+      "-e",
+      `OPENSHIP_PROBE_PORT=${port}`,
+      "api",
+      "bun",
+      "-e",
+      PROBE_SCRIPT
+    ],
+    { cwd: composePaths.dir, encoding: "utf8", timeout: 3e4 }
+  );
+  const token = (r.stdout || "").match(/openship-probe:(\S+)/)?.[1];
+  if (!token) {
+    const why = (r.stderr || r.stdout || r.error?.message || "").trim().split("\n").pop();
+    return { code: "unavailable", detail: why || void 0 };
+  }
+  if (token === "open" || token === "timeout") return { code: token };
+  const errno = token.startsWith("error:") ? token.slice("error:".length) : token;
+  if (errno === "ECONNREFUSED" || errno === "ECONNRESET") return { code: "refused", detail: errno };
+  if (errno === "ENOTFOUND" || errno === "EAI_AGAIN") return { code: "unresolved", detail: errno };
+  if (errno === "ENETUNREACH" || errno === "EHOSTUNREACH" || errno === "EHOSTDOWN") {
+    return { code: "no_route", detail: errno };
+  }
+  return { code: "error", detail: errno };
+}
+function realSourceCidrs() {
+  const id = spawnSync("docker", ["compose", "-f", composePaths.file, "ps", "-q", "api"], {
+    cwd: composePaths.dir,
+    encoding: "utf8"
+  }).stdout?.trim().split("\n")[0];
+  if (!id) return [];
+  const nets = spawnSync(
+    "docker",
+    ["inspect", id, "--format", "{{range $k, $v := .NetworkSettings.Networks}}{{$k}}\n{{end}}"],
+    { encoding: "utf8" }
+  ).stdout;
+  const cidrs = /* @__PURE__ */ new Set();
+  for (const net of (nets || "").split("\n").map((n) => n.trim()).filter(Boolean)) {
+    const subnets = spawnSync(
+      "docker",
+      ["network", "inspect", net, "--format", "{{range .IPAM.Config}}{{.Subnet}}\n{{end}}"],
+      { encoding: "utf8" }
+    ).stdout;
+    for (const s of (subnets || "").split("\n").map((v) => v.trim())) {
+      if (/^\d+\.\d+\.\d+\.\d+\/\d+$/.test(s)) cidrs.add(s);
+    }
+  }
+  return [...cidrs];
+}
+function sudoPrefix() {
+  if (typeof process.getuid === "function" && process.getuid() === 0) return [];
+  return process.stdin.isTTY ? ["sudo"] : ["sudo", "-n"];
+}
+function realApplyRule(fw, cidrs, port) {
+  const steps = firewallAllowSteps(fw, hostChannelRuleScope(cidrs, port));
+  if (!steps.supported) return { ok: false, detail: steps.reason };
+  for (const step of steps.value) {
+    const [cmd, ...rest] = [...sudoPrefix(), "sh", "-c", step];
+    const r = spawnSync(cmd, rest, { encoding: "utf8", stdio: ["inherit", "pipe", "pipe"] });
+    if (r.status !== 0) {
+      return { ok: false, detail: (r.stderr || r.stdout || "").trim().split("\n").pop() };
+    }
+  }
+  return { ok: true };
+}
+function defaultDeps() {
+  return {
+    platform: process.platform,
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    channel: composeHostChannel,
+    expected: composeHostChannelExpected,
+    probe: realProbe,
+    sourceCidrs: realSourceCidrs,
+    // All three off the one resolver, which measures this box once. This file used to
+    // run its own `command -v ufw` + `ufw status` ladder, so the CLI and the API could
+    // reach different conclusions about the same host — and it had no way at all to
+    // report nftables, the RHEL-family default.
+    firewall: () => thisHost().profile.firewall,
+    distroFamily: () => thisHost().profile.distroFamily,
+    sshdEnableHint: () => thisHost().sshdEnableHint(),
+    applyRule: realApplyRule,
+    confirmOpen: async ({ rule, port }) => {
+      const ok = await confirm({
+        message: `Open the host firewall so containers can reach port ${port}?`,
+        // Never default-yes: this edits the host's firewall.
+        initialValue: false
+      });
+      return !isCancel(ok) && ok === true;
+    },
+    print: (text) => console.log(text)
+  };
+}
+function impactLines() {
+  return dimWrapped(HOST_CHANNEL_UNAFFECTED) + chalk.dim(`${INDENT}Blocked until the channel works:
+`) + HOST_CHANNEL_BLOCKED.map((l) => chalk.dim(`${INDENT}  \xB7 ${l}
+`)).join("") + dimWrapped(HOST_CHANNEL_SYMPTOM);
+}
+function causeOf(code) {
+  switch (code) {
+    case "timeout":
+    case "refused":
+    case "unresolved":
+    case "no_route":
+    case "error":
+      return code;
+    default:
+      return null;
+  }
+}
+function diagnose(target, probe, sshdEnableHint) {
+  const cause = causeOf(probe.code);
+  if (!cause) {
+    return {
+      firewall: false,
+      text: chalk.yellow(`${INDENT}${target} \u2014 ${probe.detail || "the connection failed"}
+`)
+    };
+  }
+  const { headline, body, firewallShaped } = explainHostChannelCause(cause, {
+    target,
+    host: target.split(":")[0],
+    detail: probe.detail,
+    sshdEnableHint
+  });
+  return {
+    firewall: firewallShaped,
+    text: chalk.yellow(`${INDENT}${headline}
+
+`) + (body ? dimWrapped(body) : "")
+  };
+}
+async function checkHostChannel(overrides = {}) {
+  const deps = { ...defaultDeps(), ...overrides };
+  if (deps.platform !== "linux") return { configured: false };
+  const channel = deps.channel();
+  if (!channel) return { configured: false, unprovisioned: deps.expected() };
+  const probe = await deps.probe(channel.host, channel.port);
+  return {
+    configured: true,
+    target: `${channel.host}:${channel.port}`,
+    code: probe.code,
+    detail: probe.detail
+  };
+}
+async function verifyHostChannel(opts = {}, overrides = {}) {
+  const deps = { ...defaultDeps(), ...overrides };
+  if (deps.platform !== "linux") return { status: "skipped" };
+  const channel = deps.channel();
+  if (!channel) {
+    if (!deps.expected()) return { status: "skipped" };
+    deps.print(
+      chalk.yellow(`
+${INDENT}Host control was not provisioned on this box.
+
+`) + dimWrapped(HOST_CHANNEL_UNPROVISIONED) + "\n" + impactLines() + // The remedy, not a firewall rule: nothing was dialed, so no packet filter has
+      // been established — the same line core's `firewallShaped` draws. It carries the
+      // recheck command itself, so `blockedTail` would only repeat it.
+      chalk.dim(`
+${INDENT}Fix:
+`) + dimWrapped(HOST_CHANNEL_NOT_PROVISIONED) + dimWrapped(HOST_CHANNEL_OPT_OUT)
+    );
+    return { status: "unprovisioned" };
+  }
+  const target = `${channel.host}:${channel.port}`;
+  const probe = await deps.probe(channel.host, channel.port);
+  if (probe.code === "open") return { status: "ok", code: "open" };
+  if (probe.code === "unavailable") {
+    deps.print(
+      chalk.dim(
+        `
+${INDENT}Couldn't check the host channel from the api container${probe.detail ? ` (${probe.detail})` : ""}.
+${INDENT}Verify it later with \`openship doctor\`.
+`
+      )
+    );
+    return { status: "skipped", code: "unavailable" };
+  }
+  const { text, firewall: firewallShaped } = diagnose(target, probe, deps.sshdEnableHint());
+  deps.print(
+    chalk.yellow(`
+${INDENT}Host control is configured, but the api container can't reach it.
+
+`) + text + "\n" + impactLines()
+  );
+  if (!firewallShaped) {
+    deps.print(blockedTail());
+    return { status: "blocked", code: probe.code };
+  }
+  const cidrs = deps.sourceCidrs();
+  const firewall = deps.firewall();
+  const rule = hostFirewallRule(firewall, cidrs, channel.port, deps.distroFamily());
+  const ruleBlock = chalk.dim(`
+${INDENT}Rule to allow it${cidrs.length ? "" : ` (docker's default pool \u2014 the exact subnet couldn't be read)`}:
+`) + rule.split("\n").map((l) => `${INDENT}  ${chalk.cyan(l)}`).join("\n") + "\n";
+  const offerOnly = (why) => {
+    deps.print(ruleBlock + "\n" + dimWrapped(why) + blockedTail());
+    return { status: "blocked", code: probe.code, rule };
+  };
+  const manager = firewallManager(firewall);
+  if (!manager.supported) return offerOnly(manager.reason);
+  if (!firewallPersists(firewall)) {
+    return offerOnly(
+      `Openship won't add this ${firewall} rule for you: it lives in the running ruleset only, so it would not survive a reboot unless something saves it \u2014 and where that is depends on this box. A rule that quietly disappears is worse than one you installed knowing where it lives.`
+    );
+  }
+  deps.print(ruleBlock);
+  const consented = opts.openFirewall ? true : deps.interactive ? await deps.confirmOpen({ rule, port: channel.port }) : false;
+  if (!consented) {
+    deps.print(
+      chalk.dim(
+        `
+${INDENT}Left the firewall alone \u2014 apply the rule above when you're ready.
+` + (deps.interactive ? "" : `${INDENT}To have \`openship up\` add it for you: --open-host-firewall
+`)
+      ) + blockedTail()
+    );
+    return { status: "blocked", code: probe.code, rule };
+  }
+  const applied = deps.applyRule(manager.value, cidrs, channel.port);
+  if (!applied.ok) {
+    deps.print(
+      chalk.red(
+        `
+${INDENT}Couldn't add the rule${applied.detail ? `: ${applied.detail}` : "."}
+`
+      ) + chalk.dim(`${INDENT}Run it yourself with the command above.
+`) + blockedTail()
+    );
+    return { status: "blocked", code: probe.code, rule };
+  }
+  const again = await deps.probe(channel.host, channel.port);
+  if (again.code === "open") {
+    deps.print(chalk.green(`
+${INDENT}Opened \u2014 the host channel is reachable.
+`));
+    return { status: "fixed", code: "open", rule };
+  }
+  deps.print(
+    chalk.yellow(`
+${INDENT}Rule added, but ${target} still isn't reachable.
+
+`) + (again.code === probe.code ? chalk.dim(
+      `${INDENT}Nothing changed, so something ahead of ${firewall} is dropping it \u2014 check
+${INDENT}the DOCKER-USER chain and any cloud/provider firewall.
+`
+    ) : diagnose(target, again, deps.sshdEnableHint()).text) + // The rule is a host change made on the premise that it was the blocker, so it
+    // must not be left invisible. It is deliberately NOT reverted for us: a failure
+    // that changed shape means the rule did something, and it may well be needed
+    // once the real cause is fixed.
+    chalk.dim(`
+${INDENT}The rule is in place; to undo it:
+`) + hostFirewallRuleRemoval(firewall, cidrs, channel.port).split("\n").map((l) => `${INDENT}  ${chalk.cyan(l)}`).join("\n") + "\n" + blockedTail()
+  );
+  return { status: "blocked", code: again.code, rule };
+}
+
+export {
+  checkHostChannel,
+  verifyHostChannel
+};

package/dist/{chunk-EP2TNALB.js → chunk-XVOBL7BC.js}

@@ -3,10 +3,11 @@
 import { createRequire as __ospCreateRequire } from "node:module";
 const require = __ospCreateRequire(import.meta.url);
 import {
+  COMPONENT_CHECKS,
   COMPONENT_INSTALLERS,
   checkAll,
   checkComponents
-} from "./chunk-GUQ3QCJ7.js";
+} from "./chunk-7334NSJL.js";
 
 // ../../packages/adapters/src/system/state.ts
 var DEFAULT_STATE_PATH = "/etc/openship/setup-state.json";
@@ -69,6 +70,8 @@ var SystemManager = class {
   assumeInstalled;
   /** In-memory cache to avoid even reading from disk/DB on hot paths. */
   cachedState = null;
+  /** In-flight background re-verification, if any (see kickBackgroundVerify). */
+  verifyInFlight = null;
   constructor(mode, opts) {
     this.mode = mode;
     this.executor = opts.executor;
@@ -86,18 +89,16 @@ var SystemManager = class {
    * Returns false if:
    *   - No cached state (first boot)
    *   - Cached state says setupComplete = false
-   *   - Cache is stale (> 24h since last verification)
+   *
+   * A stale cache (> 24h) still answers true, with a re-verification kicked behind
+   * the call — this must never block.
    *
    * Use this on hot paths (every request). It's essentially free.
    */
   async isReady() {
     const state = await this.loadState();
     if (!state?.setupComplete) return false;
-    if (this.isStale(state)) {
-      this.verify().catch(() => {
-      });
-      return true;
-    }
+    if (this.isStale(state)) this.kickBackgroundVerify();
     return true;
   }
   /**
@@ -145,6 +146,7 @@ var SystemManager = class {
         (name) => state.components[name]?.healthy === true
       );
       if (allPresent) {
+        if (this.isStale(state)) this.kickBackgroundVerify();
         return { feature, ready: true, missing: [], message: `${feature} is ready` };
       }
     }
@@ -295,6 +297,21 @@ var SystemManager = class {
     this.cachedState = await this.stateStore.get();
     return this.cachedState;
   }
+  /**
+   * Run the staleness re-verification behind the caller — one at a time.
+   *
+   * The dedup is the point: a single deploy gates several features in a row, and
+   * every request calls isReady(), so an un-guarded kick would stack one full
+   * checkAll per call — each fanning 4 concurrent probes onto the same ssh
+   * connection, against sshd's MaxSessions (see mapWithConcurrency in checks.ts).
+   */
+  kickBackgroundVerify() {
+    if (this.verifyInFlight) return;
+    this.verifyInFlight = this.verify().catch(() => {
+    }).finally(() => {
+      this.verifyInFlight = null;
+    });
+  }
   isStale(state) {
     if (!state.lastVerifiedAt) return true;
     const age = Date.now() - new Date(state.lastVerifiedAt).getTime();
@@ -315,7 +332,13 @@ var SystemManager = class {
       (name) => existing.components[name]?.installed
     );
     existing.setupComplete = allRequired;
-    existing.lastVerifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const checked = new Set(components.map((c) => c.name));
+    const coveredAll = this.required.every(
+      (name) => checked.has(name) || !COMPONENT_CHECKS[name]
+    );
+    if (coveredAll) {
+      existing.lastVerifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
     existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.cachedState = existing;
     await this.stateStore.set(existing);

package/dist/cloud-3DODOWTR.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  CloudRuntime,
+  HostBuildForbiddenError,
+  PAGE_CONTAINER_PREFIX,
+  isHostBuildForbiddenError,
+  provisionCloudWorkspace
+} from "./chunk-3ZAGC5NT.js";
+import "./chunk-7334NSJL.js";
+import "./chunk-VLQ3UIVO.js";
+import "./chunk-I3DPMTSF.js";
+import "./chunk-LFCSC4IU.js";
+import "./chunk-MSZUCNPV.js";
+import "./chunk-TM2IQPYU.js";
+import "./chunk-VHMOQL5Y.js";
+import "./chunk-5OUWIPOB.js";
+import "./chunk-6FH4AXVY.js";
+import "./chunk-RFWJE7ZN.js";
+import "./chunk-WE7BXW6L.js";
+import "./chunk-A7EWM2KA.js";
+import "./chunk-PZRRL5PC.js";
+import "./chunk-EZPPTWJQ.js";
+import "./chunk-WFRXYWK2.js";
+import "./chunk-ZFJXPCQP.js";
+import "./chunk-LEYSL46B.js";
+import "./chunk-PXKCZB2I.js";
+export {
+  CloudRuntime,
+  HostBuildForbiddenError,
+  PAGE_CONTAINER_PREFIX,
+  isHostBuildForbiddenError,
+  provisionCloudWorkspace
+};

package/dist/{detect-ALF4GXRX.js → detect-P4CIQBRH.js}

@@ -20,9 +20,9 @@ import {
   sanitizeEdgeVhosts,
   sq,
   stopTargetsForStatus
-} from "./chunk-VZ2ZHPS2.js";
-import "./chunk-3LDWWY7U.js";
-import "./chunk-OTLSJYAC.js";
+} from "./chunk-WE7BXW6L.js";
+import "./chunk-A7EWM2KA.js";
+import "./chunk-LEYSL46B.js";
 import "./chunk-PXKCZB2I.js";
 export {
   EDGE_CONTAINER_NAME,

package/dist/{docker-QECQJ5P4.js → docker-3K2NEBD6.js}

@@ -6,27 +6,34 @@ import {
   DockerRuntime,
   buildInContainerExecCmd,
   buildNetworkAliases,
+  gracefulStopForGrace,
   ownsBuiltImage,
   packBuildContext,
   parseContainerEventLine,
   parsePortBindings,
   resolveExecExitCode,
-  splitDockerFrames
-} from "./chunk-3FYIXVX5.js";
-import "./chunk-EMXI4UCU.js";
-import "./chunk-VDDMADOF.js";
-import "./chunk-6ODUBKUB.js";
-import "./chunk-ZCFVHA25.js";
-import "./chunk-OTLSJYAC.js";
+  splitDockerFrames,
+  toDockerHealthcheck,
+  toStopConfig
+} from "./chunk-VDESJSG6.js";
+import "./chunk-LFCSC4IU.js";
+import "./chunk-TM2IQPYU.js";
+import "./chunk-5OUWIPOB.js";
+import "./chunk-WFRXYWK2.js";
+import "./chunk-ZFJXPCQP.js";
+import "./chunk-LEYSL46B.js";
 import "./chunk-PXKCZB2I.js";
 export {
   DockerRuntime,
   buildInContainerExecCmd,
   buildNetworkAliases,
+  gracefulStopForGrace,
   ownsBuiltImage,
   packBuildContext,
   parseContainerEventLine,
   parsePortBindings,
   resolveExecExitCode,
-  splitDockerFrames
+  splitDockerFrames,
+  toDockerHealthcheck,
+  toStopConfig
 };

package/dist/{docker-edge-executor-62N64MGS.js → docker-edge-executor-YZZ6P7IC.js}

@@ -4,13 +4,13 @@ import { createRequire as __ospCreateRequire } from "node:module";
 const require = __ospCreateRequire(import.meta.url);
 import {
   DockerEdgeExecutor
-} from "./chunk-TWJCLD4W.js";
-import "./chunk-6FH4AXVY.js";
+} from "./chunk-6JELW75A.js";
 import "./chunk-I3DPMTSF.js";
-import "./chunk-VZ2ZHPS2.js";
-import "./chunk-3LDWWY7U.js";
+import "./chunk-6FH4AXVY.js";
+import "./chunk-WE7BXW6L.js";
+import "./chunk-A7EWM2KA.js";
 import "./chunk-ZFJXPCQP.js";
-import "./chunk-OTLSJYAC.js";
+import "./chunk-LEYSL46B.js";
 import "./chunk-PXKCZB2I.js";
 export {
   DockerEdgeExecutor

package/dist/{edge-import-CQWHN2Q3.js → edge-import-MCJNVTZ2.js}

@@ -6,40 +6,43 @@ import {
   importMigratedSites,
   waitForApiHealth,
   waitForEdgeRunning
-} from "./chunk-VE2YOK4I.js";
+} from "./chunk-6HOA5JT7.js";
+import "./chunk-QLX7NBEA.js";
+import "./chunk-QWHBRY2K.js";
+import "./chunk-ELGRMZOW.js";
+import "./chunk-ONKEYSMY.js";
 import "./chunk-XZYFZ6A5.js";
 import "./chunk-PDW4L3NV.js";
-import "./chunk-QWHBRY2K.js";
 import "./chunk-DOD2BXHQ.js";
 import "./chunk-42WQABXM.js";
 import "./chunk-DRK3MEDS.js";
 import "./chunk-3NQQXMDR.js";
-import "./chunk-TWJCLD4W.js";
-import "./chunk-PSZSKEPA.js";
+import "./chunk-ZWLDLTJP.js";
+import "./chunk-6JELW75A.js";
+import "./chunk-3ZAGC5NT.js";
 import "./chunk-WNWQBB7F.js";
 import "./chunk-2GWYYHOR.js";
 import "./chunk-RXQBD4ZY.js";
-import "./chunk-EP2TNALB.js";
-import "./chunk-GUQ3QCJ7.js";
-import "./chunk-ONKEYSMY.js";
-import "./chunk-ZWLDLTJP.js";
-import "./chunk-3FYIXVX5.js";
-import "./chunk-EMXI4UCU.js";
-import "./chunk-IXM5245F.js";
-import "./chunk-JIMUYEKN.js";
-import "./chunk-IW2UKBVF.js";
-import "./chunk-VDDMADOF.js";
-import "./chunk-B3CE2OMR.js";
-import "./chunk-6ODUBKUB.js";
-import "./chunk-ZCFVHA25.js";
-import "./chunk-6FH4AXVY.js";
-import "./chunk-QEH4QUBX.js";
+import "./chunk-XVOBL7BC.js";
+import "./chunk-7334NSJL.js";
+import "./chunk-VLQ3UIVO.js";
 import "./chunk-I3DPMTSF.js";
-import "./chunk-VZ2ZHPS2.js";
-import "./chunk-3LDWWY7U.js";
-import "./chunk-OGY63DGD.js";
+import "./chunk-VDESJSG6.js";
+import "./chunk-LFCSC4IU.js";
+import "./chunk-GRTXMUHA.js";
+import "./chunk-MSZUCNPV.js";
+import "./chunk-TM2IQPYU.js";
+import "./chunk-VHMOQL5Y.js";
+import "./chunk-5OUWIPOB.js";
+import "./chunk-6FH4AXVY.js";
+import "./chunk-RFWJE7ZN.js";
+import "./chunk-WE7BXW6L.js";
+import "./chunk-A7EWM2KA.js";
+import "./chunk-PZRRL5PC.js";
+import "./chunk-EZPPTWJQ.js";
+import "./chunk-WFRXYWK2.js";
 import "./chunk-ZFJXPCQP.js";
-import "./chunk-OTLSJYAC.js";
+import "./chunk-LEYSL46B.js";
 import "./chunk-PXKCZB2I.js";
 export {
   importMigratedSites,

package/dist/edge-preflight-ES6FH4JK.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  completeHostEdge,
+  confirmEdgeAction,
+  diagnoseEdge,
+  markStoppedProxyImported,
+  planAndApplyHostEdge,
+  previewHostEdge,
+  remediateUnreachableStaticRoots,
+  renderEdgeConflict,
+  repairEdgeConflict,
+  rollbackHostEdge
+} from "./chunk-HPXP6LXZ.js";
+import "./chunk-ELGRMZOW.js";
+import "./chunk-7334NSJL.js";
+import "./chunk-VLQ3UIVO.js";
+import "./chunk-I3DPMTSF.js";
+import "./chunk-6FH4AXVY.js";
+import "./chunk-RFWJE7ZN.js";
+import "./chunk-WE7BXW6L.js";
+import "./chunk-A7EWM2KA.js";
+import "./chunk-PZRRL5PC.js";
+import "./chunk-EZPPTWJQ.js";
+import "./chunk-WFRXYWK2.js";
+import "./chunk-ZFJXPCQP.js";
+import "./chunk-LEYSL46B.js";
+import "./chunk-PXKCZB2I.js";
+export {
+  completeHostEdge,
+  confirmEdgeAction,
+  diagnoseEdge,
+  markStoppedProxyImported,
+  planAndApplyHostEdge,
+  previewHostEdge,
+  remediateUnreachableStaticRoots,
+  renderEdgeConflict,
+  repairEdgeConflict,
+  rollbackHostEdge
+};

package/dist/{ensure-container-edge-MJVXJQG5.js → ensure-container-edge-YPITNH45.js}

@@ -10,16 +10,17 @@ import {
   resolveEdgeImage,
   setDefaultEdgeImage,
   verifyEdgeServing
-} from "./chunk-GUQ3QCJ7.js";
-import "./chunk-IW2UKBVF.js";
-import "./chunk-ZCFVHA25.js";
-import "./chunk-QEH4QUBX.js";
+} from "./chunk-7334NSJL.js";
+import "./chunk-VLQ3UIVO.js";
 import "./chunk-I3DPMTSF.js";
-import "./chunk-VZ2ZHPS2.js";
-import "./chunk-3LDWWY7U.js";
-import "./chunk-OGY63DGD.js";
+import "./chunk-RFWJE7ZN.js";
+import "./chunk-WE7BXW6L.js";
+import "./chunk-A7EWM2KA.js";
+import "./chunk-PZRRL5PC.js";
+import "./chunk-EZPPTWJQ.js";
+import "./chunk-WFRXYWK2.js";
 import "./chunk-ZFJXPCQP.js";
-import "./chunk-OTLSJYAC.js";
+import "./chunk-LEYSL46B.js";
 import "./chunk-PXKCZB2I.js";
 export {
   buildEdgeRunCommand,