@highstate/backend 0.7.8 → 0.7.9

package/dist/highstate.manifest.json

@@ -1,8 +1,8 @@
 {
   "sourceHashes": {
-    "./dist/index.js": "e5a4106585f6ef91330ece00fcd73d51b7bad213ae36b46e9d98c13eb398d65f",
-    "./dist/shared/index.js": "7356c923eb12cbe487a811f5dae2d7ce79452ee8d4cbe856c5bc0beb9752d738",
-    "./dist/library/worker/main.js": "5ba7f6868be5fc81df24c54ffb1acafbe50762216c4261d631d041ece1d5a572",
-    "./dist/library/source-resolution-worker.js": "4589af58d254b32b8a9708528839e1da9450b5ebe8d74cd8d5cf713e52c1304b"
+    "./dist/index.js": "23e14a2a7ffd7bea598c3bebe69326a3c387d7a77f290481731250488f75b3ca",
+    "./dist/shared/index.js": "ce531a480a772514e20f94ec9116c98580dba419c8f5507bb85b6cef40a5c1ae",
+    "./dist/library/worker/main.js": "11bbed95f67a1756408bcbea93b87af1ed913ebbf7dbd35978027b0b3e219c05",
+    "./dist/library/package-resolution-worker.js": "4bfa368ad35a64c109df9e5a468c057791164760fe166c4eb5d9a889dee4d7bc"
   }
 }

package/dist/index.js

@@ -32,7 +32,6 @@ import {
   updateResourceCount,
   valueToString
 } from "./chunk-EQ4LMS7B.js";
