@highstate/k8s 0.19.1 → 0.21.1

package/dist/chunk-qyshvz32.js

@@ -0,0 +1,176 @@
+// @bun
+import {
+  Workload,
+  filterPatchOwnedContainersInTemplate,
+  getWorkloadComponents
+} from "./chunk-h1b79v66.js";
+import {
+  Namespace,
+  commonExtraArgs,
+  getProvider,
+  mapMetadata
+} from "./chunk-facs31cb.js";
+
+// src/job.ts
+import { getOrCreate } from "@highstate/contract";
+import { k8s } from "@highstate/library";
+import {
+  interpolate,
+  makeEntityOutput,
+  output,
+  toPromise
+} from "@highstate/pulumi";
+import { batch } from "@pulumi/kubernetes";
+import { deepmerge } from "deepmerge-ts";
+import { omit } from "remeda";
+class Job extends Workload {
+  spec;
+  status;
+  static apiVersion = "batch/v1";
+  static kind = "Job";
+  constructor(type, name, args, opts, metadata, namespace, terminalArgs, containers, networkPolicy, spec, status) {
+    super(type, name, args, opts, metadata, namespace, terminalArgs, containers, spec.template, networkPolicy);
+    this.spec = spec;
+    this.status = status;
+  }
+  get templateMetadata() {
+    return this.spec.template.metadata;
+  }
+  get entity() {
+    return makeEntityOutput({
+      entity: k8s.jobEntity,
+      identity: this.metadata.uid,
+      meta: {
+        title: this.metadata.name
+      },
+      value: {
+        ...this.entityBase,
+        spec: this.spec
+      }
+    });
+  }
+  getTerminalMeta() {
+    return output({
+      title: "Job",
+      globalTitle: interpolate`Job | ${this.metadata.name}`,
+      description: "The shell inside the job.",
+      icon: "devicon:kubernetes"
+    });
+  }
+  get resourceType() {
+    return "job";
+  }
+  static create(name, args, opts) {
+    return new CreatedJob(name, args, opts);
+  }
+  static createOrPatch(name, args, opts) {
+    if (args.existing) {
+      return new JobPatch(name, {
+        ...args,
+        name: output(args.existing).metadata.name,
+        namespace: Namespace.forResourceAsync(args.existing, output(args.namespace).cluster)
+      });
+    }
+    return new CreatedJob(name, args, opts);
+  }
+  static async createOrGet(name, args, opts) {
+    if (args.existing) {
+      return await Job.forAsync(args.existing, output(args.namespace).cluster);
+    }
+    return new CreatedJob(name, args, opts);
+  }
+  static patch(name, args, opts) {
+    return new JobPatch(name, args, opts);
+  }
+  static wrap(name, args, opts) {
+    return new WrappedJob(name, args, opts);
+  }
+  static get(name, args, opts) {
+    return new ExternalJob(name, args, opts);
+  }
+  static jobCache = new Map;
+  static for(entity, cluster) {
+    return getOrCreate(Job.jobCache, `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`, (name) => {
+      return Job.get(name, {
+        name: entity.metadata.name,
+        namespace: Namespace.forResource(entity, cluster)
+      });
+    });
+  }
+  static async forAsync(entity, cluster) {
+    const resolvedEntity = await toPromise(entity);
+    return Job.for(resolvedEntity, cluster);
+  }
+}
+var jobExtraArgs = [...commonExtraArgs, "container", "containers"];
+
+class CreatedJob extends Job {
+  constructor(name, args, opts) {
+    const { podTemplate, containers, networkPolicy } = getWorkloadComponents(name, args, () => this, opts);
+    const job = output(args.namespace).cluster.apply((cluster) => {
+      return new batch.v1.Job(name, {
+        metadata: mapMetadata(args, name),
+        spec: output({ args, podTemplate }).apply(({ args: args2, podTemplate: podTemplate2 }) => {
+          return deepmerge({
+            template: deepmerge({
+              spec: {
+                restartPolicy: "Never"
+              }
+            }, podTemplate2)
+          }, omit(args2, jobExtraArgs));
+        })
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:Job", name, args, opts, job.metadata, output(args.namespace), output(args.terminal ?? {}), containers, networkPolicy, job.spec, job.status);
+  }
+}
+
+class JobPatch extends Job {
+  constructor(name, args, opts) {
+    const { podTemplate, containers, networkPolicy } = getWorkloadComponents(name, args, () => this, opts, true);
+    const job = output(args.namespace).cluster.apply((cluster) => {
+      return new batch.v1.JobPatch(name, {
+        metadata: mapMetadata(args, name),
+        spec: output({ args, podTemplate }).apply(({ args: args2, podTemplate: podTemplate2 }) => {
+          const spec = deepmerge({ template: podTemplate2 }, omit(args2, jobExtraArgs));
+          if (spec.template) {
+            spec.template = filterPatchOwnedContainersInTemplate(spec.template, podTemplate2);
+          }
+          return spec;
+        })
+      }, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    const filteredSpec = output({ spec: job.spec, podTemplate }).apply(({ spec, podTemplate: podTemplate2 }) => {
+      if (!spec.template) {
+        return spec;
+      }
+      return {
+        ...spec,
+        template: filterPatchOwnedContainersInTemplate(spec.template, podTemplate2)
+      };
+    });
+    super("highstate:k8s:JobPatch", name, args, opts, job.metadata, output(args.namespace), output(args.terminal ?? {}), containers, networkPolicy, filteredSpec, job.status);
+    this.registerOutputs({
+      metadata: this.metadata,
+      spec: this.spec,
+      status: this.status
+    });
+  }
+}
+
+class WrappedJob extends Job {
+  constructor(name, args, opts) {
+    super("highstate:k8s:WrappedJob", name, args, opts, output(args.job).metadata, output(args.namespace), output(args.terminal ?? {}), output([]), output(undefined), output(args.job).spec, output(args.job).status);
+  }
+}
+
+class ExternalJob extends Job {
+  constructor(name, args, opts) {
+    const job = output(args.namespace).cluster.apply((cluster) => {
+      return batch.v1.Job.get(name, interpolate`${output(args.namespace).metadata.name}/${args.name}`, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:ExternalJob", name, args, opts, job.metadata, output(args.namespace), output({}), output([]), output(undefined), job.spec, job.status);
+  }
+}
+
+export { Job };

package/dist/chunk-tpfyj6fe.js

@@ -0,0 +1,199 @@
+// @bun
+import {
+  Workload,
+  filterPatchOwnedContainersInTemplate,
+  getWorkloadComponents
+} from "./chunk-h1b79v66.js";
+import {
+  Namespace,
+  commonExtraArgs,
+  getProvider,
+  mapMetadata
+} from "./chunk-facs31cb.js";
+
+// src/cron-job.ts
+import { getOrCreate } from "@highstate/contract";
+import { k8s } from "@highstate/library";
+import {
+  interpolate,
+  makeEntityOutput,
+  output,
+  toPromise
+} from "@highstate/pulumi";
+import { batch } from "@pulumi/kubernetes";
+import { deepmerge } from "deepmerge-ts";
+import { omit } from "remeda";
+class CronJob extends Workload {
+  spec;
+  status;
+  static apiVersion = "batch/v1";
+  static kind = "CronJob";
+  constructor(type, name, args, opts, metadata, namespace, terminalArgs, containers, networkPolicy, spec, status) {
+    super(type, name, args, opts, metadata, namespace, terminalArgs, containers, spec.jobTemplate.spec.template, networkPolicy);
+    this.spec = spec;
+    this.status = status;
+  }
+  get templateMetadata() {
+    return this.spec.jobTemplate.spec.template.metadata;
+  }
+  get entity() {
+    return makeEntityOutput({
+      entity: k8s.cronJobEntity,
+      identity: this.metadata.uid,
+      meta: {
+        title: this.metadata.name
+      },
+      value: {
+        ...this.entityBase,
+        spec: this.spec.jobTemplate.spec
+      }
+    });
+  }
+  getTerminalMeta() {
+    return output({
+      title: "CronJob",
+      globalTitle: interpolate`CronJob | ${this.metadata.name}`,
+      description: "The shell inside the cron job.",
+      icon: "devicon:kubernetes"
+    });
+  }
+  get resourceType() {
+    return "cronjob";
+  }
+  static create(name, args, opts) {
+    return new CreatedCronJob(name, args, opts);
+  }
+  static createOrPatch(name, args, opts) {
+    if (args.existing) {
+      return new CronJobPatch(name, {
+        ...args,
+        name: output(args.existing).metadata.name,
+        namespace: Namespace.forResourceAsync(args.existing, output(args.namespace).cluster)
+      });
+    }
+    return new CreatedCronJob(name, args, opts);
+  }
+  static async createOrGet(name, args, opts) {
+    if (args.existing) {
+      return await CronJob.forAsync(args.existing, output(args.namespace).cluster);
+    }
+    return new CreatedCronJob(name, args, opts);
+  }
+  static patch(name, args, opts) {
+    return new CronJobPatch(name, args, opts);
+  }
+  static wrap(name, args, opts) {
+    return new WrappedCronJob(name, args, opts);
+  }
+  static get(name, args, opts) {
+    return new ExternalCronJob(name, args, opts);
+  }
+  static cronJobCache = new Map;
+  static for(entity, cluster) {
+    return getOrCreate(CronJob.cronJobCache, `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`, (name) => {
+      return CronJob.get(name, {
+        name: entity.metadata.name,
+        namespace: Namespace.forResource(entity, cluster)
+      });
+    });
+  }
+  static async forAsync(entity, cluster) {
+    const resolvedEntity = await toPromise(entity);
+    return CronJob.for(resolvedEntity, cluster);
+  }
+}
+var cronJobExtraArgs = [...commonExtraArgs, "container", "containers"];
+
+class CreatedCronJob extends CronJob {
+  constructor(name, args, opts) {
+    const { podTemplate, containers, networkPolicy } = getWorkloadComponents(name, args, () => this, opts);
+    const cronJob = output(args.namespace).cluster.apply((cluster) => {
+      return new batch.v1.CronJob(name, {
+        metadata: mapMetadata(args, name),
+        spec: output({ args, podTemplate }).apply(({ args: args2, podTemplate: podTemplate2 }) => {
+          return deepmerge({
+            jobTemplate: {
+              spec: {
+                template: deepmerge({
+                  spec: {
+                    restartPolicy: "Never"
+                  }
+                }, podTemplate2)
+              }
+            },
+            schedule: args2.schedule
+          }, omit(args2, cronJobExtraArgs));
+        })
+      }, {
+        ...opts,
+        parent: this,
+        provider: getProvider(cluster)
+      });
+    });
+    super("highstate:k8s:CronJob", name, args, opts, cronJob.metadata, output(args.namespace), output(args.terminal ?? {}), containers, networkPolicy, cronJob.spec, cronJob.status);
+  }
+}
+
+class CronJobPatch extends CronJob {
+  constructor(name, args, opts) {
+    const { podTemplate, containers, networkPolicy } = getWorkloadComponents(name, args, () => this, opts, true);
+    const cronJob = output(args.namespace).cluster.apply((cluster) => {
+      return new batch.v1.CronJobPatch(name, {
+        metadata: mapMetadata(args, name),
+        spec: output({ args, podTemplate }).apply(({ args: args2, podTemplate: podTemplate2 }) => {
+          const spec = deepmerge({
+            jobTemplate: {
+              spec: {
+                template: podTemplate2
+              }
+            },
+            schedule: args2.schedule
+          }, omit(args2, cronJobExtraArgs));
+          if (spec.jobTemplate?.spec?.template) {
+            spec.jobTemplate.spec.template = filterPatchOwnedContainersInTemplate(spec.jobTemplate.spec.template, podTemplate2);
+          }
+          return spec;
+        })
+      }, {
+        ...opts,
+        parent: this,
+        provider: getProvider(cluster)
+      });
+    });
+    const filteredSpec = output({ spec: cronJob.spec, podTemplate }).apply(({ spec, podTemplate: podTemplate2 }) => {
+      const template = spec.jobTemplate?.spec?.template;
+      if (!template) {
+        return spec;
+      }
+      const filteredTemplate = filterPatchOwnedContainersInTemplate(template, podTemplate2);
+      return {
+        ...spec,
+        jobTemplate: {
+          ...spec.jobTemplate,
+          spec: {
+            ...spec.jobTemplate.spec,
+            template: filteredTemplate
+          }
+        }
+      };
+    });
+    super("highstate:k8s:CronJobPatch", name, args, opts, cronJob.metadata, output(args.namespace), output(args.terminal ?? {}), containers, networkPolicy, filteredSpec, cronJob.status);
+  }
+}
+
+class WrappedCronJob extends CronJob {
+  constructor(name, args, opts) {
+    super("highstate:k8s:WrappedCronJob", name, args, opts, output(args.cronJob).metadata, output(args.namespace), output(args.terminal ?? {}), output([]), output(undefined), output(args.cronJob).spec, output(args.cronJob).status);
+  }
+}
+
+class ExternalCronJob extends CronJob {
+  constructor(name, args, opts) {
+    const cronJob = output(args.namespace).cluster.apply((cluster) => {
+      return batch.v1.CronJob.get(name, interpolate`${output(args.namespace).metadata.name}/${args.name}`, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:ExternalCronJob", name, args, opts, cronJob.metadata, output(args.namespace), output({}), output([]), output(undefined), cronJob.spec, cronJob.status);
+  }
+}
+
+export { CronJob };

package/dist/chunk-z6bmpnm7.js

@@ -0,0 +1,180 @@
+// @bun
+import {
+  Workload,
+  filterPatchOwnedContainersInTemplate,
+  getWorkloadServiceComponents,
+  workloadServiceExtraArgs
+} from "./chunk-h1b79v66.js";
+import {
+  Namespace,
+  getProvider,
+  mapMetadata
+} from "./chunk-facs31cb.js";
+
+// src/stateful-set.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 StatefulSet extends Workload {
+  spec;
+  status;
+  static apiVersion = "apps/v1";
+  static kind = "StatefulSet";
+  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;
+  }
+  get entity() {
+    return makeEntityOutput({
+      entity: k8s.statefulSetEntity,
+      identity: this.metadata.uid,
+      meta: {
+        title: this.metadata.name
+      },
+      value: {
+        ...this.entityBase,
+        service: this.service.entity,
+        spec: this.spec
+      }
+    });
+  }
+  static create(name, args, opts) {
+    return new CreatedStatefulSet(name, args, opts);
+  }
+  static createOrPatch(name, args, opts) {
+    if (args.existing) {
+      return new StatefulSetPatch(name, {
+        ...args,
+        name: output(args.existing).metadata.name,
+        namespace: Namespace.forResourceAsync(args.existing, output(args.namespace).cluster)
+      });
+    }
+    return new CreatedStatefulSet(name, args, opts);
+  }
+  static async createOrGet(name, args, opts) {
+    if (args.existing) {
+      return await StatefulSet.forAsync(args.existing, output(args.namespace).cluster);
+    }
+    return new CreatedStatefulSet(name, args, opts);
+  }
+  static patch(name, args, opts) {
+    return new StatefulSetPatch(name, args, opts);
+  }
+  static wrap(name, args, opts) {
+    return new WrappedStatefulSet(name, args, opts);
+  }
+  static get(name, args, opts) {
+    return new ExternalStatefulSet(name, args, opts);
+  }
+  static statefulSetCache = new Map;
+  static for(entity, cluster) {
+    return getOrCreate(StatefulSet.statefulSetCache, `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`, (name) => {
+      return StatefulSet.get(name, {
+        name: entity.metadata.name,
+        namespace: Namespace.forResource(entity, cluster)
+      });
+    });
+  }
+  static async forAsync(entity, cluster) {
+    const resolvedEntity = await toPromise(entity);
+    return StatefulSet.for(resolvedEntity, cluster);
+  }
+  getTerminalMeta() {
+    return output({
+      title: "StatefulSet",
+      globalTitle: interpolate`StatefulSet | ${this.metadata.name}`,
+      description: "The shell inside the stateful set.",
+      icon: "devicon:kubernetes"
+    });
+  }
+  get resourceType() {
+    return "statefulset";
+  }
+}
+
+class CreatedStatefulSet extends StatefulSet {
+  constructor(name, args, opts) {
+    const { labels, podTemplate, networkPolicy, containers, service, routes } = getWorkloadServiceComponents(name, {
+      ...args,
+      service: output(args.service).apply((service2) => ({ ...service2 }))
+    }, () => this, opts);
+    const statefulSet = output(args.namespace).cluster.apply((cluster) => {
+      return new apps.v1.StatefulSet(name, {
+        metadata: mapMetadata(args, name),
+        spec: output({ args, podTemplate, labels, service }).apply(({ args: args2, podTemplate: podTemplate2, labels: labels2, service: service2 }) => {
+          return deepmerge({
+            serviceName: service2?.metadata.name,
+            template: podTemplate2,
+            selector: { matchLabels: labels2 }
+          }, omit(args2, workloadServiceExtraArgs));
+        })
+      }, {
+        ...opts,
+        parent: this,
+        provider: getProvider(cluster)
+      });
+    });
+    super("highstate:k8s:StatefulSet", name, args, opts, statefulSet.metadata, output(args.namespace), output(args.terminal ?? {}), containers, networkPolicy, service, routes, statefulSet.spec, statefulSet.status);
+  }
+}
+
+class StatefulSetPatch extends StatefulSet {
+  constructor(name, args, opts) {
+    const { podTemplate, networkPolicy, containers, service, routes } = getWorkloadServiceComponents(name, args, () => this, opts, true);
+    const statefulSet = output(args.namespace).cluster.apply((cluster) => {
+      return new apps.v1.StatefulSetPatch(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: statefulSet.spec, podTemplate }).apply(({ spec, podTemplate: podTemplate2 }) => {
+      if (!spec.template) {
+        return spec;
+      }
+      return {
+        ...spec,
+        template: filterPatchOwnedContainersInTemplate(spec.template, podTemplate2)
+      };
+    });
+    super("highstate:k8s:StatefulSetPatch", name, args, opts, statefulSet.metadata, output(args.namespace), output(args.terminal ?? {}), containers, networkPolicy, service, routes, filteredSpec, statefulSet.status);
+  }
+}
+
+class WrappedStatefulSet extends StatefulSet {
+  constructor(name, args, opts) {
+    super("highstate:k8s:WrappedStatefulSet", name, args, opts, output(args.statefulSet).metadata, output(args.namespace), output(args.terminal ?? {}), output([]), output(undefined), output(args.service), output([]), output(args.statefulSet).spec, output(args.statefulSet).status);
+  }
+}
+
+class ExternalStatefulSet extends StatefulSet {
+  constructor(name, args, opts) {
+    const statefulSet = output(args.namespace).cluster.apply((cluster) => {
+      return apps.v1.StatefulSet.get(name, interpolate`${output(args.namespace).metadata.name}/${args.name}`, { ...opts, parent: this, provider: getProvider(cluster) });
+    });
+    super("highstate:k8s:ExternalStatefulSet", name, args, opts, statefulSet.metadata, output(args.namespace), output({}), output([]), output(undefined), output(undefined), output([]), statefulSet.spec, statefulSet.status);
+  }
+}
+
+export { StatefulSet };

package/dist/highstate.manifest.json

@@ -7,7 +7,8 @@
     "./dist/units/existing-cluster/index.js": 2212294583,
     "./dist/units/gateway-api/index.js": 2212294583,
     "./dist/units/reduced-access-cluster/index.js": 2212294583,
-    "./dist/impl/gateway-route.js": 2536376799,
-    "./dist/impl/tls-certificate.js": 105676454
+    "./dist/impl/dynamic-endpoint-resolver.js": 313156426,
+    "./dist/impl/gateway-route.js": 212793152,
+    "./dist/impl/tls-certificate.js": 2224932688
   }
 }

package/dist/impl/dynamic-endpoint-resolver.js

@@ -0,0 +1,91 @@
+// @bun
+import {
+  isEndpointFromCluster
+} from "../chunk-k4w9zpn5.js";
+import"../chunk-facs31cb.js";
+import {
+  __callDispose,
+  __using
+} from "../chunk-b05q6fm2.js";
+
+// src/impl/dynamic-endpoint-resolver.ts
+import { crc32 } from "zlib";
+import {
+  dynamicEndpointResolverMediator,
+  endpointToString,
+  MaterializedFile,
+  parseEndpoint,
+  rebaseEndpoint
+} from "@highstate/common";
+import { z } from "@highstate/contract";
+import { k8s } from "@highstate/library";
+import { getUnitStateId } from "@highstate/pulumi";
+import spawn, { SubprocessError } from "nano-spawn";
+var resolveDynamicEndpoint = dynamicEndpointResolverMediator.implement(z.object({ cluster: k8s.clusterEntity.schema }), async ({ endpoint }, { cluster }) => {
+  if (!isEndpointFromCluster(endpoint, cluster)) {
+    throw new Error(`Endpoint "${endpointToString(endpoint)}" is not from cluster "${cluster.id}"`);
+  }
+  const { name, namespace } = endpoint.metadata["k8s.service"];
+  const localPort = getStablePort(`${cluster.id}:${namespace}:${name}`);
+  let subprocess;
+  return {
+    endpoint: rebaseEndpoint(endpoint, parseEndpoint(`localhost:${localPort}`)),
+    setup: async () => {
+      let __stack = [];
+      try {
+        console.log(`[port-forward] starting port-forward for service "${name}" in namespace "${namespace}" on local port ${localPort}`);
+        const config = MaterializedFile.for(cluster.kubeconfig);
+        const _ = __using(__stack, await config.open(), 1);
+        subprocess = spawn("kubectl", [
+          "--kubeconfig",
+          config.path,
+          "port-forward",
+          `service/${name}`,
+          "-n",
+          namespace,
+          `${localPort}:${endpoint.port}`
+        ]);
+        subprocess.catch((err) => {
+          if (err instanceof SubprocessError && err.signalName === "SIGTERM") {
+            return;
+          }
+          throw err;
+        });
+        const nodeProcess = await subprocess.nodeChildProcess;
+        await new Promise((resolve, reject) => {
+          nodeProcess.stdout?.once("data", (data) => {
+            const output = data.toString();
+            if (output.includes("Forwarding from")) {
+              resolve();
+            } else {
+              reject(new Error(`Failed to start port-forward: ${output}`));
+            }
+          });
+          nodeProcess.stderr?.once("data", (data) => {
+            reject(new Error(`Failed to start port-forward: ${data.toString()}`));
+          });
+        });
+        console.log(`[port-forward] port-forward is ready for service "${name}" in namespace "${namespace}" on local port ${localPort}`);
+      } catch (_catch) {
+        var _err = _catch, _hasErr = 1;
+      } finally {
+        var _promise = __callDispose(__stack, _err, _hasErr);
+        _promise && await _promise;
+      }
+    },
+    dispose: async () => {
+      console.log(`[port-forward] stopping port-forward for service "${name}" in namespace "${namespace}" on local port ${localPort}`);
+      const nodeProcess = await subprocess.nodeChildProcess;
+      nodeProcess.kill();
+    }
+  };
+});
+function getStablePort(id) {
+  const hash = crc32(`${getUnitStateId()}:${id}`);
+  const minPort = 30000;
+  const maxPort = 60000;
+  return Math.abs(hash) % (maxPort - minPort) + minPort;
+}
+export {
+  resolveDynamicEndpoint
+};