@highstate/k8s 0.20.0 → 0.21.1

package/dist/chunk-23vn2rdc.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  StatefulSet
+} from "./chunk-z6bmpnm7.js";
+import"./chunk-h1b79v66.js";
+import"./chunk-k4w9zpn5.js";
+import"./chunk-facs31cb.js";
+import"./chunk-b05q6fm2.js";
+export {
+  StatefulSet
+};

package/dist/chunk-2pfx13ay.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  Job
+} from "./chunk-qyshvz32.js";
+import"./chunk-h1b79v66.js";
+import"./chunk-k4w9zpn5.js";
+import"./chunk-facs31cb.js";
+import"./chunk-b05q6fm2.js";
+export {
+  Job
+};

package/dist/chunk-46ntav0c.js

@@ -0,0 +1,299 @@
+// @bun
+import {
+  Service
+} from "./chunk-k4w9zpn5.js";
+import {
+  Namespace,
+  NamespacedResource,
+  commonExtraArgs,
+  getProvider,
+  mapMetadata
+} from "./chunk-facs31cb.js";
+
+// src/gateway/backend.ts
+import { output } from "@highstate/pulumi";
+function resolveBackendRef(ref) {
+  if (Service.isInstance(ref)) {
+    return output({
+      name: ref.metadata.name,
+      namespace: ref.metadata.namespace,
+      port: ref.spec.ports[0].port
+    });
+  }
+  if ("service" in ref) {
+    const service = output(ref.service);
+    return output({
+      name: service.metadata.name,
+      namespace: service.metadata.namespace,
+      port: ref.port ?? service.spec.ports[0].port
+    });
+  }
+  return output({
+    name: ref.name,
+    namespace: ref.namespace,
+    port: ref.port
+  });
+}
+
+// src/gateway/gateway.ts
+import { parseEndpoint } from "@highstate/common";
+import { getOrCreate } from "@highstate/contract";
+import { gateway } from "@highstate/gateway-api";
+import { k8s } from "@highstate/library";
+import {
+  interpolate,
+  makeEntityOutput,
+  output as output2,
+  toPromise
+} from "@highstate/pulumi";
+import { omit } from "remeda";
+var gatewayExtraArgs = [...commonExtraArgs, "fqdn", "fqdns"];
+
+class Gateway extends NamespacedResource {
+  spec;
+  status;
+  static apiVersion = "gateway.networking.k8s.io/v1";
+  static kind = "Gateway";
+  constructor(type, name, args, opts, metadata, namespace, spec, status) {
+    super(type, name, args, opts, metadata, namespace);
+    this.spec = spec;
+    this.status = status;
+  }
+  get entity() {
+    return makeEntityOutput({
+      entity: k8s.gatewayEntity,
+      identity: this.metadata.uid,
+      meta: {
+        title: this.metadata.name
+      },
+      value: {
+        ...this.entityBase
+      }
+    });
+  }
+  get endpoints() {
+    return this.status.addresses.apply((addresses) => {
+      if (!addresses) {
+        return [];
+      }
+      return addresses.map((address) => parseEndpoint(address.value));
+    });
+  }
+  static create(name, args, opts) {
+    return new CreatedGateway(name, args, opts);
+  }
+  static createOrPatch(name, args, opts) {
+    if (args.existing) {
+      return new GatewayPatch(name, {
+        ...args,
+        name: output2(args.existing).metadata.name,
+        namespace: Namespace.forResourceAsync(args.existing, output2(args.namespace).cluster)
+      });
+    }
+    return new CreatedGateway(name, args, opts);
+  }
+  static async createOrGet(name, args, opts) {
+    if (args.existing) {
+      return await Gateway.forAsync(args.existing, output2(args.namespace).cluster);
+    }
+    return new CreatedGateway(name, args, opts);
+  }
+  static patch(name, args, opts) {
+    return new GatewayPatch(name, args, opts);
+  }
+  static wrap(name, args, opts) {
+    return new WrappedGateway(name, args, opts);
+  }
+  static get(name, args, opts) {
+    return new ExternalGateway(name, args, opts);
+  }
+  static gatewayCache = new Map;
+  static for(entity, cluster) {
+    return getOrCreate(Gateway.gatewayCache, `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`, (name) => {
+      return Gateway.get(name, {
+        name: entity.metadata.name,
+        namespace: Namespace.forResourceAsync(entity, cluster)
+      });
+    });
+  }
+  static async forAsync(entity, cluster) {
+    const resolvedEntity = await toPromise(entity);
+    return Gateway.for(resolvedEntity, output2(cluster));
+  }
+}
+
+class CreatedGateway extends Gateway {
+  constructor(name, args, opts) {
+    const gatewayResource = output2(args.namespace).cluster.apply((cluster) => {
+      return new gateway.v1.Gateway(name, {
+        metadata: mapMetadata(args, name),
+        spec: omit(args, gatewayExtraArgs)
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:Gateway", name, args, opts, gatewayResource.metadata, output2(args.namespace), gatewayResource.spec, gatewayResource.status);
+  }
+}
+
+class GatewayPatch extends Gateway {
+  constructor(name, args, opts) {
+    const gatewayResource = output2(args.namespace).cluster.apply((cluster) => {
+      return new gateway.v1.GatewayPatch(name, {
+        metadata: mapMetadata(args, name),
+        spec: omit(args, gatewayExtraArgs)
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:GatewayPatch", name, args, opts, gatewayResource.metadata, output2(args.namespace), gatewayResource.spec, gatewayResource.status);
+  }
+}
+
+class WrappedGateway extends Gateway {
+  constructor(name, args, opts) {
+    super("highstate:k8s:WrappedGateway", name, args, opts, output2(args.gateway).metadata, output2(args.namespace), output2(args.gateway).spec, output2(args.gateway).status);
+  }
+}
+
+class ExternalGateway extends Gateway {
+  constructor(name, args, opts) {
+    const gatewayResource = output2(args.namespace).cluster.apply((cluster) => {
+      return gateway.v1.Gateway.get(name, interpolate`${output2(args.namespace).metadata.name}/${args.name}`, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:ExternalGateway", name, args, opts, gatewayResource.metadata, output2(args.namespace), gatewayResource.spec, gatewayResource.status);
+  }
+}
+
+// src/gateway/http-route.ts
+import { gateway as gateway2 } from "@highstate/gateway-api";
+import {
+  ComponentResource,
+  normalize,
+  normalizeInputs,
+  normalizeInputsAndMap,
+  output as output3
+} from "@highstate/pulumi";
+import { map, pipe } from "remeda";
+class HttpRoute extends ComponentResource {
+  route;
+  constructor(name, args, opts) {
+    super("highstate:k8s:HttpRoute", name, args, opts);
+    this.route = output3(args.gateway).cluster.apply((cluster) => {
+      return new gateway2.v1.HTTPRoute(name, {
+        metadata: mapMetadata(args, name).apply((metadata) => ({
+          ...metadata,
+          namespace: output3(args.gateway).namespace.metadata.name
+        })),
+        spec: {
+          hostnames: normalizeInputs(args.hostname, args.hostnames),
+          parentRefs: [
+            {
+              name: output3(args.gateway).metadata.name
+            }
+          ],
+          rules: normalizeInputsAndMap(args.rule, args.rules, (rule) => ({
+            timeouts: rule.timeouts,
+            matches: pipe(normalize(rule.match, rule.matches), map(mapHttpRouteRuleMatch), addDefaultPathMatch),
+            filters: normalize(rule.filter, rule.filters),
+            backendRefs: normalizeInputsAndMap(rule.backend, rule.backends, resolveBackendRef)
+          }))
+        }
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+  }
+}
+function addDefaultPathMatch(matches) {
+  return matches.length ? matches : [{ path: { type: "PathPrefix", value: "/" } }];
+}
+function mapHttpRouteRuleMatch(match) {
+  if (typeof match === "string") {
+    return { path: { type: "PathPrefix", value: match } };
+  }
+  return match;
+}
+
+// src/gateway/tcp-route.ts
+import { gateway as gateway3 } from "@highstate/gateway-api";
+import {
+  ComponentResource as ComponentResource2,
+  normalizeInputsAndMap as normalizeInputsAndMap2,
+  output as output4
+} from "@highstate/pulumi";
+class TcpRoute extends ComponentResource2 {
+  route;
+  constructor(name, args, opts) {
+    super("highstate:k8s:TcpRoute", name, args, opts);
+    const gatewayOutput = output4(args.gateway);
+    const parentRefs = output4({
+      gateway: gatewayOutput,
+      listenerName: args.listenerName
+    }).apply(({ gateway: gateway4, listenerName }) => [
+      {
+        group: "gateway.networking.k8s.io",
+        kind: "Gateway",
+        name: gateway4.metadata.name,
+        namespace: gateway4.namespace.metadata.name,
+        sectionName: listenerName
+      }
+    ]);
+    const backendRefs = normalizeInputsAndMap2(args.backend, args.backends, resolveBackendRef);
+    this.route = gatewayOutput.cluster.apply((cluster) => {
+      return new gateway3.v1alpha2.TCPRoute(name, {
+        metadata: mapMetadata(args, name).apply((metadata) => ({
+          ...metadata,
+          namespace: gatewayOutput.namespace.metadata.name
+        })),
+        spec: {
+          parentRefs,
+          rules: [
+            {
+              backendRefs
+            }
+          ]
+        }
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+  }
+}
+
+// src/gateway/udp-route.ts
+import { gateway as gateway4 } from "@highstate/gateway-api";
+import {
+  ComponentResource as ComponentResource3,
+  normalizeInputsAndMap as normalizeInputsAndMap3,
+  output as output5
+} from "@highstate/pulumi";
+class UdpRoute extends ComponentResource3 {
+  route;
+  constructor(name, args, opts) {
+    super("highstate:k8s:UdpRoute", name, args, opts);
+    const gatewayOutput = output5(args.gateway);
+    const parentRefs = output5({
+      gateway: gatewayOutput,
+      listenerName: args.listenerName
+    }).apply(({ gateway: gateway5, listenerName }) => [
+      {
+        group: "gateway.networking.k8s.io",
+        kind: "Gateway",
+        name: gateway5.metadata.name,
+        namespace: gateway5.namespace.metadata.name,
+        sectionName: listenerName
+      }
+    ]);
+    const backendRefs = normalizeInputsAndMap3(args.backend, args.backends, resolveBackendRef);
+    this.route = gatewayOutput.cluster.apply((cluster) => {
+      return new gateway4.v1alpha2.UDPRoute(name, {
+        metadata: mapMetadata(args, name).apply((metadata) => ({
+          ...metadata,
+          namespace: gatewayOutput.namespace.metadata.name
+        })),
+        spec: {
+          parentRefs,
+          rules: [
+            {
+              backendRefs
+            }
+          ]
+        }
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+  }
+}
+export { resolveBackendRef, Gateway, HttpRoute, mapHttpRouteRuleMatch, TcpRoute, UdpRoute };

package/dist/chunk-556pc9e6.js

@@ -0,0 +1,155 @@
+// @bun
+import {
+  Namespace,
+  NamespacedResource,
+  Secret,
+  commonExtraArgs,
+  getProvider,
+  mapMetadata
+} from "./chunk-facs31cb.js";
+
+// src/tls.ts
+import { cert_manager } from "@highstate/cert-manager";
+import { getOrCreate } from "@highstate/contract";
+import { k8s } from "@highstate/library";
+import {
+  interpolate,
+  makeEntityOutput,
+  output,
+  toPromise
+} from "@highstate/pulumi";
+import { omit } from "remeda";
+var certManagerCertificateWaitFor = "condition=Ready";
+function mapCertificateMetadata(args, fallbackName) {
+  return mapMetadata(args, fallbackName).apply((metadata) => ({
+    ...metadata,
+    annotations: {
+      ...metadata.annotations,
+      "pulumi.com/waitFor": metadata.annotations?.["pulumi.com/waitFor"] ?? certManagerCertificateWaitFor
+    }
+  }));
+}
+
+class Certificate extends NamespacedResource {
+  name;
+  spec;
+  status;
+  static apiVersion = "cert-manager.io/v1";
+  static kind = "Certificate";
+  _secret;
+  constructor(type, name, args, opts, metadata, namespace, spec, status) {
+    super(type, name, args, opts, metadata, namespace);
+    this.name = name;
+    this.spec = spec;
+    this.status = status;
+  }
+  get entity() {
+    return makeEntityOutput({
+      entity: k8s.certificateEntity,
+      identity: this.metadata.uid,
+      meta: {
+        title: this.metadata.name
+      },
+      value: {
+        ...this.entityBase
+      }
+    });
+  }
+  get secret() {
+    if (this._secret) {
+      return this._secret;
+    }
+    this._secret = output({
+      secretName: this.spec.apply((spec) => spec.secretName),
+      namespace: this.namespace
+    }).apply(({ secretName, namespace }) => {
+      return Secret.get(`${this.name}.secret`, {
+        name: secretName,
+        namespace
+      });
+    });
+    return this._secret;
+  }
+  static create(name, args, opts) {
+    return new CreatedCertificate(name, args, opts);
+  }
+  static createOrPatch(name, args, opts) {
+    if (args.existing) {
+      return new CertificatePatch(name, {
+        ...args,
+        name: output(args.existing).metadata.name,
+        namespace: Namespace.forResourceAsync(args.existing, output(args.namespace).cluster)
+      });
+    }
+    return new CreatedCertificate(name, args, opts);
+  }
+  static async createOrGet(name, args, opts) {
+    if (args.existing) {
+      return await Certificate.forAsync(args.existing, output(args.namespace).cluster);
+    }
+    return new CreatedCertificate(name, args, opts);
+  }
+  static patch(name, args, opts) {
+    return new CertificatePatch(name, args, opts);
+  }
+  static wrap(name, args, opts) {
+    return new WrappedCertificate(name, args, opts);
+  }
+  static get(name, args, opts) {
+    return new ExternalCertificate(name, args, opts);
+  }
+  static certificateCache = new Map;
+  static for(entity, cluster) {
+    return getOrCreate(Certificate.certificateCache, `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`, (name) => {
+      return Certificate.get(name, {
+        name: entity.metadata.name,
+        namespace: Namespace.forResourceAsync(entity, cluster)
+      });
+    });
+  }
+  static async forAsync(entity, cluster) {
+    const resolvedEntity = await toPromise(entity);
+    return Certificate.for(resolvedEntity, output(cluster));
+  }
+}
+
+class CreatedCertificate extends Certificate {
+  constructor(name, args, opts) {
+    const certificate = output(args.namespace).cluster.apply((cluster) => {
+      return new cert_manager.v1.Certificate(name, {
+        metadata: mapCertificateMetadata(args, name),
+        spec: omit(args, commonExtraArgs)
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:Certificate", name, args, opts, certificate.metadata, output(args.namespace), certificate.spec, certificate.status);
+  }
+}
+
+class CertificatePatch extends Certificate {
+  constructor(name, args, opts) {
+    const certificate = output(args.namespace).cluster.apply((cluster) => {
+      return new cert_manager.v1.CertificatePatch(name, {
+        metadata: mapCertificateMetadata(args, name),
+        spec: omit(args, commonExtraArgs)
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:CertificatePatch", name, args, opts, certificate.metadata, output(args.namespace), certificate.spec, certificate.status);
+  }
+}
+
+class WrappedCertificate extends Certificate {
+  constructor(name, args, opts) {
+    super("highstate:k8s:WrappedCertificate", name, args, opts, output(args.certificate).metadata, output(args.namespace), output(args.certificate).spec, output(args.certificate).status);
+  }
+}
+
+class ExternalCertificate extends Certificate {
+  constructor(name, args, opts) {
+    const certificate = output(args.namespace).cluster.apply((cluster) => {
+      return cert_manager.v1.Certificate.get(name, interpolate`${output(args.namespace).metadata.name}/${args.name}`, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:ExternalCertificate", name, args, opts, certificate.metadata, output(args.namespace), certificate.spec, certificate.status);
+  }
+}
+
+export { Certificate };

package/dist/chunk-7kgjgcft.js

@@ -0,0 +1,170 @@
+// @bun
+import {
+  Workload,
+  filterPatchOwnedContainersInTemplate,
+  getWorkloadServiceComponents,
+  workloadServiceExtraArgs
+} from "./chunk-h1b79v66.js";
+import {
+  Namespace,
+  getProvider,
+  mapMetadata
+} from "./chunk-facs31cb.js";
+
+// src/deployment.ts
+import { getOrCreate } from "@highstate/contract";
+import { k8s } from "@highstate/library";
+import {
+  interpolate,
+  makeEntityOutput,
+  output,
+  toPromise
+} from "@highstate/pulumi";
+import { apps } from "@pulumi/kubernetes";
+import { deepmerge } from "deepmerge-ts";
+import { omit } from "remeda";
+class Deployment extends Workload {
+  spec;
+  status;
+  static apiVersion = "apps/v1";
+  static kind = "Deployment";
+  constructor(type, name, args, opts, metadata, namespace, terminalArgs, containers, networkPolicy, service, routes, spec, status) {
+    super(type, name, args, opts, metadata, namespace, terminalArgs, containers, spec.template, networkPolicy, service, routes);
+    this.spec = spec;
+    this.status = status;
+  }
+  get templateMetadata() {
+    return this.spec.template.metadata;
+  }
+  getTerminalMeta() {
+    return output({
+      title: "Deployment",
+      globalTitle: interpolate`Deployment | ${this.metadata.name}`,
+      description: "The shell inside the deployment.",
+      icon: "devicon:kubernetes"
+    });
+  }
+  get entity() {
+    const service = this._service.apply((service2) => service2?.entity);
+    return makeEntityOutput({
+      entity: k8s.deploymentEntity,
+      identity: this.metadata.uid,
+      meta: {
+        title: this.metadata.name
+      },
+      value: {
+        ...this.entityBase,
+        service,
+        spec: this.spec
+      }
+    });
+  }
+  static create(name, args, opts) {
+    return new CreatedDeployment(name, args, opts);
+  }
+  static createOrPatch(name, args, opts) {
+    if (args.existing) {
+      return new DeploymentPatch(name, {
+        ...args,
+        name: output(args.existing).metadata.name,
+        namespace: Namespace.forResourceAsync(args.existing, output(args.namespace).cluster)
+      });
+    }
+    return new CreatedDeployment(name, args, opts);
+  }
+  static async createOrGet(name, args, opts) {
+    if (args.existing) {
+      return await Deployment.forAsync(args.existing, output(args.namespace).cluster);
+    }
+    return new CreatedDeployment(name, args, opts);
+  }
+  static patch(name, args, opts) {
+    return new DeploymentPatch(name, args, opts);
+  }
+  static wrap(name, args, opts) {
+    return new WrappedDeployment(name, args, opts);
+  }
+  static get(name, args, opts) {
+    return new ExternalDeployment(name, args, opts);
+  }
+  static deploymentCache = new Map;
+  static for(entity, cluster) {
+    return getOrCreate(Deployment.deploymentCache, `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`, (name) => {
+      return Deployment.get(name, {
+        name: entity.metadata.name,
+        namespace: Namespace.forResource(entity, cluster)
+      });
+    });
+  }
+  static async forAsync(entity, cluster) {
+    const resolvedEntity = await toPromise(entity);
+    return Deployment.for(resolvedEntity, cluster);
+  }
+}
+
+class CreatedDeployment extends Deployment {
+  constructor(name, args, opts) {
+    const { labels, podTemplate, networkPolicy, containers, service, routes } = getWorkloadServiceComponents(name, args, () => this, opts);
+    const deployment = output(args.namespace).cluster.apply((cluster) => {
+      return new apps.v1.Deployment(name, {
+        metadata: mapMetadata(args, name),
+        spec: output({ args, podTemplate, labels }).apply(({ args: args2, podTemplate: podTemplate2, labels: labels2 }) => {
+          return deepmerge({
+            template: podTemplate2,
+            selector: { matchLabels: labels2 }
+          }, omit(args2, workloadServiceExtraArgs));
+        })
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:Deployment", name, args, opts, deployment.metadata, output(args.namespace), output(args.terminal ?? {}), containers, networkPolicy, service, routes, deployment.spec, deployment.status);
+  }
+}
+
+class DeploymentPatch extends Deployment {
+  constructor(name, args, opts) {
+    const { podTemplate, networkPolicy, containers, service, routes } = getWorkloadServiceComponents(name, args, () => this, opts, true);
+    const deployment = output(args.namespace).cluster.apply((cluster) => {
+      return new apps.v1.DeploymentPatch(name, {
+        metadata: mapMetadata(args, name),
+        spec: output({ args, podTemplate }).apply(({ args: args2, podTemplate: podTemplate2 }) => {
+          const spec = deepmerge({ template: podTemplate2 }, omit(args2, workloadServiceExtraArgs));
+          if (spec.template) {
+            spec.template = filterPatchOwnedContainersInTemplate(spec.template, podTemplate2);
+          }
+          return spec;
+        })
+      }, {
+        ...opts,
+        parent: this,
+        provider: getProvider(cluster)
+      });
+    });
+    const filteredSpec = output({ spec: deployment.spec, podTemplate }).apply(({ spec, podTemplate: podTemplate2 }) => {
+      if (!spec.template) {
+        return spec;
+      }
+      return {
+        ...spec,
+        template: filterPatchOwnedContainersInTemplate(spec.template, podTemplate2)
+      };
+    });
+    super("highstate:k8s:DeploymentPatch", name, args, opts, deployment.metadata, output(args.namespace), output(args.terminal ?? {}), containers, networkPolicy, service, routes, filteredSpec, deployment.status);
+  }
+}
+
+class WrappedDeployment extends Deployment {
+  constructor(name, args, opts) {
+    super("highstate:k8s:WrappedDeployment", name, args, opts, output(args.deployment).metadata, output(args.namespace), output(args.terminal ?? {}), output([]), output(undefined), output(undefined), output([]), output(args.deployment).spec, output(args.deployment).status);
+  }
+}
+
+class ExternalDeployment extends Deployment {
+  constructor(name, args, opts) {
+    const deployment = output(args.namespace).cluster.apply((cluster) => {
+      return apps.v1.Deployment.get(name, interpolate`${output(args.namespace).metadata.name}/${args.name}`, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:ExternalDeployment", name, args, opts, deployment.metadata, output(args.namespace), output({}), output([]), output(undefined), output(undefined), output([]), deployment.spec, deployment.status);
+  }
+}
+
+export { Deployment };

package/dist/{chunk-ADHZK6V2.js → chunk-9hs97f1q.js}

@@ -1,9 +1,13 @@
-import { images_exports } from './chunk-TOLFVF4S.js';
-import { parseAddress, isPrivateAddress } from '@highstate/common';
-import { text } from '@highstate/contract';
-import { output, makeFileOutput } from '@highstate/pulumi';
-import { CoreV1Api } from '@kubernetes/client-node';
+// @bun
+import {
+  images_default
+} from "./chunk-facs31cb.js";
 
+// src/cluster.ts
+import { isPrivateAddress, parseAddress } from "@highstate/common";
+import { text } from "@highstate/contract";
+import { makeFileOutput, output } from "@highstate/pulumi";
+import { CoreV1Api } from "@kubernetes/client-node";
 async function detectExternalIps(kubeConfig, internalIpsPolicy) {
   const nodeApi = kubeConfig.makeApiClient(CoreV1Api);
   const nodes = await nodeApi.listNode();
@@ -11,8 +15,8 @@ async function detectExternalIps(kubeConfig, internalIpsPolicy) {
     const addresses = node.status?.addresses ?? [];
     const externalIp = addresses.find((address) => address.type === "ExternalIP");
     const internalIp = addresses.find((address) => address.type === "InternalIP");
-    const externalAddress = externalIp ? parseAddress(externalIp.address) : void 0;
-    const internalAddress = internalIp ? parseAddress(internalIp.address) : void 0;
+    const externalAddress = externalIp ? parseAddress(externalIp.address) : undefined;
+    const internalAddress = internalIp ? parseAddress(internalIp.address) : undefined;
     const result = [];
     if (externalAddress) {
       result.push(externalAddress);
@@ -35,7 +39,7 @@ function createK8sTerminal(kubeconfig) {
       icon: "devicon:kubernetes"
     },
     spec: {
-      image: images_exports["terminal-kubectl"].image,
+      image: images_default["terminal-kubectl"].image,
       command: ["bash", "/welcome.sh"],
       files: {
         "/kubeconfig": makeFileOutput({
@@ -63,6 +67,4 @@ function createK8sTerminal(kubeconfig) {
   });
 }
 
-export { createK8sTerminal, detectExternalIps };
-//# sourceMappingURL=chunk-ADHZK6V2.js.map
-//# sourceMappingURL=chunk-ADHZK6V2.js.map
+export { detectExternalIps, createK8sTerminal };