@highstate/backend 0.7.4 → 0.7.6

package/dist/index.js

@@ -1,207 +1,57 @@
-import { z } from 'zod';
-import { pickBy, mapKeys, mapValues, omit, pick } from 'remeda';
-import { r as runWithRetryOnError, A as AbortError, s as stringArrayType, c as createAsyncBatcher, i as isAbortErrorLike, e as errorToString, a as isAbortError, t as tryWrapAbortErrorLike } from './utils-ByadNcv4.js';
-import { BetterLock } from 'better-lock';
-import { basename, relative, resolve as resolve$1, dirname } from 'node:path';
-import { findWorkspaceDir, readPackageJSON, resolvePackageJSON } from 'pkg-types';
-import { fileURLToPath } from 'node:url';
-import EventEmitter$1, { EventEmitter, on } from 'node:events';
-import { Worker } from 'node:worker_threads';
-import { readFile, readdir, writeFile, mkdir } from 'node:fs/promises';
-import { isUnitModel, getInstanceId, parseInstanceId } from '@highstate/contract';
-import Watcher from 'watcher';
-import { resolve } from 'import-meta-resolve';
-import { U as diffLibraries, e as hubModelSchema, b as instanceModelSchema, x as createInstanceState, M as createInputResolver, R as createInputHashResolver, r as instanceTerminalSchema, n as instancePageSchema, k as instanceFileSchema, g as instanceStatusFieldSchema, t as instanceTriggerSchema, G as projectOperationSchema, v as instanceStateSchema, H as isFinalOperationStatus, c as compositeInstanceSchema, T as terminalSessionSchema, y as applyPartialInstanceState, z as createInstanceStatePatch } from './library-BW5oPM7V.js';
-import { Readable, PassThrough } from 'node:stream';
-import { tmpdir, homedir } from 'node:os';
-import spawn from 'nano-spawn';
-import { ensureDependencyInstalled } from 'nypm';
-import { sha256 } from 'crypto-hash';
-import { uuidv7 } from 'uuidv7';
-import { webcrypto } from 'node:crypto';
-import { pino } from 'pino';
-import 'ajv';
+import {
+  applyPartialInstanceState,
+  compositeInstanceSchema,
+  createInputHashResolver,
+  createInputResolver,
+  createInstanceState,
+  createInstanceStatePatch,
+  diffLibraries,
+  hubModelSchema,
+  instanceFileSchema,
+  instanceModelSchema,
+  instancePageSchema,
+  instanceStateSchema,
+  instanceStatusFieldSchema,
+  instanceTerminalSchema,
+  instanceTriggerSchema,
+  isFinalOperationStatus,
+  projectOperationSchema,
+  terminalSessionSchema
+} from "./chunk-TDCHA47F.js";
+import {
+  LocalPulumiHost,
+  createAsyncBatcher,
+  errorToString,
+  isAbortError,
+  isAbortErrorLike,
+  resolveMainLocalProject,
+  runWithRetryOnError,
+  stringArrayType,
+  stringToValue,
+  tryWrapAbortErrorLike,
+  updateResourceCount,
+  valueToString
+} from "./chunk-EQ4LMS7B.js";
+import "./chunk-DGUM43GV.js";
 
-class SecretAccessDeniedError extends Error {
+// src/secret/abstractions.ts
+var SecretAccessDeniedError = class extends Error {
   constructor(projectId, key) {
     super(`Access to the secrets of component "${projectId}.${key}" is denied.`);
   }
-}
+};
 
-class LocalPulumiHost {
-  constructor(logger) {
-    this.logger = logger;
-  }
-  lock = new BetterLock();
-  async getCurrentUser() {
-    const { LocalWorkspace } = await import('@pulumi/pulumi/automation/index.js');
-    const workspace = await LocalWorkspace.create({});
-    try {
-      return await workspace.whoAmI();
-    } catch (error) {
-      this.logger.error({ msg: "failed to get current user", error });
-      return null;
-    }
-  }
-  async runEmpty(options, fn, signal) {
-    const { projectId, pulumiProjectName, pulumiStackName, envVars } = options;
-    return await this.lock.acquire(`${pulumiProjectName}.${pulumiStackName}`, async () => {
-      const { LocalWorkspace } = await import('@pulumi/pulumi/automation/index.js');
-      const stack = await LocalWorkspace.createOrSelectStack(
-        {
-          projectName: pulumiProjectName,
-          stackName: pulumiStackName,
-          program: () => Promise.resolve()
-        },
-        {
-          projectSettings: {
-            name: pulumiProjectName,
-            runtime: "nodejs"
-          },
-          envVars: {
-            PULUMI_CONFIG_PASSPHRASE: this.getPassword(projectId),
-            PULUMI_K8S_AWAIT_ALL: "true",
-            ...envVars
-          }
-        }
-      );
-      signal?.throwIfAborted();
-      try {
-        return await runWithRetryOnError(
-          () => fn(stack),
-          (error) => this.tryUnlockStack(stack, error)
-        );
-      } catch (e) {
-        if (e instanceof Error && e.message.includes("canceled")) {
-          throw new AbortError();
-        }
-        throw e;
-      }
-    });
-  }
-  async runLocal(options, fn, signal) {
-    const { projectId, pulumiProjectName, pulumiStackName, projectPath, stackConfig, envVars } = options;
-    return await this.lock.acquire(`${pulumiProjectName}.${pulumiStackName}`, async () => {
-      const { LocalWorkspace } = await import('@pulumi/pulumi/automation/index.js');
-      const stack = await LocalWorkspace.createOrSelectStack(
-        {
-          stackName: pulumiStackName,
-          workDir: projectPath
-        },
-        {
-          projectSettings: {
-            name: pulumiProjectName,
-            runtime: "nodejs"
-          },
-          stackSettings: stackConfig ? {
-            [pulumiStackName]: {
-              config: stackConfig
-            }
-          } : void 0,
-          envVars: {
-            PULUMI_CONFIG_PASSPHRASE: this.getPassword(projectId),
-            PULUMI_K8S_AWAIT_ALL: "true",
-            ...envVars
-          }
-        }
-      );
-      signal?.throwIfAborted();
-      try {
-        return await runWithRetryOnError(
-          () => fn(stack),
-          (error) => this.tryUnlockStack(stack, error)
-        );
-      } catch (e) {
-        if (e instanceof Error && e.message.includes("canceled")) {
-          throw new AbortError();
-        }
-        throw e;
-      }
-    });
-  }
-  sharedPassword = process.env.PULUMI_CONFIG_PASSPHRASE ?? "";
-  passwords = /* @__PURE__ */ new Map();
-  hasPassword(projectId) {
-    return !!this.sharedPassword || this.passwords.has(projectId);
-  }
-  setPassword(projectId, password) {
-    this.passwords.set(projectId, password);
-  }
-  removePassword(projectId) {
-    this.passwords.delete(projectId);
-  }
-  getPassword(projectId) {
-    return this.sharedPassword || this.passwords.get(projectId) || "";
-  }
-  async tryUnlockStack(stack, error) {
-    if (error instanceof Error && error.message.includes("the stack is currently locked")) {
-      this.logger.warn({ stackName: stack.name }, "inlocking stack");
-      await stack.cancel();
-      return true;
-    }
-    return false;
-  }
-  static create(logger) {
-    return new LocalPulumiHost(logger.child({ service: "LocalPulumiHost" }));
-  }
-}
-function valueToString(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  return JSON.stringify(value);
-}
-function stringToValue(value) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-}
-function updateResourceCount(opType, currentCount) {
-  switch (opType) {
-    case "same":
-    case "create":
-    case "update":
-    case "replace":
-    case "create-replacement":
-    case "import":
-    case "import-replacement":
-      return currentCount + 1;
-    case "delete":
-    case "delete-replaced":
-    case "discard":
-    case "discard-replaced":
-    case "remove-pending-replace":
-      return currentCount - 1;
-    case "refresh":
-    case "read-replacement":
-    case "read":
-      return currentCount;
-    default:
-      throw new Error(`Unknown operation type: ${opType}`);
-  }
-}
-
-async function resolveMainLocalProject(projectPath, projectName) {
-  if (!projectPath) {
-    projectPath = await findWorkspaceDir();
-  }
-  if (!projectName) {
-    const packageJson = await readPackageJSON(projectPath);
-    projectName = packageJson.name;
-  }
-  if (!projectName) {
-    projectName = basename(projectPath);
-  }
-  return [projectPath, projectName];
-}
+// src/secret/factory.ts
+import { z as z2 } from "zod";
 