-import "./chunk-DGUM43GV.js";
 
 // src/secret/abstractions.ts
 var SecretAccessDeniedError = class extends Error {
@@ -173,49 +172,43 @@ import { z as z4 } from "zod";
 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 { 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";
+import { readPackageJSON } from "pkg-types";
+import { runScript, installDependencies, addDependency } from "nypm";
+import { flatMap, groupBy, map, pipe, unique } from "remeda";
 var localLibraryBackendConfig = z3.object({
-  HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES: stringArrayType.default("@highstate/library"),
-  HIGHSTATE_BACKEND_LIBRARY_LOCAL_SOURCE_BASE_PATH: z3.string().optional(),
-  HIGHSTATE_BACKEND_LIBRARY_LOCAL_EXTRA_SOURCE_WATCH_PATHS: stringArrayType.default("")
+  HIGHSTATE_BACKEND_LIBRARY_LOCAL_PACKAGES: stringArrayType.default("@highstate/library"),
+  HIGHSTATE_BACKEND_LIBRARY_LOCAL_WATCH_PATHS: stringArrayType.optional()
 });
 var LocalLibraryBackend = class _LocalLibraryBackend {
-  constructor(modulePaths, sourceBasePath, extraSourceWatchPaths, logger) {
-    this.modulePaths = modulePaths;
-    this.sourceBasePath = sourceBasePath;
+  constructor(libraryPackages, watchPaths, logger) {
+    this.libraryPackages = libraryPackages;
     this.logger = logger;
-    this.libraryWatcher = new Watcher(modulePaths, { recursive: true, ignoreInitial: true });
-    this.libraryWatcher.on("all", (event, path) => {
-      const prefixPath = modulePaths.find((modulePath) => path.startsWith(modulePath));
-      this.logger.info({ msg: "library event", event, path: relative(prefixPath, path) });
-      void this.lock.acquire(() => this.updateLibrary());
-    });
-    this.sourceWatcher = new Watcher([sourceBasePath, ...extraSourceWatchPaths], {
+    this.watcher = new Watcher(watchPaths, {
       recursive: true,
       ignoreInitial: true,
-      ignore: /\.git|node_modules/
+      ignore: /\.git|node_modules|dist/
     });
-    this.sourceWatcher.on("all", (_, path) => {
-      if (!path.endsWith("highstate.manifest.json")) {
+    this.watcher.on("all", (event, path) => {
+      this.logger.debug({ event, path }, "library event");
+      if (!path.endsWith(".json") && !path.endsWith(".ts")) {
         return;
       }
-      void this.updateUnitSourceHashes(path);
+      void this.handleFileEvent(path);
     });
-    this.logger.debug({ msg: "initialized", modulePaths });
   }
-  libraryWatcher;
-  sourceWatcher;
+  watcher;
   lock = new BetterLock();
   eventEmitter = new EventEmitter();
   library = null;
   worker = null;
+  packages = /* @__PURE__ */ new Map();
   resolvedUnitSources = /* @__PURE__ */ new Map();
   async loadLibrary() {
     return await this.lock.acquire(async () => {
@@ -228,22 +221,27 @@ var LocalLibraryBackend = class _LocalLibraryBackend {
       yield library;
     }
   }
-  async getResolvedUnitSources() {
-    return await this.lock.acquire(async () => {
-      const [library] = await this.getLibrary();
-      if (!this.resolvedUnitSources.size) {
-        await this.syncUnitSources(library);
-      }
+  getLoadedResolvedUnitSources() {
+    return this.lock.acquire(() => {
       return Array.from(this.resolvedUnitSources.values());
     });
   }
-  async getResolvedUnitSource(unitType) {
+  async getResolvedUnitSources(unitTypes) {
     return await this.lock.acquire(async () => {
       const [library] = await this.getLibrary();
-      if (!this.resolvedUnitSources.size) {
-        await this.syncUnitSources(library);
+      const units = unitTypes.map((type) => library.components[type]).filter(isUnitModel);
+      const packageNames = Object.keys(groupBy(units, (unit) => unit.source.package));
+      await this.ensureLibraryPackagesLoaded(packageNames, true);
+      const result = [];
+      for (const unitType of unitTypes) {
+        const resolvedUnitSource = this.resolvedUnitSources.get(unitType);
+        if (resolvedUnitSource) {
+          result.push(resolvedUnitSource);
+        } else {
+          this.logger.warn(`resolved unit source not found for unit: "%s"`, unitType);
+        }
       }
-      return this.resolvedUnitSources.get(unitType) ?? null;
+      return result;
     });
   }
   async *watchResolvedUnitSources(signal) {
@@ -253,63 +251,6 @@ var LocalLibraryBackend = class _LocalLibraryBackend {
       yield resolvedUnitSource;
     }
   }
-  async syncUnitSources(library) {
-    const unitsToResolve = /* @__PURE__ */ new Map();
-    for (const component of Object.values(library.components)) {
-      if (!isUnitModel(component)) {
-        continue;
-      }
-      const existingResolvedSource = this.resolvedUnitSources.get(component.type);
-      const expectedSource = JSON.stringify(component.source);
-      if (existingResolvedSource?.serializedSource !== expectedSource) {
-        unitsToResolve.set(component.type, component);
-      }
-    }
-    await this.runSourceResolution(unitsToResolve);
-  }
-  async runSourceResolution(units) {
-    const workerPathUrl = importMetaResolve(
-      `@highstate/backend/source-resolution-worker`,
-      import.meta.url
-    );
-    const workerPath = fileURLToPath(workerPathUrl);
-    const worker = new Worker(workerPath, {
-      workerData: {
-        requests: Array.from(units.values()).map((unit) => ({
-          unitType: unit.type,
-          source: unit.source
-        })),
-        sourceBasePath: this.sourceBasePath,
-        logLevel: "error"
-      }
-    });
-    for await (const [event] of on(worker, "message")) {
-      const eventData = event;
-      if (eventData.type !== "result") {
-        throw new Error(`Unexpected message type '${eventData.type}', expected 'result'`);
-      }
-      for (const result of eventData.results) {
-        const unit = units.get(result.unitType);
-        if (!unit) {
-          this.logger.warn("unit not found for resolved source", { unitType: result.unitType });
-          continue;
-        }
-        const resolvedSource = {
-          unitType: result.unitType,
-          serializedSource: JSON.stringify(unit.source),
-          projectPath: result.projectPath,
-          packageJsonPath: result.packageJsonPath,
-          allowedDependencies: result.allowedDependencies,
-          sourceHash: result.sourceHash
-        };
-        this.resolvedUnitSources.set(result.unitType, resolvedSource);
-        this.eventEmitter.emit("resolvedUnitSource", resolvedSource);
-      }
-      this.logger.info("unit sources synced");
-      return;
-    }
-    throw new Error("Worker ended without sending the result");
-  }
   async evaluateCompositeInstances(allInstances, resolvedInputs, instanceIds) {
     return await this.lock.acquire(async () => {
       this.logger.info("evaluating %d composite instances", instanceIds.length);
@@ -357,11 +298,14 @@ var LocalLibraryBackend = class _LocalLibraryBackend {
     if (this.library && this.worker) {
       return [this.library, this.worker];
     }
-    return await this.updateLibrary();
+    return await this.reloadLibrary();
   }
-  async updateLibrary() {
-    this.logger.info("creating library worker");
-    this.worker = this.createWorker({ modulePaths: this.modulePaths, logLevel: "silent" });
+  async reloadLibrary() {
+    this.logger.info("reloading library");
+    this.worker = this.createLibraryWorker({
+      modulePaths: this.libraryPackages,
+      logLevel: "silent"
+    });
     for await (const [event] of on(this.worker, "message")) {
       const eventData = event;
       if (eventData.type === "error") {
@@ -377,36 +321,26 @@ var LocalLibraryBackend = class _LocalLibraryBackend {
       this.eventEmitter.emit("library", updates);
       this.library = eventData.library;
       this.logger.info("library reloaded");
-      await this.syncUnitSources(eventData.library);
       return [this.library, this.worker];
     }
     throw new Error("Worker ended without sending library model");
   }
-  createWorker(workerData) {
-    const workerPathUrl = importMetaResolve(`@highstate/backend/library-worker`, import.meta.url);
-    const workerPath = fileURLToPath(workerPathUrl);
-    return new Worker(workerPath, { workerData });
-  }
-  async updateUnitSourceHashes(path) {
-    const packageJsonPath = await resolvePackageJSON(path);
-    const packageJson = await readPackageJSON(path);
-    const library = await this.loadLibrary();
-    const manifestPath = resolve(dirname(packageJsonPath), "dist", "highstate.manifest.json");
-    let manifest;
-    try {
-      manifest = JSON.parse(await readFile(manifestPath, "utf8"));
-    } catch (error) {
-      this.logger.debug(
-        { error },
-        `failed to read highstate manifest for package "%s"`,
-        packageJson.name
+  async reloadUnitManifest(libraryPackage) {
+    const library = this.library;
+    if (!library) {
+      this.logger.warn(
+        `library not loaded, cannot reload unit manifest for package: "%s"`,
+        libraryPackage.name
       );
+      return;
     }
+    const manifest = await this.readLibraryPackageManifest(libraryPackage);
+    const packageJson = await readPackageJSON(libraryPackage.rootPath);
     for (const unit of Object.values(library.components)) {
       if (!isUnitModel(unit)) {
         continue;
       }
-      if (unit.source.package !== packageJson.name) {
+      if (unit.source.package !== libraryPackage.name) {
         continue;
       }
       const relativePath = unit.source.path ? `./dist/${unit.source.path}/index.js` : `./dist/index.js`;
@@ -416,40 +350,184 @@ var LocalLibraryBackend = class _LocalLibraryBackend {
         continue;
       }
       const resolvedSource = this.resolvedUnitSources.get(unit.type);
-      if (!resolvedSource) {
-        this.logger.warn(`resolved source not found for unit: "%s"`, unit.type);
-        continue;
-      }
       const newResolvedSource = {
-        ...resolvedSource,
-        sourceHash
+        unitType: unit.type,
+        sourceHash,
+        projectPath: resolve(libraryPackage.rootPath, relativePath),
+        allowedDependencies: Object.keys(packageJson.peerDependencies ?? {})
       };
+      if (resolvedSource?.sourceHash === newResolvedSource.sourceHash && resolvedSource?.projectPath === newResolvedSource.projectPath) {
+        continue;
+      }
       this.resolvedUnitSources.set(unit.type, newResolvedSource);
       this.eventEmitter.emit("resolvedUnitSource", newResolvedSource);
-      this.logger.info(`updated source hash for unit: "%s"`, unit.type);
+      this.logger.debug(`updated source for unit: "%s"`, unit.type);
     }
   }
+  async ensureLibraryPackagesLoaded(names, installIfNotFound = false) {
+    const packagesToLoad = names.filter((name) => !this.packages.has(name));
+    if (packagesToLoad.length > 0) {
+      await this.loadLibraryPackages(packagesToLoad, installIfNotFound);
+    }
+  }
+  async rebuildLibraryPackage(libraryPackage, installDeps = false, updateDeps = false, rebuiltPackages = /* @__PURE__ */ new Set()) {
+    if (rebuiltPackages.has(libraryPackage.name)) {
+      return;
+    }
+    rebuiltPackages.add(libraryPackage.name);
+    if (installDeps) {
+      this.logger.info(`installing dependencies for package "${libraryPackage.name}"`);
+      await installDependencies({ cwd: libraryPackage.rootPath });
+    }
+    if (updateDeps) {
+      await this.updateLibraryPackageDependencies(libraryPackage);
+    }
+    this.logger.info(`rebuilding library package "${libraryPackage.name}" via build script`);
+    await runScript("build", { cwd: libraryPackage.rootPath });
+    if (this.libraryPackages.includes(libraryPackage.name)) {
+      await this.reloadLibrary();
+    } else {
+      await this.reloadUnitManifest(libraryPackage);
+    }
+    await this.rebuildLibraryPackageDependents(libraryPackage, rebuiltPackages);
+  }
+  async updateLibraryPackageDependencies(libraryPackage) {
+    const packageJson = await readPackageJSON(libraryPackage.rootPath);
+    const parsedName = _LocalLibraryBackend.parseDependencyName(libraryPackage.name);
+    const dependencyPackageNames = pipe(
+      [packageJson.dependencies, packageJson.devDependencies, packageJson.peerDependencies],
+      flatMap((deps) => Object.keys(deps ?? {})),
+      unique(),
+      map(_LocalLibraryBackend.parseDependencyName)
+    );
+    const sameScopeDependencies = dependencyPackageNames.filter(
+      (dep) => dep.scope === parsedName.scope && dep.name !== parsedName.name
+    );
+    await this.ensureLibraryPackagesLoaded(sameScopeDependencies.map((dep) => dep.name));
+    for (const dependency of sameScopeDependencies) {
+      const dependencyPackage = this.packages.get(dependency.name);
+      if (!dependencyPackage) {
+        this.logger.warn(`dependency package not found for graph update: "%s"`, dependency.name);
+        continue;
+      }
+      libraryPackage.dependencies.add(dependency.name);
+      dependencyPackage.dependents.add(libraryPackage.name);
+    }
+  }
+  async rebuildLibraryPackageDependents(libraryPackage, rebuiltPackages = /* @__PURE__ */ new Set()) {
+    const promises = [];
+    for (const dependent of libraryPackage.dependents) {
+      const dependentPackage = this.packages.get(dependent);
+      if (!dependentPackage) {
+        this.logger.warn(`dependent package not found for rebuild: "%s"`, dependent);
+        continue;
+      }
+      promises.push(this.rebuildLibraryPackage(dependentPackage, false, false, rebuiltPackages));
+    }
+    await Promise.all(promises);
+  }
+  static parseDependencyName(dependency) {
+    if (dependency.startsWith("@")) {
+      const parts = dependency.split("/");
+      return {
+        name: dependency,
+        scope: parts[0]
+      };
+    }
+    return {
+      name: dependency,
+      scope: null
+    };
+  }
+  async readLibraryPackageManifest(libraryPackage) {
+    const manifestPath = resolve(libraryPackage.rootPath, "dist", "highstate.manifest.json");
+    try {
+      const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+      return manifest;
+    } catch (error) {
+      this.logger.debug(
+        { error },
+        `failed to read highstate manifest of package: "%s"`,
+        libraryPackage.name
+      );
+      return void 0;
+    }
+  }
+  async loadLibraryPackages(names, installIfNotFound = false) {
+    this.logger.info("loading library packages: %s", names.join(", "));
+    const missingPackages = [];
+    const packagesToUpdate = [];
+    const worker = this.createPackageResolutionWorker({ packageNames: names });
+    for await (const [event] of on(worker, "message")) {
+      const eventData = event;
+      if (eventData.type !== "result") {
+        continue;
+      }
+      for (const result of eventData.results) {
+        if (result.type === "success") {
+          const libraryPackage = {
+            name: result.packageName,
+            rootPath: result.packageRootPath,
+            dependencies: /* @__PURE__ */ new Set(),
+            dependents: /* @__PURE__ */ new Set()
+          };
+          this.packages.set(result.packageName, libraryPackage);
+          packagesToUpdate.push(libraryPackage);
+          this.logger.info(`loaded library package: "%s"`, result.packageName);
+        } else if (result.type === "not-found") {
+          missingPackages.push(result.packageName);
+        } else {
+          this.logger.error(
+            `failed to load library package "%s": %s`,
+            result.packageName,
+            result.error
+          );
+        }
+      }
+      break;
+    }
+    for (const libraryPackage of packagesToUpdate) {
+      await this.updateLibraryPackageDependencies(libraryPackage);
+      if (!this.libraryPackages.includes(libraryPackage.name)) {
+        await this.reloadUnitManifest(libraryPackage);
+      }
+    }
+    if (installIfNotFound && missingPackages.length > 0) {
+      this.logger.info("installing missing library packages: %s", missingPackages.join(", "));
+      await addDependency(missingPackages);
+      await this.loadLibraryPackages(missingPackages);
+    }
+  }
+  async handleFileEvent(path) {
+    await this.lock.acquire(async () => {
+      const libraryPackage = this.packages.values().find((pkg) => path.startsWith(pkg.rootPath));
+      if (libraryPackage) {
+        await this.rebuildLibraryPackage(libraryPackage);
+      }
+    });
+  }
+  createLibraryWorker(workerData) {
+    const workerPathUrl = importMetaResolve(`@highstate/backend/library-worker`, import.meta.url);
+    const workerPath = fileURLToPath(workerPathUrl);
+    return new Worker(workerPath, { workerData });
+  }
+  createPackageResolutionWorker(workerData) {
+    const workerPathUrl = importMetaResolve(
+      `@highstate/backend/package-resolution-worker`,
+      import.meta.url
+    );
+    const workerPath = fileURLToPath(workerPathUrl);
+    return new Worker(workerPath, { workerData });
+  }
   static async create(config, logger) {
-    const modulePaths = [];
-    for (const module of config.HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES) {
-      const url = importMetaResolve(module, import.meta.url);
-      let path = fileURLToPath(url);
-      if (basename(path).includes(".")) {
-        path = dirname(path);
-      }
-      modulePaths.push(path);
-    }
-    let sourceBasePath = config.HIGHSTATE_BACKEND_LIBRARY_LOCAL_SOURCE_BASE_PATH;
-    const extraSourceWatchPaths = config.HIGHSTATE_BACKEND_LIBRARY_LOCAL_EXTRA_SOURCE_WATCH_PATHS;
-    if (!sourceBasePath) {
+    let watchPaths = config.HIGHSTATE_BACKEND_LIBRARY_LOCAL_WATCH_PATHS;
+    if (!watchPaths) {
       const [projectPath] = await resolveMainLocalProject();
-      sourceBasePath = resolve(projectPath, "units");
-      extraSourceWatchPaths.push(projectPath);
+      watchPaths = [resolve(projectPath, "packages")];
     }
     return new _LocalLibraryBackend(
-      modulePaths,
-      sourceBasePath,
-      extraSourceWatchPaths,
+      config.HIGHSTATE_BACKEND_LIBRARY_LOCAL_PACKAGES,
+      watchPaths,
       logger.child({ backend: "LibraryBackend", service: "LocalLibraryBackend" })
     );
   }
@@ -842,6 +920,30 @@ var ProjectManager = class _ProjectManager {
       yield children;
     }
   }
+  /**
+   * Loads the full info of a project, including instances, hubs, and composite instances.
+   *
+   * Also filters out instances that are not in the library.
+   *
+   * @param projectId The ID of the project to load.
+   */
+  async getProject(projectId) {
+    const [{ instances, hubs }, compositeInstances, library] = await Promise.all([
+      this.projectBackend.getProject(projectId),
+      this.stateBackend.getCompositeInstances(projectId),
+      this.libraryBackend.loadLibrary()
+    ]);
+    const filteredInstances = instances.filter((instance) => instance.type in library.components);
+    const filteredCompositeInstances = compositeInstances.filter((instance) => instance.instance.type in library.components).map((instance) => ({
+      ...instance,
+      children: instance.children.filter((child) => child.type in library.components)
+    }));
+    return {
+      instances: filteredInstances,
+      hubs,
+      compositeInstances: filteredCompositeInstances
+    };
+  }
   async createInstance(projectId, instance) {
     const createdInstance = await this.projectBackend.createInstance(projectId, instance);
     await this.updateCompositeInstance(projectId, createdInstance);
@@ -986,9 +1088,10 @@ var ProjectManager = class _ProjectManager {
       }
       let sourceHash;
       if (isUnitModel2(library.components[instance.type])) {
-        const resolvedUnit = await this.libraryBackend.getResolvedUnitSource(instance.type);
+        const resolvedUnits = await this.libraryBackend.getResolvedUnitSources([instance.type]);
+        const resolvedUnit = resolvedUnits.find((unit) => unit.unitType === instance.type);
         if (!resolvedUnit) {
-          throw new Error(`Resolved unit not found: ${instance.type}`);
+          throw new Error(`Resolved unit not found for type "${instance.type}"`);
         }
         sourceHash = resolvedUnit.sourceHash;
       }
@@ -1088,7 +1191,7 @@ import { z as z7 } from "zod";
 import spawn from "nano-spawn";
 
 // src/terminal/run.sh.ts
-var runScript = `set -e -o pipefail
+var runScript2 = `set -e -o pipefail
 read -r data
 
 # Extract env and files as key-value pairs, and command as an array
@@ -1143,7 +1246,7 @@ var DockerTerminalBackend = class _DockerTerminalBackend {
     const hsTempDir = resolve3(tmpdir(), "highstate");
     await mkdir2(hsTempDir, { recursive: true });
     const runScriptPath = resolve3(hsTempDir, "run.sh");
-    await writeFile2(runScriptPath, runScript, { mode: 493 });
+    await writeFile2(runScriptPath, runScript2, { mode: 493 });
     const args = [
       "run",
       "-i",
@@ -1630,10 +1733,7 @@ var LocalRunnerBackend = class _LocalRunnerBackend {
   async updateWorker(options, configMap, preview) {
     const instanceId = _LocalRunnerBackend.getInstanceId(options);
     try {
-      const resolvedSource = await this.libraryBackend.getResolvedUnitSource(options.instanceType);
-      if (!resolvedSource) {
-        throw new Error(`Resolved unit source not found for ${options.instanceType}`);
-      }
+      const resolvedSource = await this.getResolvedUnitSource(options.instanceType);
       await this.pulumiProjectHost.runLocal(
         {
           projectId: options.projectId,
@@ -1737,7 +1837,7 @@ var LocalRunnerBackend = class _LocalRunnerBackend {
   async destroyWorker(options) {
     const instanceId = _LocalRunnerBackend.getInstanceId(options);
     try {
-      const resolvedSource = await this.libraryBackend.getResolvedUnitSource(options.instanceType);
+      const resolvedSource = await this.getResolvedUnitSource(options.instanceType);
       if (!resolvedSource) {
         throw new Error(`Resolved unit source not found for ${options.instanceType}`);
       }
@@ -1980,6 +2080,14 @@ var LocalRunnerBackend = class _LocalRunnerBackend {
     await ensureDependencyInstalled(packageName);
     return true;
   }
+  async getResolvedUnitSource(instanceType) {
+    const sources = await this.libraryBackend.getResolvedUnitSources([instanceType]);
+    const source = sources.find((source2) => source2.unitType === instanceType);
+    if (!source) {
+      throw new Error(`Resolved unit source not found for ${instanceType}`);
+    }
+    return source;
+  }
   static getStackName(options) {
     return `${options.projectId}_${options.instanceName}`;
   }
@@ -2538,6 +2646,7 @@ import { mapValues as mapValues3 } from "remeda";
 
 // src/orchestrator/operation-workset.ts
 import { isUnitModel as isUnitModel3 } from "@highstate/contract";
+import { unique as unique2 } from "remeda";
 var OperationWorkset = class _OperationWorkset {
   constructor(operation, library, stateManager, logger) {
     this.operation = operation;
@@ -2788,13 +2897,15 @@ var OperationWorkset = class _OperationWorkset {
     return Array.from(instanceIds);
   }
   static async load(operation, projectBackend, libraryBackend, stateBackend, stateManager, logger, signal) {
-    const [library, unitSources, project, compositeInstances, states] = await Promise.all([
+    const [library, project, compositeInstances, states] = await Promise.all([
       libraryBackend.loadLibrary(signal),
-      libraryBackend.getResolvedUnitSources(),
       projectBackend.getProject(operation.projectId, signal),
       stateBackend.getCompositeInstances(operation.projectId, signal),
       stateBackend.getAllInstanceStates(operation.projectId, signal)
     ]);
+    const unitSources = await libraryBackend.getResolvedUnitSources(
+      unique2(project.instances.map((i) => i.type))
+    );
     const workset = new _OperationWorkset(
       operation,
       library,