@absolutejs/deploy 0.20.0 → 0.21.0

package/dist/digitaloceanEphemeralInfrastructure.js

@@ -0,0 +1,610 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
+// src/targets.ts
+import { mkdir } from "fs/promises";
+import { join } from "path";
+var decodeChunks = async (reader, onLine) => {
+  if (!reader)
+    return "";
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let collected = "";
+  const stream = reader.getReader();
+  try {
+    while (true) {
+      const { done, value } = await stream.read();
+      if (done)
+        break;
+      const chunk = decoder.decode(value, { stream: true });
+      collected += chunk;
+      if (!onLine)
+        continue;
+      buffer += chunk;
+      let newline = buffer.indexOf(`
+`);
+      while (newline !== -1) {
+        const line = buffer.slice(0, newline).replace(/\r$/, "");
+        if (line.length > 0)
+          onLine(line);
+        buffer = buffer.slice(newline + 1);
+        newline = buffer.indexOf(`
+`);
+      }
+    }
+    const tail = decoder.decode();
+    collected += tail;
+    if (onLine && (buffer + tail).length > 0)
+      onLine((buffer + tail).replace(/\r$/, ""));
+  } finally {
+    stream.releaseLock();
+  }
+  return collected;
+};
+var runSpawn = async (argv, options) => {
+  const proc = Bun.spawn(argv, {
+    cwd: options.cwd,
+    env: options.env,
+    stderr: "pipe",
+    stdin: options.stdin === undefined ? "ignore" : "pipe",
+    stdout: "pipe"
+  });
+  if (options.stdin !== undefined && proc.stdin) {
+    const sink = proc.stdin;
+    const wrote = sink.write(options.stdin);
+    if (wrote && typeof wrote.then === "function") {
+      await wrote;
+    }
+    const ended = sink.end();
+    if (ended && typeof ended.then === "function") {
+      await ended;
+    }
+  }
+  const timeout = options.timeoutMs ?? 600000;
+  let timer;
+  if (timeout > 0) {
+    timer = setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {}
+    }, timeout);
+  }
+  const stdoutPromise = decodeChunks(proc.stdout, options.onLog ? (line) => options.onLog(line, "stdout") : undefined);
+  const stderrPromise = decodeChunks(proc.stderr, options.onLog ? (line) => options.onLog(line, "stderr") : undefined);
+  const [stdout, stderr, exitCode] = await Promise.all([
+    stdoutPromise,
+    stderrPromise,
+    proc.exited
+  ]);
+  if (timer)
+    clearTimeout(timer);
+  return { exitCode: exitCode ?? -1, stderr, stdout };
+};
+var localTarget = (options) => {
+  const baseEnv = { ...options.env };
+  const ensureRoot = async () => {
+    await mkdir(options.root, { recursive: true });
+  };
+  return {
+    description: `local ${options.root}`,
+    exec: async (cmd, opts) => {
+      await ensureRoot();
+      return runSpawn(["sh", "-c", cmd], {
+        cwd: opts?.cwd ?? options.root,
+        env: { ...process.env, ...baseEnv, ...opts?.env ?? {} },
+        onLog: opts?.onLog,
+        stdin: opts?.stdin,
+        timeoutMs: opts?.timeoutMs
+      });
+    },
+    upload: async (localPath, remotePath, opts) => {
+      await ensureRoot();
+      const dest = remotePath.startsWith("/") ? remotePath : join(options.root, remotePath);
+      const argv = ["rsync", "-a"];
+      if (opts?.deleteOrphans)
+        argv.push("--delete");
+      for (const pattern of opts?.exclude ?? [])
+        argv.push("--exclude", pattern);
+      argv.push(localPath, dest);
+      const result = await runSpawn(argv, { timeoutMs: 600000 });
+      if (result.exitCode !== 0) {
+        throw new Error(`local upload failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+      }
+    }
+  };
+};
+var sshTargetString = (options) => {
+  const user = options.user ?? "root";
+  return `${user}@${options.host}`;
+};
+var sshBaseFlags = (options) => {
+  const flags = [];
+  if (options.port !== undefined && options.port !== 22)
+    flags.push("-p", String(options.port));
+  if (options.identity !== undefined)
+    flags.push("-i", options.identity);
+  flags.push("-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=accept-new");
+  for (const flag of options.sshFlags ?? [])
+    flags.push(flag);
+  return flags;
+};
+var shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+var buildRemoteCmd = (cmd, opts) => {
+  const env = opts?.env;
+  const envPrefix = env ? Object.entries(env).map(([k, v]) => `${k}=${shellQuote(v)}`).join(" ") + " " : "";
+  if (opts?.cwd) {
+    return `cd ${shellQuote(opts.cwd)} && ${envPrefix}${cmd}`;
+  }
+  return `${envPrefix}${cmd}`;
+};
+var sshTarget = (options) => {
+  const remote = sshTargetString(options);
+  const useRsync = options.rsync ?? true;
+  return {
+    description: `ssh ${remote}${options.port && options.port !== 22 ? `:${options.port}` : ""}`,
+    exec: async (cmd, opts) => {
+      const argv = ["ssh", ...sshBaseFlags(options)];
+      for (const name of options.forwardEnv ?? [])
+        argv.push("-o", `SendEnv=${name}`);
+      argv.push(remote, buildRemoteCmd(cmd, opts));
+      return runSpawn(argv, {
+        onLog: opts?.onLog,
+        stdin: opts?.stdin,
+        timeoutMs: opts?.timeoutMs
+      });
+    },
+    upload: async (localPath, remotePath, opts) => {
+      if (useRsync) {
+        const sshCmd = ["ssh", ...sshBaseFlags(options)].map((part) => part.includes(" ") ? `'${part}'` : part).join(" ");
+        const argv2 = ["rsync", "-az", "-e", sshCmd];
+        if (opts?.deleteOrphans)
+          argv2.push("--delete");
+        for (const pattern of opts?.exclude ?? [])
+          argv2.push("--exclude", pattern);
+        argv2.push(localPath, `${remote}:${remotePath}`);
+        const result2 = await runSpawn(argv2, { timeoutMs: 600000 });
+        if (result2.exitCode !== 0) {
+          throw new Error(`rsync upload failed (exit ${result2.exitCode}): ${result2.stderr || result2.stdout}`);
+        }
+        return;
+      }
+      const argv = ["scp", "-r", ...sshBaseFlags(options), localPath, `${remote}:${remotePath}`];
+      const result = await runSpawn(argv, { timeoutMs: 600000 });
+      if (result.exitCode !== 0) {
+        throw new Error(`scp upload failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+      }
+    }
+  };
+};
+
+// src/cloudTarget.ts
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var defaultProbeSsh = async (host, port) => {
+  const PROBE_TIMEOUT_MS = 2000;
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve(value);
+    };
+    const timer = setTimeout(() => settle(false), PROBE_TIMEOUT_MS);
+    Bun.connect({
+      hostname: host,
+      port,
+      socket: {
+        data: () => {},
+        error: () => {
+          clearTimeout(timer);
+          settle(false);
+        },
+        open: (socket) => {
+          clearTimeout(timer);
+          socket.end();
+          settle(true);
+        }
+      }
+    }).catch(() => {
+      clearTimeout(timer);
+      settle(false);
+    });
+  });
+};
+var createCloudTarget = async (hooks, options) => {
+  const log = options.onLog ?? (() => {});
+  const probeSsh = options.probeSsh ?? defaultProbeSsh;
+  const sleep = options.sleep ?? defaultSleep;
+  const now = options.now ?? Date.now;
+  const pollMs = options.pollIntervalMs ?? 5000;
+  const provisionTimeout = options.provisionTimeoutMs ?? 5 * 60000;
+  const sshTimeout = options.sshReadinessTimeoutMs ?? 2 * 60000;
+  const port = options.port ?? 22;
+  const prefix = options.logPrefix;
+  const noun = options.entityWord;
+  const existing = await hooks.findByName(options.name);
+  let current;
+  if (existing === undefined) {
+    log(`${prefix} creating ${noun} "${options.name}" in ${options.region}`);
+    current = await hooks.create();
+  } else {
+    log(`${prefix} reusing ${noun} "${options.name}" (id ${hooks.getId(existing)}, status ${hooks.getStatus(existing)})`);
+    current = existing;
+  }
+  const provisionStart = now();
+  let ipv4 = hooks.getIpv4(current);
+  while (!hooks.isReady(current) || ipv4 === undefined) {
+    if (now() - provisionStart > provisionTimeout) {
+      throw new Error(`${prefix} provision timeout after ${provisionTimeout}ms \u2014 ${noun} ${hooks.getId(current)} status "${hooks.getStatus(current)}", ipv4 ${ipv4 ?? "(unassigned)"}`);
+    }
+    await sleep(pollMs);
+    current = await hooks.fetch(hooks.getId(current));
+    ipv4 = hooks.getIpv4(current);
+    log(`${prefix} poll: status=${hooks.getStatus(current)} ipv4=${ipv4 ?? "(none yet)"}`);
+  }
+  log(`${prefix} ${noun} ready at ${ipv4}`);
+  const sshStart = now();
+  while (!await probeSsh(ipv4, port)) {
+    if (now() - sshStart > sshTimeout) {
+      throw new Error(`${prefix} SSH readiness timeout after ${sshTimeout}ms \u2014 ${ipv4}:${port} did not accept connections`);
+    }
+    await sleep(pollMs);
+    log(`${prefix} waiting on ssh ${ipv4}:${port}`);
+  }
+  log(`${prefix} ssh ready at ${ipv4}:${port}`);
+  const ssh = sshTarget({
+    host: ipv4,
+    ...options.user !== undefined ? { user: options.user } : {},
+    ...options.identity !== undefined ? { identity: options.identity } : {},
+    ...options.port !== undefined ? { port: options.port } : {}
+  });
+  const id = hooks.getId(current);
+  const resolvedIpv4 = ipv4;
+  return {
+    description: options.describeTarget(ssh.description),
+    destroy: () => hooks.destroy(id).then(() => {
+      log(`${prefix} destroyed ${noun} ${id}`);
+    }),
+    exec: ssh.exec,
+    id,
+    ipv4: resolvedIpv4,
+    upload: ssh.upload,
+    ...ssh.close !== undefined ? { close: ssh.close } : {}
+  };
+};
+
+// src/digitalocean.ts
+var DO_API_BASE = "https://api.digitalocean.com/v2";
+
+class DigitalOceanError extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "DigitalOceanError";
+    this.status = status;
+    this.body = body;
+  }
+}
+var createDigitalOceanClient = (token, options = {}) => {
+  const base = options.baseUrl ?? DO_API_BASE;
+  const f = options.fetch ?? fetch;
+  return {
+    request: async (method, path, body) => {
+      const init = {
+        headers: {
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json"
+        },
+        method
+      };
+      if (body !== undefined)
+        init.body = JSON.stringify(body);
+      const response = await f(`${base}${path}`, init);
+      if (response.status === 204)
+        return;
+      const text = await response.text();
+      const parsed = text.length > 0 ? JSON.parse(text) : undefined;
+      if (!response.ok) {
+        throw new DigitalOceanError(`DigitalOcean API ${method} ${path} failed: ${response.status} ${response.statusText}`, response.status, parsed);
+      }
+      return parsed;
+    }
+  };
+};
+var resolveClient = (options) => {
+  if (options.client !== undefined)
+    return options.client;
+  if (options.token !== undefined && options.token.length > 0) {
+    return createDigitalOceanClient(options.token);
+  }
+  throw new Error("[deploy/digitalocean] either `token` or `client` must be provided");
+};
+var publicIpv4 = (droplet) => droplet.networks.v4.find((net) => net.type === "public")?.ip_address;
+var findDigitalOceanDroplet = async (client, name) => {
+  const body = await client.request("GET", `/droplets?name=${encodeURIComponent(name)}`);
+  const matches = body.droplets.filter((droplet) => droplet.name === name);
+  if (matches.length === 0)
+    return;
+  if (matches.length > 1) {
+    throw new Error(`[deploy/digitalocean] multiple droplets named "${name}" (${matches.map((droplet) => droplet.id).join(", ")}). Resolve manually before adopting.`);
+  }
+  return matches[0];
+};
+var listDigitalOceanDroplets = async (options) => {
+  const client = resolveClient(options);
+  const path = options.tag !== undefined ? `/droplets?tag_name=${encodeURIComponent(options.tag)}` : "/droplets";
+  const body = await client.request("GET", path);
+  return body.droplets;
+};
+var destroyDigitalOceanDroplet = async (options) => {
+  const client = resolveClient(options);
+  try {
+    await client.request("DELETE", `/droplets/${options.id}`);
+  } catch (error) {
+    if (error instanceof DigitalOceanError && error.status === 404) {
+      return;
+    }
+    throw error;
+  }
+};
+var digitalOceanTarget = async (options) => {
+  const client = resolveClient(options);
+  const hooks = {
+    create: async () => {
+      const created = await client.request("POST", "/droplets", {
+        name: options.name,
+        region: options.region,
+        size: options.size,
+        image: options.image,
+        ssh_keys: [...options.sshKeys],
+        ...options.tags !== undefined ? { tags: [...options.tags] } : {},
+        ...options.userData !== undefined ? { user_data: options.userData } : {},
+        ...options.vpcUuid !== undefined ? { vpc_uuid: options.vpcUuid } : {},
+        ...options.ipv6 === true ? { ipv6: true } : {},
+        ...options.monitoring === true ? { monitoring: true } : {}
+      });
+      return created.droplet;
+    },
+    destroy: (id) => destroyDigitalOceanDroplet({ client, id }),
+    fetch: async (id) => {
+      const refreshed = await client.request("GET", `/droplets/${id}`);
+      return refreshed.droplet;
+    },
+    findByName: (name) => findDigitalOceanDroplet(client, name),
+    getId: (droplet) => droplet.id,
+    getIpv4: publicIpv4,
+    getStatus: (droplet) => droplet.status,
+    isReady: (droplet) => droplet.status === "active"
+  };
+  const result = await createCloudTarget(hooks, {
+    describeTarget: (sshDescription) => `digitalocean droplet "${options.name}" (${sshDescription})`,
+    entityWord: "droplet",
+    logPrefix: "[do]",
+    name: options.name,
+    region: options.region,
+    ...options.user !== undefined ? { user: options.user } : {},
+    ...options.identity !== undefined ? { identity: options.identity } : {},
+    ...options.port !== undefined ? { port: options.port } : {},
+    ...options.provisionTimeoutMs !== undefined ? { provisionTimeoutMs: options.provisionTimeoutMs } : {},
+    ...options.sshReadinessTimeoutMs !== undefined ? { sshReadinessTimeoutMs: options.sshReadinessTimeoutMs } : {},
+    ...options.pollIntervalMs !== undefined ? { pollIntervalMs: options.pollIntervalMs } : {},
+    ...options.onLog !== undefined ? { onLog: options.onLog } : {},
+    ...options.probeSsh !== undefined ? { probeSsh: options.probeSsh } : {},
+    ...options.sleep !== undefined ? { sleep: options.sleep } : {},
+    ...options.now !== undefined ? { now: options.now } : {}
+  });
+  return {
+    description: result.description,
+    destroy: result.destroy,
+    dropletId: result.id,
+    exec: result.exec,
+    ipv4: result.ipv4,
+    upload: result.upload,
+    ...result.close !== undefined ? { close: result.close } : {}
+  };
+};
+
+// src/digitaloceanEphemeralInfrastructure.ts
+var DEFAULT_CLEANUP_POLL_INTERVAL_MS = 2000;
+var DEFAULT_CLEANUP_TIMEOUT_MS = 120000;
+var MINIMUM_VOLUME_GIB = 1;
+var SAFE_RESOURCE_NAME = /^[a-z0-9][a-z0-9-]{0,62}$/;
+var resolveClient2 = (options) => {
+  if (options.client)
+    return options.client;
+  if (options.token)
+    return createDigitalOceanClient(options.token);
+  throw new Error("[deploy/digitalocean-ephemeral] either `token` or `client` must be provided");
+};
+var parseDropletId = (id) => {
+  const match = /^digitalocean:droplet:([1-9][0-9]*)$/.exec(id);
+  if (!match?.[1])
+    throw new Error("[deploy/digitalocean-ephemeral] invalid droplet id");
+  return Number(match[1]);
+};
+var parseVolumeId = (id) => {
+  const match = /^digitalocean:volume:([0-9a-f-]{36})$/.exec(id);
+  if (!match?.[1])
+    throw new Error("[deploy/digitalocean-ephemeral] invalid volume id");
+  return match[1];
+};
+var privateIpv4 = (droplet) => droplet.networks.v4.find(({ type }) => type === "private")?.ip_address;
+var publicIpv42 = (droplet) => droplet.networks.v4.find(({ type }) => type === "public")?.ip_address;
+var normalize = (droplet, volume) => {
+  const privateAddress = privateIpv4(droplet);
+  const publicAddress = publicIpv42(droplet);
+  return {
+    node: {
+      id: `digitalocean:droplet:${droplet.id}`,
+      label: droplet.name,
+      provider: "digitalocean",
+      region: droplet.region?.slug ?? "unknown",
+      state: droplet.status === "active" ? "ready" : droplet.status === "new" ? "pending" : "terminated",
+      ...privateAddress ? { privateIpv4: privateAddress } : {},
+      ...publicAddress ? { publicIpv4: publicAddress } : {}
+    },
+    volume: {
+      encryptedAtRest: true,
+      id: `digitalocean:volume:${volume.id}`,
+      label: volume.name,
+      region: volume.region.slug,
+      sizeGiB: volume.size_gigabytes
+    }
+  };
+};
+var findVolume = async (client, name) => {
+  const result = await client.request("GET", `/volumes?name=${encodeURIComponent(name)}`);
+  const matches = result.volumes.filter((volume) => volume.name === name);
+  if (matches.length > 1)
+    throw new Error(`[deploy/digitalocean-ephemeral] multiple volumes named "${name}"`);
+  return matches[0];
+};
+var absent = async (operation) => {
+  try {
+    await operation();
+    return false;
+  } catch (error) {
+    if (error instanceof DigitalOceanError && error.status === 404)
+      return true;
+    throw error;
+  }
+};
+var validateRequest = (request) => {
+  if (!SAFE_RESOURCE_NAME.test(request.name))
+    throw new Error("[deploy/digitalocean-ephemeral] invalid resource name");
+  if (!request.idempotencyKey)
+    throw new Error("[deploy/digitalocean-ephemeral] idempotency key is required");
+  if (!request.vpcUuid)
+    throw new Error("[deploy/digitalocean-ephemeral] VPC UUID is required");
+  if (request.sshKeys.length === 0)
+    throw new Error("[deploy/digitalocean-ephemeral] at least one SSH key is required");
+  if (!Number.isSafeInteger(request.volumeGiB) || request.volumeGiB < MINIMUM_VOLUME_GIB)
+    throw new Error("[deploy/digitalocean-ephemeral] invalid volume size");
+};
+var createDigitalOceanEphemeralInfrastructureProvider = (options) => {
+  if (!options.tag)
+    throw new Error("[deploy/digitalocean-ephemeral] a resource tag is required");
+  const client = resolveClient2(options);
+  const sleep = options.sleep ?? ((milliseconds) => Bun.sleep(milliseconds));
+  const pollIntervalMs = options.cleanupPollIntervalMs ?? DEFAULT_CLEANUP_POLL_INTERVAL_MS;
+  const cleanupTimeoutMs = options.cleanupTimeoutMs ?? DEFAULT_CLEANUP_TIMEOUT_MS;
+  const inspectAbsence = async (resources) => {
+    const dropletId = parseDropletId(resources.node.id);
+    const volumeId = parseVolumeId(resources.volume.id);
+    const [dropletAbsent, volumeAbsent] = await Promise.all([
+      absent(() => client.request("GET", `/droplets/${dropletId}`)),
+      absent(() => client.request("GET", `/volumes/${volumeId}`))
+    ]);
+    return { dropletAbsent, volumeAbsent };
+  };
+  const waitUntil = async (predicate, label) => {
+    const deadline = Date.now() + cleanupTimeoutMs;
+    while (!await predicate()) {
+      if (Date.now() >= deadline)
+        throw new Error(`[deploy/digitalocean-ephemeral] timed out waiting for ${label}`);
+      await sleep(pollIntervalMs);
+    }
+  };
+  return {
+    cleanup: async (resources) => {
+      const dropletId = parseDropletId(resources.node.id);
+      const volumeId = parseVolumeId(resources.volume.id);
+      if (!(await inspectAbsence(resources)).dropletAbsent)
+        await client.request("DELETE", `/droplets/${dropletId}`);
+      await waitUntil(async () => (await inspectAbsence(resources)).dropletAbsent, "droplet deletion");
+      if (!(await inspectAbsence(resources)).volumeAbsent)
+        await client.request("DELETE", `/volumes/${volumeId}`);
+      await waitUntil(async () => (await inspectAbsence(resources)).volumeAbsent, "volume deletion");
+      return inspectAbsence(resources);
+    },
+    inspectAbsence,
+    name: "digitalocean",
+    provision: async (request) => {
+      validateRequest(request);
+      const volumeName = `${request.name}-checkpoint`;
+      let volume = await findVolume(client, volumeName);
+      const createdVolume = !volume;
+      if (!volume) {
+        const result = await client.request("POST", "/volumes", {
+          description: `Ephemeral ${request.name} checkpoint volume`,
+          filesystem_label: "criu-checkpoint",
+          filesystem_type: "ext4",
+          name: volumeName,
+          region: request.region,
+          size_gigabytes: request.volumeGiB,
+          tags: [options.tag]
+        });
+        volume = result.volume;
+      }
+      if (volume.region.slug !== request.region || volume.size_gigabytes !== request.volumeGiB)
+        throw new Error("[deploy/digitalocean-ephemeral] existing volume does not match the requested topology");
+      try {
+        let droplet = await findDigitalOceanDroplet(client, request.name);
+        if (!droplet) {
+          const result = await client.request("POST", "/droplets", {
+            backups: false,
+            image: request.image,
+            ipv6: false,
+            monitoring: true,
+            name: request.name,
+            region: request.region,
+            size: request.size,
+            ssh_keys: [...request.sshKeys],
+            tags: [options.tag],
+            user_data: request.userData,
+            volumes: [volume.id],
+            vpc_uuid: request.vpcUuid
+          });
+          droplet = result.droplet;
+        }
+        if (droplet.region?.slug !== request.region || droplet.size_slug && droplet.size_slug !== request.size)
+          throw new Error("[deploy/digitalocean-ephemeral] existing droplet does not match the requested topology");
+        if (volume.droplet_ids.length > 0 && !volume.droplet_ids.includes(droplet.id))
+          throw new Error("[deploy/digitalocean-ephemeral] checkpoint volume is attached to another droplet");
+        return normalize(droplet, volume);
+      } catch (error) {
+        if (createdVolume)
+          await client.request("DELETE", `/volumes/${volume.id}`);
+        throw error;
+      }
+    }
+  };
+};
+export {
+  createDigitalOceanEphemeralInfrastructureProvider
+};
+
+//# debugId=B8BFAC3CF04D69D764756E2164756E21
+//# sourceMappingURL=digitaloceanEphemeralInfrastructure.js.map