-const localSecretBackendConfig = z.object({
+// src/secret/local.ts
+import { mapKeys, mapValues, pickBy } from "remeda";
+import { z } from "zod";
+var localSecretBackendConfig = z.object({
   HIGHSTATE_BACKEND_SECRET_PROJECT_PATH: z.string().optional(),
   HIGHSTATE_BACKEND_SECRET_PROJECT_NAME: z.string().optional()
 });
-class LocalSecretBackend {
+var LocalSecretBackend = class _LocalSecretBackend {
   constructor(projectPath, projectName, pulumiProjectHost, logger) {
     this.projectPath = projectPath;
     this.projectName = projectName;
@@ -294,17 +144,18 @@ class LocalSecretBackend {
       config.HIGHSTATE_BACKEND_SECRET_PROJECT_PATH,
       config.HIGHSTATE_BACKEND_SECRET_PROJECT_NAME
     );
-    return new LocalSecretBackend(
+    return new _LocalSecretBackend(
       projectPath,
       projectName,
       pulumiProjectHost,
       logger.child({ backend: "SecretBackend", service: "LocalSecretBackend" })
     );
   }
-}
+};
 
-const secretBackendConfig = z.object({
-  HIGHSTATE_BACKEND_SECRET_TYPE: z.enum(["local"]).default("local"),
+// src/secret/factory.ts
+var secretBackendConfig = z2.object({
+  HIGHSTATE_BACKEND_SECRET_TYPE: z2.enum(["local"]).default("local"),
   ...localSecretBackendConfig.shape
 });
 function createSecretBackend(config, localPulumiHost, logger) {
@@ -315,12 +166,27 @@ function createSecretBackend(config, localPulumiHost, logger) {
   }
 }
 
-const localLibraryBackendConfig = z.object({
+// src/library/factory.ts
+import { z as z4 } from "zod";
+
+// src/library/local.ts
+import { fileURLToPath } from "node:url";
+import { EventEmitter, on } from "node:events";
+import { Worker } from "node:worker_threads";
+import { basename, dirname, relative, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { isUnitModel } from "@highstate/contract";
+import Watcher from "watcher";
+import { BetterLock } from "better-lock";
+import { resolve as importMetaResolve } from "import-meta-resolve";
+import { z as z3 } from "zod";
+import { readPackageJSON, resolvePackageJSON } from "pkg-types";
+var localLibraryBackendConfig = z3.object({
   HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES: stringArrayType.default("@highstate/library"),
-  HIGHSTATE_BACKEND_LIBRARY_LOCAL_SOURCE_BASE_PATH: z.string().optional(),
+  HIGHSTATE_BACKEND_LIBRARY_LOCAL_SOURCE_BASE_PATH: z3.string().optional(),
   HIGHSTATE_BACKEND_LIBRARY_LOCAL_EXTRA_SOURCE_WATCH_PATHS: stringArrayType.default("")
 });
-class LocalLibraryBackend {
+var LocalLibraryBackend = class _LocalLibraryBackend {
   constructor(modulePaths, sourceBasePath, extraSourceWatchPaths, logger) {
     this.modulePaths = modulePaths;
     this.sourceBasePath = sourceBasePath;
@@ -402,7 +268,7 @@ class LocalLibraryBackend {
     await this.runSourceResolution(unitsToResolve);
   }
   async runSourceResolution(units) {
-    const workerPathUrl = resolve(
+    const workerPathUrl = importMetaResolve(
       `@highstate/backend/source-resolution-worker`,
       import.meta.url
     );
@@ -517,7 +383,7 @@ class LocalLibraryBackend {
     throw new Error("Worker ended without sending library model");
   }
   createWorker(workerData) {
-    const workerPathUrl = resolve(`@highstate/backend/library-worker`, import.meta.url);
+    const workerPathUrl = importMetaResolve(`@highstate/backend/library-worker`, import.meta.url);
     const workerPath = fileURLToPath(workerPathUrl);
     return new Worker(workerPath, { workerData });
   }
@@ -525,7 +391,7 @@ class LocalLibraryBackend {
     const packageJsonPath = await resolvePackageJSON(path);
     const packageJson = await readPackageJSON(path);
     const library = await this.loadLibrary();
-    const manifestPath = resolve$1(dirname(packageJsonPath), "dist", "highstate.manifest.json");
+    const manifestPath = resolve(dirname(packageJsonPath), "dist", "highstate.manifest.json");
     let manifest;
     try {
       manifest = JSON.parse(await readFile(manifestPath, "utf8"));
@@ -566,7 +432,7 @@ class LocalLibraryBackend {
   static async create(config, logger) {
     const modulePaths = [];
     for (const module of config.HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES) {
-      const url = resolve(module, import.meta.url);
+      const url = importMetaResolve(module, import.meta.url);
       let path = fileURLToPath(url);
       if (basename(path).includes(".")) {
         path = dirname(path);
@@ -577,20 +443,21 @@ class LocalLibraryBackend {
     const extraSourceWatchPaths = config.HIGHSTATE_BACKEND_LIBRARY_LOCAL_EXTRA_SOURCE_WATCH_PATHS;
     if (!sourceBasePath) {
       const [projectPath] = await resolveMainLocalProject();
-      sourceBasePath = resolve$1(projectPath, "units");
+      sourceBasePath = resolve(projectPath, "units");
       extraSourceWatchPaths.push(projectPath);
     }
-    return new LocalLibraryBackend(
+    return new _LocalLibraryBackend(
       modulePaths,
       sourceBasePath,
       extraSourceWatchPaths,
       logger.child({ backend: "LibraryBackend", service: "LocalLibraryBackend" })
     );
   }
-}
+};
 
-const libraryBackendConfig = z.object({
-  HIGHSTATE_BACKEND_LIBRARY_TYPE: z.enum(["local"]).default("local"),
+// src/library/factory.ts
+var libraryBackendConfig = z4.object({
+  HIGHSTATE_BACKEND_LIBRARY_TYPE: z4.enum(["local"]).default("local"),
   ...localLibraryBackendConfig.shape
 });
 async function createLibraryBackend(config, logger) {
@@ -601,14 +468,27 @@ async function createLibraryBackend(config, logger) {
   }
 }
 
-const localProjectBackendConfig = z.object({
-  HIGHSTATE_BACKEND_PROJECT_PROJECTS_DIR: z.string().optional()
+// src/config.ts
+import { z as z15 } from "zod";
+
+// src/project/factory.ts
+import { z as z6 } from "zod";
+
+// src/project/local.ts
+import { mkdir, readdir, readFile as readFile2, writeFile } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+import { z as z5 } from "zod";
+import {
+  getInstanceId
+} from "@highstate/contract";
+var localProjectBackendConfig = z5.object({
+  HIGHSTATE_BACKEND_PROJECT_PROJECTS_DIR: z5.string().optional()
 });
-const projectModelSchema = z.object({
-  instances: z.record(instanceModelSchema),
-  hubs: z.record(hubModelSchema)
+var projectModelSchema = z5.object({
+  instances: z5.record(instanceModelSchema),
+  hubs: z5.record(hubModelSchema)
 });
-class LocalProjectBackend {
+var LocalProjectBackend = class _LocalProjectBackend {
   constructor(projectsDir) {
     this.projectsDir = projectsDir;
   }
@@ -857,7 +737,7 @@ class LocalProjectBackend {
   async loadProject(projectId) {
     const projectPath = this.getProjectPath(projectId);
     try {
-      const content = await readFile(projectPath, "utf-8");
+      const content = await readFile2(projectPath, "utf-8");
       return projectModelSchema.parse(JSON.parse(content));
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -890,22 +770,25 @@ class LocalProjectBackend {
     let projectsPath = config.HIGHSTATE_BACKEND_PROJECT_PROJECTS_DIR;
     if (!projectsPath) {
       const [mainProjectPath] = await resolveMainLocalProject();
-      projectsPath = resolve$1(mainProjectPath, "projects");
+      projectsPath = resolve2(mainProjectPath, "projects");
     }
     await mkdir(projectsPath, { recursive: true });
-    return new LocalProjectBackend(projectsPath);
+    return new _LocalProjectBackend(projectsPath);
   }
-}
+};
 
-const projectBackendConfig = z.object({
-  HIGHSTATE_BACKEND_PROJECT_TYPE: z.enum(["local"]).default("local"),
+// src/project/factory.ts
+var projectBackendConfig = z6.object({
+  HIGHSTATE_BACKEND_PROJECT_TYPE: z6.enum(["local"]).default("local"),
   ...localProjectBackendConfig.shape
 });
 function createProjectBackend(config) {
   return LocalProjectBackend.create(config);
 }
 
-class ProjectLock {
+// src/project/lock.ts
+import { BetterLock as BetterLock2 } from "better-lock";
+var ProjectLock = class {
   constructor(lock, projectId) {
     this.lock = lock;
     this.projectId = projectId;
@@ -930,15 +813,18 @@ class ProjectLock {
       fn
     );
   }
-}
-class ProjectLockManager {
-  lock = new BetterLock();
+};
+var ProjectLockManager = class {
+  lock = new BetterLock2();
   getLock(projectId) {
     return new ProjectLock(this.lock, projectId);
   }
-}
+};
 
-class ProjectManager {
+// src/project/manager.ts
+import { EventEmitter as EventEmitter2, on as on2 } from "node:events";
+import { isUnitModel as isUnitModel2 } from "@highstate/contract";
+var ProjectManager = class _ProjectManager {
   constructor(projectBackend, stateBackend, libraryBackend, projectLockManager, stateManager, logger) {
     this.projectBackend = projectBackend;
     this.stateBackend = stateBackend;
@@ -948,9 +834,9 @@ class ProjectManager {
     this.logger = logger;
     void this.watchLibraryChanges();
   }
-  compositeInstanceEE = new EventEmitter();
+  compositeInstanceEE = new EventEmitter2();
   async *watchCompositeInstances(projectId, signal) {
-    for await (const [children] of on(this.compositeInstanceEE, projectId, {
+    for await (const [children] of on2(this.compositeInstanceEE, projectId, {
       signal
     })) {
       yield children;
@@ -983,7 +869,7 @@ class ProjectManager {
     if (!component) {
       return;
     }
-    if (isUnitModel(component)) {
+    if (isUnitModel2(component)) {
       return;
     }
     const { inputHash: expectedInputHash } = await resolveInputHash(instance.id);
@@ -1099,7 +985,7 @@ class ProjectManager {
         throw new Error("Expected instance node");
       }
       let sourceHash;
-      if (isUnitModel(library.components[instance.type])) {
+      if (isUnitModel2(library.components[instance.type])) {
         const resolvedUnit = await this.libraryBackend.getResolvedUnitSource(instance.type);
         if (!resolvedUnit) {
           throw new Error(`Resolved unit not found: ${instance.type}`);
@@ -1157,7 +1043,7 @@ class ProjectManager {
     for (const projectId of projects) {
       const { resolveInputHash, instances } = await this.prepareInputHashResolver(projectId);
       const filteredInstances = instances.filter(
-        (instance) => changedComponents.has(instance.type) && library.components[instance.type] && !isUnitModel(library.components[instance.type])
+        (instance) => changedComponents.has(instance.type) && library.components[instance.type] && !isUnitModel2(library.components[instance.type])
       );
       this.logger.info(
         { projectId, filteredInstanceIds: filteredInstances.map((instance) => instance.id) },
@@ -1179,7 +1065,7 @@ class ProjectManager {
     }
   }
   static create(projectBackend, stateBackend, libraryBackend, projectLockManager, stateManager, logger) {
-    return new ProjectManager(
+    return new _ProjectManager(
       projectBackend,
       stateBackend,
       libraryBackend,
@@ -1188,9 +1074,21 @@ class ProjectManager {
       logger.child({ service: "ProjectManager" })
     );
   }
-}
+};
 
-const runScript = `set -e -o pipefail
+// src/terminal/factory.ts
+import { z as z8 } from "zod";
+
+// src/terminal/docker.ts
+import { Readable } from "node:stream";
+import { tmpdir } from "node:os";
+import { resolve as resolve3 } from "node:path";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { z as z7 } from "zod";
+import spawn from "nano-spawn";
+
+// src/terminal/run.sh.ts
+var runScript = `set -e -o pipefail
 read -r data
 
 # Extract env and files as key-value pairs, and command as an array
@@ -1228,12 +1126,13 @@ cmd=$(printf "%q " "\${commandArr[@]}")
 exec script -q -c "stty cols $cols rows $rows; $cmd" /dev/null
 `;
 
-const dockerTerminalBackendConfig = z.object({
-  HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY: z.string().default("docker"),
-  HIGHSTATE_BACKEND_TERMINAL_DOCKER_USE_SUDO: z.coerce.boolean().default(false),
-  HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST: z.string().optional()
+// src/terminal/docker.ts
+var dockerTerminalBackendConfig = z7.object({
+  HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY: z7.string().default("docker"),
+  HIGHSTATE_BACKEND_TERMINAL_DOCKER_USE_SUDO: z7.coerce.boolean().default(false),
+  HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST: z7.string().optional()
 });
-class DockerTerminalBackend {
+var DockerTerminalBackend = class _DockerTerminalBackend {
   constructor(binary, useSudo, host, logger) {
     this.binary = binary;
     this.useSudo = useSudo;
@@ -1241,10 +1140,10 @@ class DockerTerminalBackend {
     this.logger = logger;
   }
   async run({ factory, stdin, stdout, screenSize, signal }) {
-    const hsTempDir = resolve$1(tmpdir(), "highstate");
-    await mkdir(hsTempDir, { recursive: true });
-    const runScriptPath = resolve$1(hsTempDir, "run.sh");
-    await writeFile(runScriptPath, runScript, { mode: 493 });
+    const hsTempDir = resolve3(tmpdir(), "highstate");
+    await mkdir2(hsTempDir, { recursive: true });
+    const runScriptPath = resolve3(hsTempDir, "run.sh");
+    await writeFile2(runScriptPath, runScript, { mode: 493 });
     const args = [
       "run",
       "-i",
@@ -1268,32 +1167,33 @@ class DockerTerminalBackend {
     if (this.useSudo) {
       args.unshift(this.binary);
     }
-    const process = spawn(this.useSudo ? "sudo" : this.binary, args, {
+    const process2 = spawn(this.useSudo ? "sudo" : this.binary, args, {
       env: {
         DOCKER_HOST: this.host
       },
       signal
     });
-    const childProcess = await process.nodeChildProcess;
+    const childProcess = await process2.nodeChildProcess;
     initDataStream.pipe(childProcess.stdin, { end: false });
     initDataStream.on("end", () => stdin.pipe(childProcess.stdin));
     childProcess.stdout.pipe(stdout);
     childProcess.stderr.pipe(stdout);
     this.logger.info({ pid: childProcess.pid }, "process started");
-    await process;
+    await process2;
   }
   static create(config, logger) {
-    return new DockerTerminalBackend(
+    return new _DockerTerminalBackend(
       config.HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY,
       config.HIGHSTATE_BACKEND_TERMINAL_DOCKER_USE_SUDO,
       config.HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST,
       logger.child({ backend: "TerminalBackend", service: "DockerTerminalBackend" })
     );
   }
-}
+};
 
-const terminalBackendConfig = z.object({
-  HIGHSTATE_BACKEND_TERMINAL_TYPE: z.enum(["docker"]).default("docker"),
+// src/terminal/factory.ts
+var terminalBackendConfig = z8.object({
+  HIGHSTATE_BACKEND_TERMINAL_TYPE: z8.enum(["docker"]).default("docker"),
   ...dockerTerminalBackendConfig.shape
 });
 function createTerminalBackend(config, logger) {
@@ -1304,17 +1204,28 @@ function createTerminalBackend(config, logger) {
   }
 }
 
-const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+// src/terminal/manager.ts
+import { PassThrough } from "node:stream";
+import { EventEmitter as EventEmitter3, on as on3 } from "node:events";
+import { parseInstanceId } from "@highstate/contract";
 
-const POOL_SIZE_MULTIPLIER = 128;
-let pool, poolOffset;
+// ../../node_modules/nanoid/index.js
+import { webcrypto as crypto } from "node:crypto";
+
+// ../../node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
 function fillPool(bytes) {
   if (!pool || pool.length < bytes) {
     pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    webcrypto.getRandomValues(pool);
+    crypto.getRandomValues(pool);
     poolOffset = 0;
   } else if (poolOffset + bytes > pool.length) {
-    webcrypto.getRandomValues(pool);
+    crypto.getRandomValues(pool);
     poolOffset = 0;
   }
   poolOffset += bytes;
@@ -1328,8 +1239,9 @@ function nanoid(size = 21) {
   return id;
 }
 
-const notAttachedTerminalLifetime = 5 * 60 * 1e3;
-class TerminalManager {
+// src/terminal/manager.ts
+var notAttachedTerminalLifetime = 5 * 60 * 1e3;
+var TerminalManager = class _TerminalManager {
   constructor(terminalBackend, stateBackend, runnerBackend, logger) {
     this.terminalBackend = terminalBackend;
     this.stateBackend = stateBackend;
@@ -1339,7 +1251,7 @@ class TerminalManager {
   }
   managedTerminals = /* @__PURE__ */ new Map();
   existingSessions = /* @__PURE__ */ new Map();
-  terminalEE = new EventEmitter();
+  terminalEE = new EventEmitter3();
   isSessionActive(sessionId) {
     return this.managedTerminals.has(sessionId);
   }
@@ -1354,7 +1266,7 @@ class TerminalManager {
       return;
     }
     yield managedTerminal.session;
-    for await (const [terminalSession] of on(this.terminalEE, sessionId, {
+    for await (const [terminalSession] of on3(this.terminalEE, sessionId, {
       signal
     })) {
       yield terminalSession;
@@ -1517,7 +1429,7 @@ class TerminalManager {
     setTimeout(() => this.closeTerminalIfNotAttached(terminal), notAttachedTerminalLifetime);
   }
   static create(terminalBackend, stateBackend, runnerBackend, logger) {
-    return new TerminalManager(
+    return new _TerminalManager(
       terminalBackend,
       stateBackend,
       runnerBackend,
@@ -1538,23 +1450,35 @@ class TerminalManager {
     }
     await this.updateActiveTerminalSessions();
   }
-}
+};
 
-class InvalidInstanceStatusError extends Error {
+// src/runner/abstractions.ts
+var InvalidInstanceStatusError = class extends Error {
   constructor(currentStatus, expectedStatuses) {
     const expectedString = expectedStatuses.join(", ");
     super(`The current state is "${currentStatus}", but it should be one of "${expectedString}".`);
     this.currentStatus = currentStatus;
     this.expectedStatuses = expectedStatuses;
   }
-}
+};
+
+// src/runner/factory.ts
+import { z as z10 } from "zod";
 
-const localRunnerBackendConfig = z.object({
-  HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK: z.boolean({ coerce: true }).default(false),
-  HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT: z.boolean({ coerce: true }).default(true),
-  HIGHSTATE_BACKEND_RUNNER_LOCAL_CACHE_DIR: z.string().optional()
+// src/runner/local.ts
+import { EventEmitter as EventEmitter4, on as on4 } from "node:events";
+import { resolve as resolve4 } from "node:path";
+import { getInstanceId as getInstanceId2 } from "@highstate/contract";
+import { ensureDependencyInstalled } from "nypm";
+import { mapValues as mapValues2, omit, pick, pickBy as pickBy2 } from "remeda";
+import { z as z9 } from "zod";
+import { sha256 } from "crypto-hash";
+var localRunnerBackendConfig = z9.object({
+  HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK: z9.boolean({ coerce: true }).default(false),
+  HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT: z9.boolean({ coerce: true }).default(true),
+  HIGHSTATE_BACKEND_RUNNER_LOCAL_CACHE_DIR: z9.string().optional()
 });
-class LocalRunnerBackend {
+var LocalRunnerBackend = class _LocalRunnerBackend {
   constructor(skipStateCheck, printOutput, cacheDir, pulumiProjectHost, libraryBackend) {
     this.skipStateCheck = skipStateCheck;
     this.printOutput = printOutput;
@@ -1562,12 +1486,12 @@ class LocalRunnerBackend {
     this.pulumiProjectHost = pulumiProjectHost;
     this.libraryBackend = libraryBackend;
   }
-  events = new EventEmitter();
+  events = new EventEmitter4();
   async *watch(options) {
-    const stream = on(
+    const stream = on4(
       //
       this.events,
-      `state:${LocalRunnerBackend.getInstanceId(options)}`,
+      `state:${_LocalRunnerBackend.getInstanceId(options)}`,
       { signal: options.signal }
     );
     for await (const [statePatch] of stream) {
@@ -1582,11 +1506,11 @@ class LocalRunnerBackend {
       {
         projectId: options.projectId,
         pulumiProjectName: options.instanceType,
-        pulumiStackName: LocalRunnerBackend.getStackName(options)
+        pulumiStackName: _LocalRunnerBackend.getStackName(options)
       },
       async (stack) => {
         const info = await stack.info();
-        const instanceId = getInstanceId(options.instanceType, options.instanceName);
+        const instanceId = getInstanceId2(options.instanceType, options.instanceName);
         if (!info) {
           return createInstanceState(instanceId);
         }
@@ -1613,14 +1537,14 @@ class LocalRunnerBackend {
       {
         projectId: options.projectId,
         pulumiProjectName: options.instanceType,
-        pulumiStackName: LocalRunnerBackend.getStackName(options)
+        pulumiStackName: _LocalRunnerBackend.getStackName(options)
       },
       async (stack) => {
         const outputs = await stack.outputs();
         if (!outputs["$terminals"]) {
           return null;
         }
-        const terminals = z.array(instanceTerminalSchema).parse(outputs["$terminals"].value);
+        const terminals = z9.array(instanceTerminalSchema).parse(outputs["$terminals"].value);
         const terminal = terminals.find((t) => t.name === terminalName);
         if (!terminal) {
           return null;
@@ -1634,14 +1558,14 @@ class LocalRunnerBackend {
       {
         projectId: options.projectId,
         pulumiProjectName: options.instanceType,
-        pulumiStackName: LocalRunnerBackend.getStackName(options)
+        pulumiStackName: _LocalRunnerBackend.getStackName(options)
       },
       async (stack) => {
         const outputs = await stack.outputs();
         if (!outputs["$pages"]) {
           return null;
         }
-        const pages = z.array(instancePageSchema).parse(outputs["$pages"].value);
+        const pages = z9.array(instancePageSchema).parse(outputs["$pages"].value);
         const page = pages.find((p) => p.name === pageName);
         if (!page) {
           return null;
@@ -1655,14 +1579,14 @@ class LocalRunnerBackend {
       {
         projectId: options.projectId,
         pulumiProjectName: options.instanceType,
-        pulumiStackName: LocalRunnerBackend.getStackName(options)
+        pulumiStackName: _LocalRunnerBackend.getStackName(options)
       },
       async (stack) => {
         const outputs = await stack.outputs();
         if (!outputs["$files"]) {
           return null;
         }
-        const files = z.array(instanceFileSchema).parse(outputs["$files"].value);
+        const files = z9.array(instanceFileSchema).parse(outputs["$files"].value);
         const file = files.find((f) => f.meta.name === fileName);
         if (!file) {
           return null;
@@ -1682,8 +1606,8 @@ class LocalRunnerBackend {
       return;
     }
     const configMap = {
-      ...mapValues(options.config, (value) => ({ value })),
-      ...mapValues(options.secrets, (value) => ({ value, secret: true }))
+      ...mapValues2(options.config, (value) => ({ value })),
+      ...mapValues2(options.secrets, (value) => ({ value, secret: true }))
     };
     void this.updateWorker(options, configMap, false);
   }
@@ -1698,13 +1622,13 @@ class LocalRunnerBackend {
       return;
     }
     const configMap = {
-      ...mapValues(options.config, (value) => ({ value })),
-      ...mapValues(options.secrets, (value) => ({ value, secret: true }))
+      ...mapValues2(options.config, (value) => ({ value })),
+      ...mapValues2(options.secrets, (value) => ({ value, secret: true }))
     };
     void this.updateWorker(options, configMap, true);
   }
   async updateWorker(options, configMap, preview) {
-    const instanceId = LocalRunnerBackend.getInstanceId(options);
+    const instanceId = _LocalRunnerBackend.getInstanceId(options);
     try {
       const resolvedSource = await this.libraryBackend.getResolvedUnitSource(options.instanceType);
       if (!resolvedSource) {
@@ -1714,7 +1638,7 @@ class LocalRunnerBackend {
         {
           projectId: options.projectId,
           pulumiProjectName: options.instanceType,
-          pulumiStackName: LocalRunnerBackend.getStackName(options),
+          pulumiStackName: _LocalRunnerBackend.getStackName(options),
           projectPath: resolvedSource.projectPath,
           stackConfig: configMap,
           envVars: {
@@ -1811,7 +1735,7 @@ class LocalRunnerBackend {
     void this.destroyWorker(options);
   }
   async destroyWorker(options) {
-    const instanceId = LocalRunnerBackend.getInstanceId(options);
+    const instanceId = _LocalRunnerBackend.getInstanceId(options);
     try {
       const resolvedSource = await this.libraryBackend.getResolvedUnitSource(options.instanceType);
       if (!resolvedSource) {
@@ -1821,7 +1745,7 @@ class LocalRunnerBackend {
         {
           projectId: options.projectId,
           pulumiProjectName: options.instanceType,
-          pulumiStackName: LocalRunnerBackend.getStackName(options),
+          pulumiStackName: _LocalRunnerBackend.getStackName(options),
           projectPath: resolvedSource.projectPath,
           envVars: {
             HIGHSTATE_CACHE_DIR: this.cacheDir,
@@ -1874,7 +1798,7 @@ class LocalRunnerBackend {
         }
       );
     } catch (error) {
-      const { StackNotFoundError } = await import('@pulumi/pulumi/automation/index.js');
+      const { StackNotFoundError } = await import("@pulumi/pulumi/automation/index.js");
       if (error instanceof StackNotFoundError) {
         this.updateState({
           id: instanceId,
@@ -1909,13 +1833,13 @@ class LocalRunnerBackend {
     void this.refreshWorker(options);
   }
   async refreshWorker(options) {
-    const instanceId = LocalRunnerBackend.getInstanceId(options);
+    const instanceId = _LocalRunnerBackend.getInstanceId(options);
     try {
       await this.pulumiProjectHost.runEmpty(
         {
           projectId: options.projectId,
           pulumiProjectName: options.instanceType,
-          pulumiStackName: LocalRunnerBackend.getStackName(options)
+          pulumiStackName: _LocalRunnerBackend.getStackName(options)
         },
         async (stack) => {
           const summary = await stack.workspace.stack();
@@ -1981,36 +1905,36 @@ class LocalRunnerBackend {
     const outputs = await stack.outputs();
     const patch = {};
     if (outputs["$status"]) {
-      patch.statusFields = z.array(instanceStatusFieldSchema).parse(outputs["$status"].value);
+      patch.statusFields = z9.array(instanceStatusFieldSchema).parse(outputs["$status"].value);
     } else {
       patch.statusFields = [];
     }
     if (outputs["$pages"]) {
-      const pages = z.array(instancePageSchema).parse(outputs["$pages"].value);
+      const pages = z9.array(instancePageSchema).parse(outputs["$pages"].value);
       patch.pages = pages.map((page) => omit(page, ["content"]));
     } else {
       patch.pages = [];
     }
     if (outputs["$files"]) {
-      const files = z.array(instanceFileSchema).parse(outputs["$files"].value);
+      const files = z9.array(instanceFileSchema).parse(outputs["$files"].value);
       patch.files = files.map((file) => file.meta);
     } else {
       patch.files = [];
     }
     if (outputs["$terminals"]) {
-      const terminals = z.array(instanceTerminalSchema).parse(outputs["$terminals"].value);
+      const terminals = z9.array(instanceTerminalSchema).parse(outputs["$terminals"].value);
       patch.terminals = terminals.map((terminal) => pick(terminal, ["name", "title", "description"]));
     } else {
       patch.terminals = [];
     }
     if (outputs["$triggers"]) {
-      patch.triggers = z.array(instanceTriggerSchema).parse(outputs["$triggers"].value);
+      patch.triggers = z9.array(instanceTriggerSchema).parse(outputs["$triggers"].value);
     } else {
       patch.triggers = [];
     }
     if (outputs["$secrets"]) {
-      patch.secrets = pickBy(
-        z.record(z.string().nullish()).parse(outputs["$secrets"].value),
+      patch.secrets = pickBy2(
+        z9.record(z9.string().nullish()).parse(outputs["$secrets"].value),
         (v) => !!v
       );
     } else {
@@ -2036,7 +1960,7 @@ class LocalRunnerBackend {
     return existingState.status;
   }
   static getInstanceId(options) {
-    return getInstanceId(options.instanceType, options.instanceName);
+    return getInstanceId2(options.instanceType, options.instanceName);
   }
   async tryInstallMissingDependencies(error, allowedDependencies) {
     if (!(error instanceof Error)) {
@@ -2068,9 +1992,9 @@ class LocalRunnerBackend {
           "Failed to determine the home directory, please set HIGHSTATE_BACKEND_RUNNER_LOCAL_CACHE_DIR"
         );
       }
-      cacheDir = resolve$1(homeDir, ".cache", "highstate");
+      cacheDir = resolve4(homeDir, ".cache", "highstate");
     }
-    return new LocalRunnerBackend(
+    return new _LocalRunnerBackend(
       config.HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK,
       config.HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT,
       cacheDir,
@@ -2078,10 +2002,11 @@ class LocalRunnerBackend {
       libraryBackend
     );
   }
-}
+};
 
-const runnerBackendConfig = z.object({
-  HIGHSTATE_BACKEND_RUNNER_TYPE: z.enum(["local"]).default("local"),
+// src/runner/factory.ts
+var runnerBackendConfig = z10.object({
+  HIGHSTATE_BACKEND_RUNNER_TYPE: z10.enum(["local"]).default("local"),
   ...localRunnerBackendConfig.shape
 });
 function createRunnerBackend(config, pulumiProjectHost, libraryBackend) {
@@ -2092,10 +2017,17 @@ function createRunnerBackend(config, pulumiProjectHost, libraryBackend) {
   }
 }
 
-const localStateBackendConfig = z.object({
-  HIGHSTATE_BACKEND_STATE_LOCAL_DIR: z.string().optional()
+// src/state/factory.ts
+import { z as z12 } from "zod";
+
+// src/state/local.ts
+import { resolve as resolve5 } from "node:path";
+import { z as z11 } from "zod";
+import { uuidv7 } from "uuidv7";
+var localStateBackendConfig = z11.object({
+  HIGHSTATE_BACKEND_STATE_LOCAL_DIR: z11.string().optional()
 });
-class LocalStateBackend {
+var LocalStateBackend = class _LocalStateBackend {
   constructor(db, logger) {
     this.db = db;
     this.logger = logger;
@@ -2227,7 +2159,7 @@ class LocalStateBackend {
   async putCompositeInstances(projectId, instances) {
     this.validateArray(compositeInstanceSchema, instances);
     const sublevel = this.getProjectCompositeInstancesSublevel(projectId);
-    this.getProjectCompositeInstanceInputHashesSublevel(projectId);
+    const inputHashesSublevel = this.getProjectCompositeInstanceInputHashesSublevel(projectId);
     await this.db.batch(
       instances.flatMap((instance) => [
         {
@@ -2252,7 +2184,7 @@ class LocalStateBackend {
   async getTopLevelCompositeChildrenIds(projectId, instanceIds) {
     const sublevel = this.getProjectCompositeChildrenIdsSublevel(projectId);
     const items = await sublevel.getMany(instanceIds);
-    const schema = z.array(z.string()).optional();
+    const schema = z11.array(z11.string()).optional();
     const result = {};
     for (let i = 0; i < items.length; i++) {
       const instanceId = instanceIds[i];
@@ -2263,7 +2195,7 @@ class LocalStateBackend {
   }
   async putTopLevelCompositeChildrenIds(projectId, childrenIds) {
     const sublevel = this.getProjectCompositeChildrenIdsSublevel(projectId);
-    const schema = z.array(z.string()).optional();
+    const schema = z11.array(z11.string()).optional();
     await sublevel.batch(
       Object.entries(childrenIds).map(([instanceId, ids]) => ({
         type: "put",
@@ -2274,7 +2206,7 @@ class LocalStateBackend {
   }
   async getActiveTerminalSessions() {
     const data = await this.db.get("activeTerminalSessionIds", { valueEncoding: "json" });
-    return data ? z.array(terminalSessionSchema).parse(data) : [];
+    return data ? z11.array(terminalSessionSchema).parse(data) : [];
   }
   putActiveTerminalSessions(sessions) {
     this.validateArray(terminalSessionSchema, sessions);
@@ -2469,21 +2401,22 @@ class LocalStateBackend {
         );
       }
       const path = currentUser.url.replace("file://", "").replace("~", process.env.HOME);
-      location = resolve$1(path, ".pulumi", ".highstate");
+      location = resolve5(path, ".pulumi", ".highstate");
       childLogger.debug({
         msg: "auto-detected state location",
         pulumiStateUrl: currentUser.url,
         location
       });
     }
-    const { ClassicLevel } = await import('classic-level');
+    const { ClassicLevel } = await import("classic-level");
     const db = new ClassicLevel(location);
-    return new LocalStateBackend(db, childLogger);
+    return new _LocalStateBackend(db, childLogger);
   }
-}
+};
 
-const stateBackendConfig = z.object({
-  HIGHSTATE_BACKEND_STATE_TYPE: z.enum(["local"]).default("local"),
+// src/state/factory.ts
+var stateBackendConfig = z12.object({
+  HIGHSTATE_BACKEND_STATE_TYPE: z12.enum(["local"]).default("local"),
   ...localStateBackendConfig.shape
 });
 function createStateBackend(config, localPulumiHost, logger) {
@@ -2494,8 +2427,10 @@ function createStateBackend(config, localPulumiHost, logger) {
   }
 }
 
-class StateManager {
-  stateEE = new EventEmitter$1();
+// src/state/manager.ts
+import EventEmitter5, { on as on5 } from "node:events";
+var StateManager = class {
+  stateEE = new EventEmitter5();
   /**
    * Watches for all instance state changes in the project.
    *
@@ -2503,7 +2438,7 @@ class StateManager {
    * @param signal The signal to abort the operation.
    */
   async *watchInstanceStates(projectId, signal) {
-    for await (const [state] of on(this.stateEE, projectId, { signal })) {
+    for await (const [state] of on5(this.stateEE, projectId, { signal })) {
       yield state;
     }
   }
@@ -2516,12 +2451,19 @@ class StateManager {
   emitStatePatch(projectId, patch) {
     this.stateEE.emit(projectId, patch);
   }
-}
+};
+
+// src/workspace/factory.ts
+import { z as z14 } from "zod";
 
-const localWorkspaceBackendConfig = z.object({
-  HIGHSTATE_BACKEND_WORKSPACE_LOCAL_DIR: z.string().optional()
+// src/workspace/local.ts
+import { homedir } from "node:os";
+import { resolve as resolve6 } from "node:path";
+import { z as z13 } from "zod";
+var localWorkspaceBackendConfig = z13.object({
+  HIGHSTATE_BACKEND_WORKSPACE_LOCAL_DIR: z13.string().optional()
 });
-class LocalWorkspaceBackend {
+var LocalWorkspaceBackend = class _LocalWorkspaceBackend {
   constructor(db) {
     this.db = db;
   }
@@ -2547,27 +2489,29 @@ class LocalWorkspaceBackend {
     let location = config.HIGHSTATE_BACKEND_WORKSPACE_LOCAL_DIR;
     if (!location) {
       const home = homedir();
-      location = resolve$1(home, ".highstate/workspace");
+      location = resolve6(home, ".highstate/workspace");
     }
-    const { ClassicLevel } = await import('classic-level');
+    const { ClassicLevel } = await import("classic-level");
     const db = new ClassicLevel(location, { valueEncoding: "json" });
-    return new LocalWorkspaceBackend(db);
+    return new _LocalWorkspaceBackend(db);
   }
-}
+};
 
-const workspaceBackendConfig = z.object({
-  HIGHSTATE_BACKEND_WORKSPACE_TYPE: z.enum(["local"]).default("local"),
+// src/workspace/factory.ts
+var workspaceBackendConfig = z14.object({
+  HIGHSTATE_BACKEND_WORKSPACE_TYPE: z14.enum(["local"]).default("local"),
   ...localWorkspaceBackendConfig.shape
 });
 function createWorkspaceBackend(config) {
   return LocalWorkspaceBackend.create(config);
 }
 
-const loggerConfig = z.object({
-  HIGHSTATE_BACKEND_LOGGER_NAME: z.string().default("highstate-backend"),
-  HIGHSTATE_BACKEND_LOGGER_LEVEL: z.enum(["fatal", "error", "warn", "info", "debug", "trace"]).default("info")
+// src/config.ts
+var loggerConfig = z15.object({
+  HIGHSTATE_BACKEND_LOGGER_NAME: z15.string().default("highstate-backend"),
+  HIGHSTATE_BACKEND_LOGGER_LEVEL: z15.enum(["fatal", "error", "warn", "info", "debug", "trace"]).default("info")
 });
-const configSchema = z.object({
+var configSchema = z15.object({
   ...libraryBackendConfig.shape,
   ...projectBackendConfig.shape,
   ...secretBackendConfig.shape,
@@ -2579,12 +2523,22 @@ const configSchema = z.object({
 });
 async function loadConfig(env = process.env, useDotenv = true) {
   if (useDotenv) {
-    await import('dotenv/config');
+    await import("dotenv/config");
   }
   return configSchema.parse(env);
 }
 
-class OperationWorkset {
+// src/orchestrator/manager.ts
+import { EventEmitter as EventEmitter6, on as on6 } from "node:events";
+import { uuidv7 as uuidv72 } from "uuidv7";
+
+// src/orchestrator/operation.ts
+import { isUnitModel as isUnitModel4, parseInstanceId as parseInstanceId2 } from "@highstate/contract";
+import { mapValues as mapValues3 } from "remeda";
+
+// src/orchestrator/operation-workset.ts
+import { isUnitModel as isUnitModel3 } from "@highstate/contract";
+var OperationWorkset = class _OperationWorkset {
   constructor(operation, library, stateManager, logger) {
     this.operation = operation;
     this.library = library;
@@ -2805,7 +2759,7 @@ class OperationWorkset {
     this.operation.affectedInstanceIds = Array.from(this.affectedInstanceIdSet);
   }
   getSourceHashIfApplicable(instance, component) {
-    if (isUnitModel(component)) {
+    if (isUnitModel3(component)) {
       return this.unitSourceHashMap.get(instance.type);
     }
     return void 0;
@@ -2841,7 +2795,7 @@ class OperationWorkset {
       stateBackend.getCompositeInstances(operation.projectId, signal),
       stateBackend.getAllInstanceStates(operation.projectId, signal)
     ]);
-    const workset = new OperationWorkset(
+    const workset = new _OperationWorkset(
       operation,
       library,
       stateManager,
@@ -2926,9 +2880,10 @@ class OperationWorkset {
     }
     return workset;
   }
-}
+};
 
-class RuntimeOperation {
+// src/orchestrator/operation.ts
+var RuntimeOperation = class {
   constructor(operation, runnerBackend, stateBackend, libraryBackend, projectBackend, secretBackend, projectLock, stateManager, operationEE, instanceLogsEE, logger) {
     this.operation = operation;
     this.runnerBackend = runnerBackend;
@@ -3032,7 +2987,7 @@ class RuntimeOperation {
   getInstancePromiseForOperation(instanceId) {
     const instance = this.workset.getInstance(instanceId);
     const component = this.workset.library.components[instance.type];
-    if (isUnitModel(component)) {
+    if (isUnitModel4(component)) {
       return this.getUnitPromise(instance);
     }
     return this.getCompositePromise(instance);
@@ -3135,7 +3090,7 @@ class RuntimeOperation {
         instanceName: instance.name,
         config: this.prepareUnitConfig(instance),
         refresh: this.operation.options.refresh,
-        secrets: mapValues(secrets, (value) => valueToString(value)),
+        secrets: mapValues3(secrets, (value) => valueToString(value)),
         signal: this.abortController.signal
       });
       logger.debug("unit update requested");
@@ -3200,7 +3155,7 @@ class RuntimeOperation {
       instanceName: instance.name,
       config: this.prepareUnitConfig(instance, invokedTriggers),
       refresh: this.operation.options.refresh,
-      secrets: mapValues(secrets, (value) => valueToString(value)),
+      secrets: mapValues3(secrets, (value) => valueToString(value)),
       signal: this.abortController.signal
     });
     logger.debug("unit update requested");
@@ -3235,7 +3190,7 @@ class RuntimeOperation {
       this.abortController.signal.throwIfAborted();
       await this.processBeforeDestroyTriggers(state, logger);
       logger.info("destroying unit...");
-      const [type, name] = parseInstanceId(instanceId);
+      const [type, name] = parseInstanceId2(instanceId);
       await this.runnerBackend.destroy({
         projectId: this.operation.projectId,
         instanceType: type,
@@ -3266,7 +3221,7 @@ class RuntimeOperation {
         totalResourceCount: 0
       });
       logger.info("refreshing unit...");
-      const [type, name] = parseInstanceId(instanceId);
+      const [type, name] = parseInstanceId2(instanceId);
       await this.runnerBackend.refresh({
         projectId: this.operation.projectId,
         instanceType: type,
@@ -3398,9 +3353,10 @@ class RuntimeOperation {
       }
     }
   );
-}
+};
 
-class OperationManager {
+// src/orchestrator/manager.ts
+var OperationManager = class _OperationManager {
   constructor(runnerBackend, stateBackend, libraryBackend, projectBackend, secretBackend, projectLockManager, stateManager, logger) {
     this.runnerBackend = runnerBackend;
     this.stateBackend = stateBackend;
@@ -3411,8 +3367,8 @@ class OperationManager {
     this.stateManager = stateManager;
     this.logger = logger;
   }
-  operationEE = new EventEmitter();
-  instanceLogsEE = new EventEmitter();
+  operationEE = new EventEmitter6();
+  instanceLogsEE = new EventEmitter6();
   runtimeOperations = /* @__PURE__ */ new Map();
   /**
    * Watches for all project operations in the project.
@@ -3421,7 +3377,7 @@ class OperationManager {
    * @param signal The signal to abort the operation.
    */
   async *watchOperations(projectId, signal) {
-    for await (const [operation] of on(this.operationEE, projectId, { signal })) {
+    for await (const [operation] of on6(this.operationEE, projectId, { signal })) {
       yield operation;
     }
   }
@@ -3434,7 +3390,7 @@ class OperationManager {
    */
   async *watchInstanceLogs(operationId, instanceId, signal) {
     const eventKey = `${operationId}/${instanceId}`;
-    for await (const [log] of on(this.instanceLogsEE, eventKey, { signal })) {
+    for await (const [log] of on6(this.instanceLogsEE, eventKey, { signal })) {
       yield log;
     }
   }
@@ -3445,7 +3401,7 @@ class OperationManager {
    */
   async launch(request) {
     const operation = {
-      id: uuidv7(),
+      id: uuidv72(),
       projectId: request.projectId,
       type: request.type,
       instanceIds: request.instanceIds,
@@ -3495,7 +3451,7 @@ class OperationManager {
     void runtimeOperation.operateSafe().finally(() => this.runtimeOperations.delete(operation.id));
   }
   static async create(runnerBackend, stateBackend, libraryBackend, projectBackend, secretBackend, projectLockManager, stateManager, logger) {
-    const operator = new OperationManager(
+    const operator = new _OperationManager(
       runnerBackend,
       stateBackend,
       libraryBackend,
@@ -3513,8 +3469,10 @@ class OperationManager {
     }
     return operator;
   }
-}
+};
 
+// src/services.ts
+import { pino } from "pino";
 async function createServices({
   config,
   services: {
@@ -3583,12 +3541,25 @@ async function createServices({
     workspaceBackend
   };
 }
-let sharedServicesPromise;
+var sharedServicesPromise;
 function getSharedServices(options = {}) {
   if (!sharedServicesPromise) {
     sharedServicesPromise = createServices(options);
   }
   return sharedServicesPromise;
 }
-
-export { OperationManager, SecretAccessDeniedError, TerminalManager, createLibraryBackend, createSecretBackend, createServices, createTerminalBackend, getSharedServices, libraryBackendConfig, loadConfig, secretBackendConfig, terminalBackendConfig };
+export {
+  OperationManager,
+  SecretAccessDeniedError,
+  TerminalManager,
+  createLibraryBackend,
+  createSecretBackend,
+  createServices,
+  createTerminalBackend,
+  getSharedServices,
+  libraryBackendConfig,
+  loadConfig,
+  secretBackendConfig,
+  terminalBackendConfig
+};
+//# sourceMappingURL=index.js.map