@absolutejs/deploy 0.16.1 → 0.17.0

package/README.md

@@ -55,6 +55,46 @@ address data, list/get/provision/terminate, and regional placement. Application
 deployment, draining, migration, and edge cutover remain higher-level
 orchestration concerns.
 
+## Global edge ingress (0.17.0)
+
+`EdgeIngressProvider` is the shared lifecycle for a public global ingress over
+regional edge pools. It normalizes the listener, backend health check, ordered
+regional failover priority, provider resource references, addresses, state,
+and idempotent removal. Provider resource construction stays here instead of
+leaking DigitalOcean or GCP APIs into a control plane.
+
+```ts
+import { createDigitalOceanIngressProvider } from '@absolutejs/deploy/digitalocean-ingress';
+
+const ingress = createDigitalOceanIngressProvider({
+  token: process.env.DIGITALOCEAN_TOKEN!,
+});
+
+await ingress.reconcileIngress({
+  name: 'absolutejs-edge',
+  idempotencyKey: crypto.randomUUID(),
+  backends: [
+    { region: 'nyc3', resourceId: 'regional-lb-east', priority: 1 },
+    { region: 'sfo3', resourceId: 'regional-lb-west', priority: 2 },
+  ],
+  listener: {
+    port: 443,
+    protocol: 'https',
+    targetPort: 443,
+    tlsPassthrough: true,
+  },
+  healthCheck: { protocol: 'tcp', port: 443 },
+});
+```
+
+DigitalOcean uses a Global Load Balancer whose backends are regional load
+balancer UUIDs. GCP uses a global external TCP proxy whose backends are
+provider-native instance-group or NEG self-links; the adapter also owns its
+health check, backend service, proxy, Premium address, and forwarding rule.
+Both preserve TLS termination at the regional edge and wait for provider
+operations before advancing dependent resources. Creating an adapter does not
+provision anything; only `reconcileIngress()` mutates provider state.
+
 ```ts
 import {
   createDeployer,

package/dist/digitaloceanIngress.d.ts

@@ -0,0 +1,9 @@
+/** DigitalOcean Global Load Balancer adapter for regional edge pools. */
+import { type DigitalOceanClientLike } from "./digitalocean";
+import { type EdgeIngressProvider } from "./edgeIngress";
+export type DigitalOceanIngressProviderOptions = {
+    client?: DigitalOceanClientLike;
+    networkStack?: "IPV4" | "DUALSTACK";
+    token?: string;
+};
+export declare const createDigitalOceanIngressProvider: (options: DigitalOceanIngressProviderOptions) => EdgeIngressProvider;

package/dist/digitaloceanIngress.js

@@ -0,0 +1,552 @@
+// @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/edgeIngress.ts
+var validPort = (port) => Number.isInteger(port) && port >= 1 && port <= 65535;
+
+class EdgeIngressValidationError extends Error {
+}
+var validateEdgeIngressSpec = (spec) => {
+  if (!/^[a-z]([-a-z0-9]*[a-z0-9])?$/.test(spec.name))
+    throw new EdgeIngressValidationError("Invalid edge ingress name");
+  if (spec.backends.length === 0)
+    throw new EdgeIngressValidationError("Edge ingress requires at least one regional backend");
+  if (!validPort(spec.listener.port) || !validPort(spec.listener.targetPort))
+    throw new EdgeIngressValidationError("Invalid edge ingress listener port");
+  if (!validPort(spec.healthCheck.port))
+    throw new EdgeIngressValidationError("Invalid edge ingress health port");
+  const resources = new Set;
+  for (const backend of spec.backends) {
+    if (!backend.resourceId || !backend.region)
+      throw new EdgeIngressValidationError("Invalid edge ingress backend");
+    if (resources.has(backend.resourceId))
+      throw new EdgeIngressValidationError("Duplicate edge ingress backend");
+    resources.add(backend.resourceId);
+  }
+  if (spec.listener.tlsPassthrough && spec.listener.protocol !== "https" && spec.listener.protocol !== "tcp")
+    throw new EdgeIngressValidationError("TLS passthrough requires an HTTPS or TCP listener");
+  return spec;
+};
+var normalizedEdgeIngressBackends = (backends) => [...backends].sort((left, right) => (left.priority ?? Number.MAX_SAFE_INTEGER) - (right.priority ?? Number.MAX_SAFE_INTEGER) || left.region.localeCompare(right.region) || left.resourceId.localeCompare(right.resourceId));
+
+// 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/digitaloceanIngress.ts
+var resolveClient2 = (options) => {
+  if (options.client)
+    return options.client;
+  if (options.token)
+    return createDigitalOceanClient(options.token);
+  throw new Error("[deploy/digitalocean-ingress] either `token` or `client` must be provided");
+};
+var normalize = (loadBalancer, backends = []) => ({
+  addresses: [loadBalancer.ip, loadBalancer.ipv6].filter((address) => Boolean(address)),
+  backends: normalizedEdgeIngressBackends(backends),
+  id: `digitalocean:${loadBalancer.id}`,
+  name: loadBalancer.name,
+  provider: "digitalocean",
+  state: loadBalancer.status === "active" ? "ready" : loadBalancer.status === "errored" ? "degraded" : "provisioning"
+});
+var createDigitalOceanIngressProvider = (options) => {
+  const client = resolveClient2(options);
+  const find = async (name) => {
+    const response = await client.request("GET", "/load_balancers");
+    const matches = response.load_balancers.filter((loadBalancer) => loadBalancer.name === name);
+    if (matches.length > 1)
+      throw new Error(`[deploy/digitalocean-ingress] multiple load balancers named ${name}`);
+    return matches[0] ?? null;
+  };
+  return {
+    capabilities: {
+      automaticHealthFailover: true,
+      global: true,
+      tlsPassthrough: true
+    },
+    getIngress: async (name) => {
+      const existing = await find(name);
+      return existing ? normalize(existing) : null;
+    },
+    name: "digitalocean",
+    reconcileIngress: async (spec) => {
+      validateEdgeIngressSpec(spec);
+      if (spec.listener.protocol === "tcp")
+        throw new Error("[deploy/digitalocean-ingress] Global Load Balancers require an HTTP-family listener");
+      const backends = normalizedEdgeIngressBackends(spec.backends);
+      const existing = await find(spec.name);
+      const body = {
+        forwarding_rules: [
+          {
+            entry_port: spec.listener.port,
+            entry_protocol: spec.listener.protocol,
+            target_port: spec.listener.targetPort,
+            target_protocol: spec.listener.protocol,
+            ...spec.listener.tlsPassthrough ? { tls_passthrough: true } : {}
+          }
+        ],
+        glb_settings: {
+          region_priorities: Object.fromEntries(backends.map((backend, index) => [
+            backend.region,
+            backend.priority ?? index + 1
+          ])),
+          target_load_balancer_ids: backends.map((backend) => backend.resourceId),
+          target_port: spec.listener.targetPort,
+          target_protocol: spec.listener.protocol
+        },
+        health_check: {
+          path: spec.healthCheck.path ?? "/healthz",
+          port: spec.healthCheck.port,
+          protocol: spec.healthCheck.protocol
+        },
+        name: spec.name,
+        network_stack: options.networkStack ?? "DUALSTACK",
+        type: "GLOBAL"
+      };
+      const response = existing ? await client.request("PUT", `/load_balancers/${encodeURIComponent(existing.id)}`, body) : await client.request("POST", "/load_balancers", body);
+      return normalize(response.load_balancer, backends);
+    },
+    removeIngress: async (name) => {
+      const existing = await find(name);
+      if (existing)
+        await client.request("DELETE", `/load_balancers/${encodeURIComponent(existing.id)}`);
+    }
+  };
+};
+export {
+  createDigitalOceanIngressProvider
+};
+
+//# debugId=C41516659DD2857764756E2164756E21
+//# sourceMappingURL=digitaloceanIngress.js.map