@stacksjs/ts-cloud 0.7.104 → 0.7.108

package/dist/ui-src/src/topology.ts

@@ -0,0 +1,485 @@
+// ../../node_modules/@ts-charts/graph/dist/layered.js
+var Mj = { direction: "down", nodeWidth: 160, nodeHeight: 56, layerGap: 80, nodeGap: 28, padding: 24, iterations: 8, straightenPasses: 6 };
+function Nj(Q, W) {
+  let J = [], _ = new Map;
+  for (let H of Q)
+    _.set(H, []);
+  for (let H of W)
+    _.get(H.source)?.push(H);
+  let V = new Set, Z = new Set, G = new Set, T = (H) => {
+    V.add(H), Z.add(H);
+    for (let I of _.get(H) ?? [])
+      if (Z.has(I.target))
+        G.add(I);
+      else if (!V.has(I.target))
+        T(I.target);
+    Z.delete(H);
+  };
+  for (let H of Q)
+    if (!V.has(H))
+      T(H);
+  for (let H of W) {
+    let I = H.weight ?? 1;
+    if (G.has(H))
+      J.push({ source: H.target, target: H.source, weight: I, reversed: true });
+    else
+      J.push({ source: H.source, target: H.target, weight: I, reversed: false });
+  }
+  return J;
+}
+function Qj(Q, W) {
+  let J = new Map, _ = new Map, V = new Map, Z = new Map;
+  for (let H of Q)
+    _.set(H.id, []), V.set(H.id, []), Z.set(H.id, 0);
+  for (let H of W) {
+    if (H.source === H.target)
+      continue;
+    _.get(H.target)?.push(H.source), V.get(H.source)?.push(H.target), Z.set(H.target, (Z.get(H.target) ?? 0) + 1);
+  }
+  let G = [];
+  for (let H of Q)
+    if ((Z.get(H.id) ?? 0) === 0)
+      J.set(H.id, 0), G.push(H.id);
+  for (let H = 0;H < G.length; H++) {
+    let I = G[H];
+    for (let U of V.get(I) ?? []) {
+      J.set(U, Math.max(J.get(U) ?? 0, (J.get(I) ?? 0) + 1));
+      let L = (Z.get(U) ?? 0) - 1;
+      if (Z.set(U, L), L === 0)
+        G.push(U);
+    }
+  }
+  for (let H of Q)
+    if (!J.has(H.id))
+      J.set(H.id, 0);
+  for (let H of Q)
+    if (H.layer != null && Number.isFinite(H.layer))
+      J.set(H.id, H.layer);
+  let T = Math.min(...J.values());
+  if (T !== 0)
+    for (let [H, I] of J)
+      J.set(H, I - T);
+  return J;
+}
+function b(Q, W) {
+  let J = 0;
+  for (let _ = 0;_ + 1 < Q.length; _++) {
+    let V = new Map;
+    Q[_ + 1].forEach((G, T) => V.set(G, T));
+    let Z = [];
+    for (let G of Q[_])
+      for (let T of W.get(G) ?? []) {
+        let H = V.get(T);
+        if (H != null)
+          Z.push(H);
+      }
+    for (let G = 0;G < Z.length; G++)
+      for (let T = G + 1;T < Z.length; T++)
+        if (Z[G] > Z[T])
+          J++;
+  }
+  return J;
+}
+function s(Q) {
+  if (!Q.length)
+    return -1;
+  let W = [...Q].sort((Z, G) => Z - G), J = W.length >> 1;
+  if (W.length % 2 === 1)
+    return W[J];
+  if (W.length === 2)
+    return (W[0] + W[1]) / 2;
+  let _ = W[J - 1] - W[0], V = W[W.length - 1] - W[J];
+  return (W[J - 1] * V + W[J] * _) / (_ + V || 1);
+}
+function Tj(Q, W = {}) {
+  let J = { ...Mj, ...W }, _ = J.direction === "right" || J.direction === "left", V = new Map;
+  for (let j of Q.nodes)
+    V.set(j.id, j);
+  let Z = [...V.keys()], G = Q.edges.filter((j) => V.has(j.source) && V.has(j.target));
+  if (!Z.length)
+    return { nodes: [], edges: [], layers: [], width: J.padding * 2, height: J.padding * 2, crossings: 0 };
+  let T = Nj(Z, G), H = Qj(Q.nodes, T), I = new Map, U = (j) => _ ? j.width ?? J.nodeWidth : j.height ?? J.nodeHeight, L = (j) => _ ? j.height ?? J.nodeHeight : j.width ?? J.nodeWidth;
+  for (let j of Q.nodes)
+    I.set(j.id, { id: j.id, layer: H.get(j.id) ?? 0, order: 0, depth: U(j), breadth: L(j), pos: 0, dummy: false });
+  let A = [], P = [], z = "__bend";
+  while (Z.some((j) => j.startsWith(z)))
+    z = `_${z}`;
+  let d = 0;
+  for (let j of T) {
+    if (j.source === j.target)
+      continue;
+    let E = I.get(j.source), F = I.get(j.target), N = { source: j.source, target: j.target, weight: j.weight, reversed: j.reversed, bends: [] };
+    if (A.push(N), F.layer <= E.layer) {
+      P.push({ from: j.source, to: j.target, weight: j.weight });
+      continue;
+    }
+    let R = j.source;
+    for (let K = E.layer + 1;K < F.layer; K++) {
+      let X = `${z}${d++}`;
+      I.set(X, { id: X, layer: K, order: 0, depth: 0, breadth: 0, pos: 0, dummy: true }), N.bends.push(X), P.push({ from: R, to: X, weight: j.weight }), R = X;
+    }
+    P.push({ from: R, to: j.target, weight: j.weight });
+  }
+  let n = Math.max(...[...I.values()].map((j) => j.layer)) + 1, B = Array.from({ length: n }, () => []);
+  for (let j of I.values())
+    B[j.layer].push(j.id);
+  let q = new Map, O = new Map;
+  for (let j of I.keys())
+    q.set(j, []), O.set(j, []);
+  for (let j of P) {
+    let E = I.get(j.from);
+    if (I.get(j.to).layer === E.layer + 1)
+      q.get(j.from).push(j.to), O.get(j.to).push(j.from);
+  }
+  let t = (j) => {
+    let E = new Map;
+    return j.forEach((F, N) => E.set(F, N)), E;
+  }, o = (j, E) => {
+    let F = j.map((R) => [...R]), N = E ? [...F.keys()].slice(1) : [...F.keys()].slice(0, -1).reverse();
+    for (let R of N) {
+      let K = t(F[E ? R - 1 : R + 1]), X = E ? O : q, Y = new Map;
+      F[R].forEach(($, C) => {
+        let Jj = (X.get($) ?? []).map((x) => K.get(x)).filter((x) => x != null), a = s(Jj);
+        Y.set($, a < 0 ? C : a);
+      }), F[R].sort(($, C) => (Y.get($) ?? 0) - (Y.get(C) ?? 0));
+    }
+    return F;
+  }, r = (j) => {
+    let E = j.map((R) => [...R]), F = true, N = 0;
+    while (F && N++ < 8) {
+      F = false;
+      for (let R = 0;R < E.length; R++)
+        for (let K = 0;K + 1 < E[R].length; K++) {
+          let X = b(E, q), Y = E[R], $ = () => {
+            let C = Y[K];
+            Y[K] = Y[K + 1], Y[K + 1] = C;
+          };
+          if ($(), b(E, q) < X)
+            F = true;
+          else
+            $();
+        }
+    }
+    return E;
+  }, v = B.map((j) => [...j]), f = b(v, q);
+  for (let j = 0;j < J.iterations; j++) {
+    B = r(o(B, j % 2 === 0));
+    let E = b(B, q);
+    if (E <= f)
+      f = E, v = B.map((F) => [...F]);
+  }
+  B = v, B.forEach((j, E) => {
+    j.forEach((F, N) => {
+      let R = I.get(F);
+      R.layer = E, R.order = N;
+    });
+  });
+  let e = (j) => {
+    let E = 0;
+    for (let F of j) {
+      let N = I.get(F);
+      N.pos = E + N.breadth / 2, E += N.breadth + J.nodeGap;
+    }
+  };
+  for (let j of B)
+    e(j);
+  let jj = (j) => {
+    for (let E = 1;E < j.length; E++) {
+      let F = I.get(j[E - 1]), N = I.get(j[E]), R = F.pos + F.breadth / 2 + J.nodeGap + N.breadth / 2;
+      if (N.pos < R)
+        N.pos = R;
+    }
+    for (let E = j.length - 2;E >= 0; E--) {
+      let F = I.get(j[E + 1]), N = I.get(j[E]), R = F.pos - F.breadth / 2 - J.nodeGap - N.breadth / 2;
+      if (N.pos > R)
+        N.pos = R;
+    }
+  };
+  for (let j = 0;j < J.straightenPasses; j++) {
+    let E = j % 2 === 0, F = E ? [...B.keys()] : [...B.keys()].reverse();
+    for (let N of F) {
+      let R = E ? O : q;
+      for (let K of B[N]) {
+        let X = I.get(K), Y = (R.get(K) ?? []).map(($) => I.get($).pos);
+        if (Y.length)
+          X.pos = X.dummy ? Rj(Y) : s(Y);
+      }
+      jj(B[N]);
+    }
+  }
+  let Ej = (j) => {
+    let E = 1 / 0, F = -1 / 0;
+    for (let N of j) {
+      let R = I.get(N);
+      E = Math.min(E, R.pos - R.breadth / 2), F = Math.max(F, R.pos + R.breadth / 2);
+    }
+    return j.length ? { min: E, max: F } : { min: 0, max: 0 };
+  }, k = B.map(Ej), m = Math.max(0, ...k.map((j) => j.max - j.min));
+  B.forEach((j, E) => {
+    let F = (m - (k[E].max - k[E].min)) / 2 - k[E].min;
+    for (let N of j)
+      I.get(N).pos += F;
+  });
+  let S = B.map((j) => Math.max(0, ...j.map((E) => I.get(E).depth))), g = [], h = J.padding;
+  for (let j = 0;j < B.length; j++)
+    g.push(h), h += S[j] + J.layerGap;
+  let y = h - J.layerGap + J.padding, u = m + J.padding * 2, p = J.direction === "up" || J.direction === "left", c = (j, E) => {
+    let F = g[j] + (S[j] - E) / 2;
+    return p ? y - F - E : F;
+  }, D = (j) => {
+    let E = c(j.layer, j.depth), F = j.pos + J.padding - j.breadth / 2;
+    return _ ? { x: E, y: F, width: j.depth, height: j.breadth } : { x: F, y: E, width: j.breadth, height: j.depth };
+  }, l = [];
+  for (let j of Q.nodes) {
+    let E = I.get(j.id), F = D(E);
+    l.push({ id: j.id, layer: E.layer, order: E.order, ...F });
+  }
+  let Fj = (j) => {
+    let E = D(j);
+    return { x: E.x + E.width / 2, y: E.y + E.height / 2 };
+  }, w = (j, E) => {
+    let F = D(j), N = E !== p;
+    if (_)
+      return { x: N ? F.x + F.width : F.x, y: F.y + F.height / 2 };
+    return { x: F.x + F.width / 2, y: N ? F.y + F.height : F.y };
+  }, i = (j, E) => {
+    let F = D(j), N = E.pos >= j.pos;
+    if (_)
+      return { x: F.x + F.width / 2, y: N ? F.y + F.height : F.y };
+    return { x: N ? F.x + F.width : F.x, y: F.y + F.height / 2 };
+  }, Hj = A.map((j) => {
+    let E = I.get(j.source), F = I.get(j.target), N = F.layer === E.layer, R = F.layer < E.layer, K = N ? [i(E, F), i(F, E)] : R ? [w(E, false), w(F, true)] : [w(E, true), ...j.bends.map((X) => Fj(I.get(X))), w(F, false)];
+    return j.reversed ? { source: j.target, target: j.source, points: [...K].reverse(), reversed: true, flat: N } : { source: j.source, target: j.target, points: K, reversed: false, flat: N };
+  }), Ij = B.map((j, E) => {
+    let F = j.filter(($) => !I.get($).dummy).map(($) => D(I.get($))), N = c(E, S[E]);
+    if (!F.length)
+      return _ ? { index: E, nodes: [], x: N, y: J.padding, width: S[E], height: 0 } : { index: E, nodes: [], x: J.padding, y: N, width: 0, height: S[E] };
+    let R = Math.min(...F.map(($) => $.x)), K = Math.min(...F.map(($) => $.y)), X = Math.max(...F.map(($) => $.x + $.width)), Y = Math.max(...F.map(($) => $.y + $.height));
+    return { index: E, nodes: j.filter(($) => !I.get($).dummy), x: R, y: K, width: X - R, height: Y - K };
+  });
+  return { nodes: l, edges: Hj, layers: Ij, width: _ ? y : u, height: _ ? u : y, crossings: f };
+}
+function Rj(Q) {
+  let W = 0;
+  for (let J of Q)
+    W += J;
+  return W / Q.length;
+}
+function Uj(Q, W = {}) {
+  if (Q.length < 2)
+    return "";
+  let { curve: J = "smooth", direction: _ = "down", radius: V = 10 } = W, Z = _ === "right" || _ === "left";
+  if (J === "linear")
+    return `M${M(Q[0].x)},${M(Q[0].y)}${Q.slice(1).map((T) => `L${M(T.x)},${M(T.y)}`).join("")}`;
+  if (J === "orthogonal") {
+    let T = `M${M(Q[0].x)},${M(Q[0].y)}`;
+    for (let H = 1;H < Q.length; H++) {
+      let I = Q[H - 1], U = Q[H], L = Z ? (I.x + U.x) / 2 : (I.y + U.y) / 2, A = Math.min(V, Math.abs(Z ? U.y - I.y : U.x - I.x) / 2);
+      if (A < 0.5) {
+        T += `L${M(U.x)},${M(U.y)}`;
+        continue;
+      }
+      if (Z) {
+        let P = U.y > I.y ? 1 : -1;
+        T += `L${M(L - A)},${M(I.y)}Q${M(L)},${M(I.y)} ${M(L)},${M(I.y + A * P)}`, T += `L${M(L)},${M(U.y - A * P)}Q${M(L)},${M(U.y)} ${M(L + A)},${M(U.y)}`, T += `L${M(U.x)},${M(U.y)}`;
+      } else {
+        let P = U.x > I.x ? 1 : -1;
+        T += `L${M(I.x)},${M(L - A)}Q${M(I.x)},${M(L)} ${M(I.x + A * P)},${M(L)}`, T += `L${M(U.x - A * P)},${M(L)}Q${M(U.x)},${M(L)} ${M(U.x)},${M(L + A)}`, T += `L${M(U.x)},${M(U.y)}`;
+      }
+    }
+    return T;
+  }
+  let G = `M${M(Q[0].x)},${M(Q[0].y)}`;
+  for (let T = 1;T < Q.length; T++) {
+    let H = Q[T - 1], I = Q[T];
+    if (Z) {
+      let U = (H.x + I.x) / 2;
+      G += `C${M(U)},${M(H.y)} ${M(U)},${M(I.y)} ${M(I.x)},${M(I.y)}`;
+    } else {
+      let U = (H.y + I.y) / 2;
+      G += `C${M(H.x)},${M(U)} ${M(I.x)},${M(U)} ${M(I.x)},${M(I.y)}`;
+    }
+  }
+  return G;
+}
+function M(Q) {
+  return Math.round(Q * 100) / 100;
+}
+
+// ../ui/src/topology.ts
+var NODE_HEIGHT = 64;
+var LANE_GUTTER = 78;
+var GROUP_PADDING = 22;
+function midpoint(a, b2) {
+  return { x: (a.x + b2.x) / 2, y: (a.y + b2.y) / 2 };
+}
+var ICONS = {
+  internet: "M12 3a9 9 0 100 18 9 9 0 000-18zM3 12h18M12 3c2.5 2.4 3.8 5.5 3.8 9S14.5 21.6 12 21c-2.5-2.4-3.8-5.5-3.8-9S9.5 3 12 3z",
+  dns: "M4 7h16M4 12h16M4 17h10M7 4v16",
+  waf: "M12 3l7 3v5c0 4.4-2.9 8.2-7 10-4.1-1.8-7-5.6-7-10V6l7-3z",
+  firewall: "M3 6h18M3 12h18M3 18h18M8 6v6M16 6v6M12 12v6",
+  cdn: "M6 17a4 4 0 010-8 5.5 5.5 0 0110.6-1.3A4.2 4.2 0 0118 17H6z",
+  gateway: "M4 8h16M4 16h16M8 4v16M16 4v16",
+  proxy: "M4 6h7l3 3h6M4 18h7l3-3h6M17 6l3 3-3 3M17 12l3 3-3 3",
+  site: "M4 5h16v14H4zM4 9h16M7 7h.01M10 7h.01",
+  function: "M8 5c-2 0-2 3-2 5s-1 2-2 2 1 0 2 2 0 5 2 5M16 5c2 0 2 3 2 5s1 2 2 2-1 0-2 2 0 5-2 5",
+  worker: "M12 9a3 3 0 100 6 3 3 0 000-6zM12 3v3M12 18v3M4.9 4.9l2.1 2.1M17 17l2.1 2.1M3 12h3M18 12h3M4.9 19.1L7 17M17 7l2.1-2.1",
+  scheduler: "M12 3a9 9 0 100 18 9 9 0 000-18zM12 7v5l3 2",
+  queue: "M4 7h16v4H4zM4 13h16v4H4z",
+  cache: "M12 4c4.4 0 8 1.3 8 3s-3.6 3-8 3-8-1.3-8-3 3.6-3 8-3zM4 7v10c0 1.7 3.6 3 8 3s8-1.3 8-3V7",
+  database: "M12 3c4.4 0 8 1.3 8 3s-3.6 3-8 3-8-1.3-8-3 3.6-3 8-3zM4 6v12c0 1.7 3.6 3 8 3s8-1.3 8-3V6M4 12c0 1.7 3.6 3 8 3s8-1.3 8-3",
+  storage: "M4 6h16v12H4zM4 10h16M8 14h4",
+  filesystem: "M4 7a2 2 0 012-2h4l2 2h6a2 2 0 012 2v8a2 2 0 01-2 2H6a2 2 0 01-2-2V7z",
+  backup: "M12 5a7 7 0 107 7M12 5V2M12 5l3 3M5 12a7 7 0 002 5"
+};
+var FALLBACK_ICON = "M5 5h14v14H5z";
+function iconFor(kind) {
+  return ICONS[kind] ?? FALLBACK_ICON;
+}
+function widthFor(node) {
+  const label = (node.label ?? "").length;
+  const sub = (node.sub ?? "").length;
+  const longest = Math.max(label * 8.4, sub * 6.4);
+  return Math.round(Math.min(288, Math.max(168, longest + 78)));
+}
+function topologyGeometry(model, options = {}) {
+  const laneGutter = options.laneGutter ?? LANE_GUTTER;
+  const nodeHeight = options.nodeHeight ?? NODE_HEIGHT;
+  const nodes = Array.isArray(model?.nodes) ? model.nodes : [];
+  const links = Array.isArray(model?.links) ? model.links : [];
+  if (!nodes.length)
+    return { width: 400, height: laneGutter + 200, nodes: [], links: [], lanes: [], groups: [], crossings: 0 };
+  const used = [...new Set(nodes.map((node) => node.layer))].sort((a, b2) => a - b2);
+  const rankOf = new Map(used.map((layer, rank) => [layer, rank]));
+  const layout = Tj({
+    nodes: nodes.map((node) => ({
+      id: node.id,
+      layer: rankOf.get(node.layer) ?? 0,
+      width: widthFor(node),
+      height: nodeHeight
+    })),
+    edges: links.map((link) => ({ source: link.source, target: link.target }))
+  }, {
+    direction: "right",
+    layerGap: options.layerGap ?? 96,
+    nodeGap: options.nodeGap ?? 30,
+    padding: 28
+  });
+  const placed = new Map(layout.nodes.map((node) => [node.id, node]));
+  const neighbours = new Map;
+  for (const node of nodes)
+    neighbours.set(node.id, new Set);
+  for (const link of links) {
+    neighbours.get(link.source)?.add(link.target);
+    neighbours.get(link.target)?.add(link.source);
+  }
+  const shift = laneGutter;
+  const geometryNodes = nodes.flatMap((node) => {
+    const box = placed.get(node.id);
+    if (!box)
+      return [];
+    const y = box.y + shift;
+    return [{
+      ...node,
+      x: box.x,
+      y,
+      width: box.width,
+      height: box.height,
+      cx: box.x + box.width / 2,
+      cy: y + box.height / 2,
+      icon: iconFor(node.kind),
+      neighbours: [...neighbours.get(node.id) ?? []]
+    }];
+  });
+  const pending = new Map;
+  for (const link of links) {
+    const key = `${link.source}->${link.target}`;
+    if (!pending.has(key))
+      pending.set(key, []);
+    pending.get(key).push(link);
+  }
+  const geometryLinks = layout.edges.map((edge) => {
+    const source = pending.get(`${edge.source}->${edge.target}`)?.shift();
+    const points = edge.points.map((point) => ({ x: point.x, y: point.y + shift }));
+    const middle = points.length % 2 ? points[Math.floor(points.length / 2)] : midpoint(points[points.length / 2 - 1], points[points.length / 2]);
+    return {
+      source: edge.source,
+      target: edge.target,
+      flow: source?.flow ?? "request",
+      label: source?.label,
+      status: source?.status,
+      id: `${edge.source}->${edge.target}`,
+      d: Uj(points, { curve: "smooth", direction: "right" }),
+      labelX: middle.x,
+      labelY: middle.y - 7
+    };
+  });
+  const width = layout.width;
+  const height = layout.height + shift;
+  const labelOf = new Map((model.layers ?? []).map((layer) => [layer.index, layer.label]));
+  const lanes = used.flatMap((layer) => {
+    const members = geometryNodes.filter((node) => node.layer === layer);
+    if (!members.length)
+      return [];
+    const left = Math.min(...members.map((node) => node.x));
+    const right = Math.max(...members.map((node) => node.x + node.width));
+    return [{
+      id: `lane-${layer}`,
+      label: labelOf.get(layer) ?? `Layer ${layer}`,
+      x: left - 16,
+      y: shift - 34,
+      width: right - left + 32,
+      height: height - shift + 46,
+      count: members.length
+    }];
+  });
+  const groups = (model.groups ?? []).flatMap((group) => {
+    const members = geometryNodes.filter((node) => node.group === group.id);
+    if (!members.length)
+      return [];
+    const x = Math.min(...members.map((node) => node.x)) - GROUP_PADDING;
+    const y = Math.min(...members.map((node) => node.y)) - GROUP_PADDING - 12;
+    const right = Math.max(...members.map((node) => node.x + node.width)) + GROUP_PADDING;
+    const bottom = Math.max(...members.map((node) => node.y + node.height)) + GROUP_PADDING;
+    return [{ ...group, x, y, width: right - x, height: bottom - y }];
+  });
+  return { width, height, nodes: geometryNodes, links: geometryLinks, lanes, groups, crossings: layout.crossings };
+}
+function matchTopology(nodes, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle)
+    return new Set(nodes.map((node) => node.id));
+  return new Set(nodes.filter((node) => `${node.label} ${node.kind} ${node.sub ?? ""} ${node.facts.map((fact) => fact.value).join(" ")}`.toLowerCase().includes(needle)).map((node) => node.id));
+}
+function highlightFor(geometry, id) {
+  if (!id)
+    return null;
+  const keep = new Set([id]);
+  const incoming = new Map;
+  for (const link of geometry.links) {
+    if (!incoming.has(link.target))
+      incoming.set(link.target, []);
+    incoming.get(link.target).push(link.source);
+  }
+  const node = geometry.nodes.find((candidate) => candidate.id === id);
+  for (const neighbour of node?.neighbours ?? [])
+    keep.add(neighbour);
+  const seen = new Set([id]);
+  const queue = [id];
+  while (queue.length) {
+    const current = queue.shift();
+    for (const parent of incoming.get(current) ?? []) {
+      keep.add(parent);
+      if (seen.has(parent))
+        continue;
+      seen.add(parent);
+      queue.push(parent);
+    }
+  }
+  return keep;
+}
+export {
+  topologyGeometry,
+  matchTopology,
+  highlightFor
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/ts-cloud",
   "type": "module",
-  "version": "0.7.104",
+  "version": "0.7.108",
   "description": "A lightweight, performant infrastructure-as-code library and CLI for deploying both server-based (EC2) and serverless applications.",
   "author": "Chris Breuer <chris@stacksjs.com>",
   "license": "MIT",
@@ -90,8 +90,8 @@
   },
   "dependencies": {
     "@stacksjs/ts-xml": "^0.1.0",
-    "@ts-cloud/aws-types": "0.7.104",
-    "@ts-cloud/core": "0.7.104"
+    "@ts-cloud/aws-types": "0.7.108",
+    "@ts-cloud/core": "0.7.108"
   },
   "devDependencies": {
     "better-dx": "^0.2.16",

package/dist/dns/mail-records.d.ts

@@ -1,82 +0,0 @@
-/**
- * Mail DNS provisioning.
- *
- * A domain that sends mail needs four records, and getting any one of them
- * wrong is not a visible error: mail simply arrives in spam, or is silently
- * rejected by the receiving side. That failure mode is why this belongs in the
- * deploy rather than in a runbook — a deploy that stands up a mail-sending app
- * and leaves its DNS to be typed by hand has not finished the job.
- *
- * The record set is deliberately a pure function of its inputs, so what a
- * deploy is about to publish can be inspected, diffed and tested without an
- * API call or a live zone.
- *
- * @module ts-cloud/dns/mail-records
- */
-import type { DnsProvider, DnsRecord } from './types';
-export interface MailDnsOptions {
-    /** The domain that sends mail, e.g. `example.com`. */
-    domain: string;
-    /** Hostname of the mail server that receives for it. */
-    mailHost: string;
-    /** Public IPv4 of the sending server, authorised in SPF. */
-    ip?: string;
-    /** Additional SPF mechanisms, e.g. `include:amazonses.com`. */
-    spfIncludes?: string[];
-    /** DKIM selector. Convention is `default`. */
-    dkimSelector?: string;
-    /**
-     * DKIM public key, base64, without PEM armour or newlines. Omit to skip the
-     * DKIM record: publishing an empty or malformed key is worse than publishing
-     * none, because receivers treat a broken signature as a stronger negative
-     * signal than an unsigned message.
-     */
-    dkimPublicKey?: string;
-    /** MX preference. */
-    mxPriority?: number;
-    /**
-     * DMARC policy. `none` by default: it asks receivers to report rather than
-     * to reject, which is the only safe setting to switch on automatically for a
-     * domain whose mail history nobody has checked yet.
-     */
-    dmarcPolicy?: 'none' | 'quarantine' | 'reject';
-    /** Where aggregate DMARC reports go. Omitted from the record when absent. */
-    dmarcReportTo?: string;
-    ttl?: number;
-}
-/** SPF is a single TXT record; more than one is a permanent error. */
-export declare function buildSpfValue(options: Pick<MailDnsOptions, 'ip' | 'spfIncludes'>): string;
-/** Strip PEM armour and whitespace, which a DKIM TXT record must not contain. */
-export declare function normalizeDkimKey(key: string): string;
-export declare function buildDkimValue(publicKey: string): string;
-export declare function buildDmarcValue(options: Pick<MailDnsOptions, 'dmarcPolicy' | 'dmarcReportTo'>): string;
-/**
- * The full record set a mail-sending domain needs.
- *
- * Names are returned as the labels providers expect (`@` for the apex), since
- * every provider in this package normalises from that form.
- */
-export declare function buildMailDnsRecords(options: MailDnsOptions): DnsRecord[];
-export interface MailDnsSyncResult {
-    domain: string;
-    applied: Array<{
-        name: string;
-        type: string;
-        ok: boolean;
-        message?: string;
-    }>;
-    /** True when every record was written. */
-    ok: boolean;
-}
-/**
- * Publish the record set, idempotently.
- *
- * Uses `upsertRecord` rather than create, so a redeploy converges instead of
- * accumulating duplicate SPF records — two SPF TXT records on one domain is a
- * permanent error under RFC 7208 and breaks mail that previously worked.
- *
- * Never throws. Mail DNS is one part of a deploy, and a zone that is
- * momentarily unreachable should surface as a reported failure rather than
- * roll back an otherwise healthy release.
- */
-export declare function syncMailDns(provider: DnsProvider, options: MailDnsOptions): Promise<MailDnsSyncResult>;