@highstate/backend 0.7.2 → 0.7.3

package/dist/{terminal-CqIsctlZ.mjs → library-BW5oPM7V.js}

@@ -1,6 +1,8 @@
 import { z } from 'zod';
-import { omit, unique, fromEntries } from 'remeda';
+import { omit, unique, mapValues, fromEntries } from 'remeda';
+import { isUnitModel } from '@highstate/contract';
 import { sha256 } from 'crypto-hash';
+import { Ajv } from 'ajv';
 
 const positionSchema = z.object({
   x: z.number(),
@@ -25,12 +27,15 @@ const instanceModelSchema = z.object({
   type: z.string(),
   name: z.string(),
   ...instanceModelPatchSchema.shape,
+  resolvedInputs: z.record(z.array(instanceInputSchema)).optional(),
   parentId: z.string().optional(),
-  outputs: z.record(z.array(instanceInputSchema)).optional()
+  outputs: z.record(z.array(instanceInputSchema)).optional(),
+  resolvedOutputs: z.record(z.array(instanceInputSchema)).optional()
 });
 const compositeInstanceSchema = z.object({
   instance: instanceModelSchema,
-  children: z.array(instanceModelSchema)
+  children: z.array(instanceModelSchema),
+  inputHash: z.string().optional()
 });
 const hubModelPatchSchema = z.object({
   position: positionSchema.optional(),
@@ -60,15 +65,17 @@ const instanceStatusFieldSchema = z.object({
   value: z.string().optional(),
   displayName: z.string().optional(),
   sensitive: z.boolean().optional(),
-  url: z.string().optional()
+  url: z.string().optional(),
+  complementaryTo: z.string().optional()
 });
 const instanceFileMetaSchema = z.object({
   name: z.string(),
   contentType: z.string(),
+  size: z.number(),
   isBinary: z.boolean().optional()
 });
 const instanceFileSchema = z.object({
-  ...instanceFileMetaSchema.shape,
+  meta: instanceFileMetaSchema,
   content: z.string()
 });
 const instancePageBlockSchema = z.union([
@@ -142,13 +149,14 @@ const instanceStateSchema = z.object({
   inputHash: z.string().nullable().default(null),
   outputHash: z.string().nullable().default(null),
   error: z.string().nullable().default(null),
+  evaluationError: z.string().nullable().default(null),
   statusFields: z.array(instanceStatusFieldSchema).default(() => []),
   files: z.array(instanceFileMetaSchema).default(() => []),
   pages: z.array(instancePageMetaSchema).default(() => []),
   terminals: z.array(instanceTerminalMetaSchema).default(() => []),
   triggers: z.array(instanceTriggerSchema).default(() => [])
 });
-const instanceStatePatchSchema = z.object({
+const instanceStateUpdateSchema = z.object({
   ...instanceStateSchema.shape,
   // secrets updated by the unit
   secrets: z.record(z.string()).nullable(),
@@ -167,6 +175,7 @@ function createInstanceState(id, status = "not_created", fields = {}) {
     inputHash: null,
     outputHash: null,
     error: null,
+    evaluationError: null,
     statusFields: [],
     files: [],
     pages: [],
@@ -179,54 +188,13 @@ function applyPartialInstanceState(states, patch) {
   if (!patch.id) {
     throw new Error("The ID of the instance state is required.");
   }
-  let state = states.get(patch.id);
-  if (!state) {
-    state = createInstanceState(patch.id, "unknown");
-    states.set(patch.id, state);
-  }
-  if (patch.status !== void 0) {
-    state.status = patch.status;
-  }
-  if (patch.dependencyIds !== void 0) {
-    state.dependencyIds = patch.dependencyIds;
-  }
-  if (patch.latestOperationId !== void 0) {
-    state.latestOperationId = patch.latestOperationId;
-  }
-  if (patch.currentResourceCount !== void 0) {
-    state.currentResourceCount = patch.currentResourceCount;
-  }
-  if (patch.totalResourceCount !== void 0) {
-    state.totalResourceCount = patch.totalResourceCount;
-  }
-  if (patch.inputHash !== void 0) {
-    state.inputHash = patch.inputHash;
-  }
-  if (patch.outputHash !== void 0) {
-    state.outputHash = patch.outputHash;
-  }
-  if (patch.error !== void 0) {
-    state.error = patch.error;
-  }
-  if (patch.statusFields !== void 0) {
-    state.statusFields = patch.statusFields;
-  }
-  if (patch.files !== void 0) {
-    state.files = patch.files;
-  }
-  if (patch.pages !== void 0) {
-    state.pages = patch.pages;
-  }
-  if (patch.terminals !== void 0) {
-    state.terminals = patch.terminals;
-  }
-  if (patch.triggers !== void 0) {
-    state.triggers = patch.triggers;
-  }
+  let state = states.get(patch.id) ?? createInstanceState(patch.id, "unknown");
+  state = { ...state, ...patch };
+  states.set(state.id, state);
   return state;
 }
-function createInstanceStateFrontendPatch(patch) {
-  return omit(patch, ["secrets", "logLine"]);
+function createInstanceStatePatch(update) {
+  return omit(update, ["secrets", "logLine"]);
 }
 function buildDependentInstanceStateMap(instanceStates) {
   const dependentMap = /* @__PURE__ */ new Map();
@@ -259,17 +227,9 @@ function getAllDependentInstanceIds(dependentMap, instanceId) {
   return Array.from(result);
 }
 
-const operationTypeSchema = z.enum([
-  "update",
-  "preview",
-  "destroy",
-  "recreate",
-  "refresh",
-  "evaluate"
-]);
+const operationTypeSchema = z.enum(["update", "preview", "destroy", "recreate", "refresh"]);
 const operationStatusSchema = z.enum([
   "pending",
-  "evaluating",
   "running",
   "completed",
   "failed",
@@ -323,6 +283,7 @@ const projectOperationSchema = z.object({
   projectId: z.string(),
   type: operationTypeSchema,
   instanceIds: z.array(z.string()),
+  affectedInstanceIds: z.array(z.string()).default(() => []),
   options: operationOptionsSchema.default(() => ({})),
   error: z.string().nullable(),
   startedAt: z.number(),
@@ -345,8 +306,10 @@ function createDefaultGraphResolverBackend() {
   };
 }
 function defineGraphResolver(options) {
-  return (nodes, logger, backend) => {
+  const factory = (nodes, logger, backend) => {
     backend ??= createDefaultGraphResolverBackend();
+    logger = logger.child({ resolver: options.name });
+    const outputs = /* @__PURE__ */ new Map();
     const resolver = (itemId, dependencyChain) => {
       logger.trace({ itemId }, "resolving item");
       const existingPromise = backend.promiseCache.get(itemId);
@@ -364,19 +327,16 @@ function defineGraphResolver(options) {
         const dependencies = unique(options.getNodeDependencies(item));
         backend.setDependencies?.(itemId, dependencies);
         logger.trace({ itemId, dependencies }, "resolving item dependencies");
-        const resolvedDependencies = /* @__PURE__ */ new Map();
         const newChain = [...dependencyChain, itemId];
         for (const depId of dependencies) {
-          const depResult = await resolver(depId, newChain);
-          if (depResult !== void 0) {
-            resolvedDependencies.set(depId, depResult);
-          }
+          await resolver(depId, newChain);
         }
-        return await options.process(item, resolvedDependencies, logger);
+        return await options.process(item, outputs, logger);
       };
       const promise = resolve().then((result) => {
         if (backend.promiseCache.get(itemId) === promise) {
           backend.setOutput?.(itemId, result);
+          outputs.set(itemId, result);
         }
         return result;
       });
@@ -385,9 +345,12 @@ function defineGraphResolver(options) {
     };
     return (id) => resolver(id, []);
   };
+  factory.factoryName = options.name;
+  return factory;
 }
 
 const createInputResolver = defineGraphResolver({
+  name: "input-resolver",
   getNodeId(node) {
     if (node.kind === "hub") {
       return `hub:${node.hub.id}`;
@@ -405,6 +368,11 @@ const createInputResolver = defineGraphResolver({
       }
       return dependencies;
     }
+    for (const inputs of Object.values(node.instance.inputs ?? {})) {
+      for (const input of inputs) {
+        dependencies.push(`instance:${input.instanceId}`);
+      }
+    }
     for (const inputs of Object.values(node.instance.hubInputs ?? {})) {
       for (const input of inputs) {
         dependencies.push(`hub:${input.hubId}`);
@@ -429,12 +397,20 @@ const createInputResolver = defineGraphResolver({
     const getInstanceOutput = (input) => {
       const output = dependencies.get(`instance:${input.instanceId}`);
       if (!output) {
-        return { component: null };
+        return {
+          component: null,
+          resolvedInputs: [],
+          resolvedOutputs: []
+        };
       }
       if (output.kind !== "instance") {
         throw new Error("Expected instance node");
       }
-      return output;
+      return {
+        component: output.component,
+        resolvedInputs: output.resolvedInputs[input.output] ?? [],
+        resolvedOutputs: output.resolvedOutputs[input.output] ?? []
+      };
     };
     if (node.kind === "hub") {
       const hubResult = /* @__PURE__ */ new Map();
@@ -461,6 +437,27 @@ const createInputResolver = defineGraphResolver({
         resolvedInputs: Array.from(hubResult.values())
       };
     }
+    if (node.instance.resolvedInputs) {
+      return {
+        kind: "instance",
+        component: node.component,
+        resolvedInputs: mapValues(node.instance.resolvedInputs, (inputs, inputName) => {
+          const componentInput = node.component.inputs[inputName];
+          if (!componentInput) {
+            logger.warn({
+              msg: "input not found in the component",
+              inputName,
+              component: node.component
+            });
+            return [];
+          }
+          return inputs.map((input) => ({ input, type: componentInput.type }));
+        }),
+        resolvedOutputs: node.instance.resolvedOutputs ?? {},
+        resolvedInjectionInputs: [],
+        matchedInjectionInputs: []
+      };
+    }
     const resolvedInputsMap = /* @__PURE__ */ new Map();
     const addInstanceResult = (inputName, input) => {
       let inputs = resolvedInputsMap.get(inputName);
@@ -470,14 +467,28 @@ const createInputResolver = defineGraphResolver({
       }
       inputs.set(`${input.input.instanceId}:${input.input.output}`, input);
     };
+    const addInstanceInput = (inputName, input) => {
+      const componentInput = node.component.inputs[inputName];
+      if (!componentInput) {
+        logger.warn({ msg: "input not found in the component", input, component: node.component });
+        return;
+      }
+      const { component, resolvedOutputs } = getInstanceOutput(input);
+      if (!component) {
+        logger.warn({ instanceId: node.instance.id, input }, "no output found for the input");
+        return;
+      }
+      if (isUnitModel(component)) {
+        addInstanceResult(inputName, { input, type: componentInput.type });
+        return;
+      }
+      for (const output of resolvedOutputs) {
+        addInstanceResult(inputName, { input: output, type: componentInput.type });
+      }
+    };
     for (const [inputName, inputs] of Object.entries(node.instance.inputs ?? {})) {
       for (const input of inputs) {
-        const componentInput = node.component.inputs[inputName];
-        if (!componentInput) {
-          logger.warn({ msg: "input not found in the component", input, component: node.component });
-          continue;
-        }
-        addInstanceResult(inputName, { input, type: componentInput.type });
+        addInstanceInput(inputName, input);
       }
     }
     const injectionInputs = /* @__PURE__ */ new Map();
@@ -499,7 +510,7 @@ const createInputResolver = defineGraphResolver({
       }
       for (const input of allInputs.values()) {
         if (input.type === componentInput.type) {
-          addInstanceResult(inputName, input);
+          addInstanceInput(inputName, input.input);
           const key = `${input.input.instanceId}:${input.input.output}`;
           if (injectionInputs.has(key)) {
             matchedInjectionInputs.set(key, input);
@@ -517,6 +528,7 @@ const createInputResolver = defineGraphResolver({
       kind: "instance",
       component: node.component,
       resolvedInputs,
+      resolvedOutputs: node.instance.resolvedOutputs ?? {},
       resolvedInjectionInputs: Array.from(injectionInputs.values()),
       matchedInjectionInputs: Array.from(matchedInjectionInputs.values())
     };
@@ -548,6 +560,7 @@ function getMatchedInjectionInstanceInputs(output) {
 }
 
 const createInputHashResolver = defineGraphResolver({
+  name: "input-hash-resolver",
   getNodeId: (node) => node.instance.id,
   getNodeDependencies({ resolvedInputs }) {
     const dependencies = [];
@@ -558,14 +571,11 @@ const createInputHashResolver = defineGraphResolver({
     }
     return dependencies;
   },
-  async process({ instance, resolvedInputs, sourceHash, state }, dependencies) {
-    let sink = JSON.stringify(instance.args ?? {});
+  async process({ instance, component, resolvedInputs, sourceHash, state }, dependencies) {
+    let sink = component.definitionHash + JSON.stringify(instance.args ?? {});
     if (sourceHash) {
       sink += sourceHash;
     }
-    if (state?.outputHash) {
-      sink += state.outputHash;
-    }
     const sortedInputs = Object.entries(resolvedInputs).sort(([a], [b]) => a.localeCompare(b));
     for (const [inputKey, inputs] of sortedInputs) {
       if (Object.keys(inputs).length === 0) {
@@ -575,16 +585,129 @@ const createInputHashResolver = defineGraphResolver({
       const instanceIds = inputs.map((input) => input.input.instanceId);
       instanceIds.sort();
       for (const instanceId of instanceIds) {
-        sink += dependencies.get(instanceId);
+        const dependency = dependencies.get(instanceId);
+        if (!dependency) continue;
+        sink += dependency.inputHash;
+        sink += dependency.outputHash;
       }
     }
-    return await sha256(sink);
+    return {
+      inputHash: await sha256(sink),
+      outputHash: state?.outputHash ?? ""
+    };
   }
 });
 
+const createValidationResolver = defineGraphResolver({
+  name: "validation-resolver",
+  getNodeId: (node) => node.instance.id,
+  getNodeDependencies({ resolvedInputs }) {
+    const dependencies = [];
+    for (const inputs of Object.values(resolvedInputs)) {
+      for (const input of inputs) {
+        dependencies.push(input.input.instanceId);
+      }
+    }
+    return dependencies;
+  },
+  process({ instance, component, resolvedInputs }, dependencies, logger) {
+    const ajv = new Ajv();
+    logger.debug({ instanceId: instance.id }, "validating instance");
+    for (const [name, argument] of Object.entries(component.args)) {
+      if (!argument.required && !instance.args?.[name]) {
+        continue;
+      }
+      if (!ajv.validate(argument.schema, instance.args?.[name])) {
+        logger.debug({ instanceId: instance.id, argumentName: name }, "invalid argument");
+        return {
+          status: "invalid-args",
+          errorText: ajv.errorsText()
+        };
+      }
+    }
+    for (const inputs of Object.values(resolvedInputs)) {
+      for (const input of inputs) {
+        const inputInstance = dependencies.get(input.input.instanceId);
+        if (inputInstance?.status !== "ok") {
+          return {
+            status: "invalid-inputs",
+            errorText: `instance "${input.input.instanceId}" is invalid`
+          };
+        }
+      }
+    }
+    for (const [name, input] of Object.entries(component.inputs)) {
+      if (!input.required || input.multiple) {
+        continue;
+      }
+      if (!resolvedInputs[name] || !resolvedInputs[name].length) {
+        return {
+          status: "missing-inputs",
+          errorText: `input "${name}" is missing`
+        };
+      }
+    }
+    return { status: "ok" };
+  }
+});
+
+const resolverFactories = {
+  [createInputResolver.factoryName]: createInputResolver,
+  [createInputHashResolver.factoryName]: createInputHashResolver,
+  [createValidationResolver.factoryName]: createValidationResolver
+};
+
 const terminalSessionSchema = z.object({
-  id: z.string().uuid(),
-  terminalName: z.string()
+  id: z.string().nanoid(),
+  projectId: z.string(),
+  instanceId: z.string(),
+  terminalName: z.string(),
+  terminalTitle: z.string(),
+  createdAt: z.coerce.date(),
+  finishedAt: z.coerce.date().optional()
 });
 
-export { instancePageMetaSchema as A, instanceTerminalMetaSchema as B, instanceTerminalFileSchema as C, instanceTriggerSpecSchema as D, instanceTriggerInvocationSchema as E, instanceStatePatchSchema as F, buildDependentInstanceStateMap as G, getAllDependentInstanceIds as H, operationTypeSchema as I, operationStatusSchema as J, operationOptionsSchema as K, projectOperationRequestSchema as L, CircularDependencyError as M, createDefaultGraphResolverBackend as N, getResolvedHubInputs as O, getResolvedInstanceInputs as P, getResolvedInjectionInstanceInputs as Q, getMatchedInjectionInstanceInputs as R, createInputHashResolver as a, createInstanceState as b, createInputResolver as c, instanceTerminalSchema as d, instancePageSchema as e, instanceFileSchema as f, instanceStatusFieldSchema as g, hubModelSchema as h, instanceModelSchema as i, instanceTriggerSchema as j, compositeInstanceSchema as k, instanceStateSchema as l, isFinalOperationStatus as m, createInstanceStateFrontendPatch as n, applyPartialInstanceState as o, projectOperationSchema as p, defineGraphResolver as q, positionSchema as r, instanceInputSchema as s, terminalSessionSchema as t, hubInstanceInputSchema as u, instanceModelPatchSchema as v, hubModelPatchSchema as w, instanceStatusSchema as x, instanceFileMetaSchema as y, instancePageBlockSchema as z };
+function diffLibraries(oldLibrary, newLibrary) {
+  const updates = [];
+  for (const [componentType, newComponent] of Object.entries(newLibrary.components)) {
+    const existingComponent = oldLibrary.components[componentType];
+    if (existingComponent?.definitionHash !== newComponent.definitionHash) {
+      updates.push({ type: "component-updated", component: newComponent });
+    }
+  }
+  for (const componentType of Object.keys(oldLibrary.components)) {
+    if (!newLibrary.components[componentType]) {
+      updates.push({ type: "component-removed", componentType });
+    }
+  }
+  for (const [entityType, newEntity] of Object.entries(newLibrary.entities)) {
+    const existingEntity = oldLibrary.entities[entityType];
+    if (existingEntity?.definitionHash !== newEntity.definitionHash) {
+      updates.push({ type: "entity-updated", entity: newEntity });
+    }
+  }
+  for (const entityType of Object.keys(oldLibrary.entities)) {
+    if (!newLibrary.entities[entityType]) {
+      updates.push({ type: "entity-removed", entityType });
+    }
+  }
+  return updates;
+}
+function applyLibraryUpdate(components, entities, update) {
+  switch (update.type) {
+    case "component-updated":
+      components[update.component.type] = update.component;
+      break;
+    case "entity-updated":
+      entities[update.entity.type] = update.entity;
+      break;
+    case "component-removed":
+      delete components[update.componentType];
+      break;
+    case "entity-removed":
+      delete entities[update.entityType];
+      break;
+  }
+}
+
+export { buildDependentInstanceStateMap as A, getAllDependentInstanceIds as B, operationTypeSchema as C, operationStatusSchema as D, operationOptionsSchema as E, projectOperationRequestSchema as F, projectOperationSchema as G, isFinalOperationStatus as H, CircularDependencyError as I, createDefaultGraphResolverBackend as J, defineGraphResolver as K, resolverFactories as L, createInputResolver as M, getResolvedHubInputs as N, getResolvedInstanceInputs as O, getResolvedInjectionInstanceInputs as P, getMatchedInjectionInstanceInputs as Q, createInputHashResolver as R, createValidationResolver as S, terminalSessionSchema as T, diffLibraries as U, applyLibraryUpdate as V, instanceModelPatchSchema as a, instanceModelSchema as b, compositeInstanceSchema as c, hubModelPatchSchema as d, hubModelSchema as e, instanceStatusSchema as f, instanceStatusFieldSchema as g, hubInstanceInputSchema as h, instanceInputSchema as i, instanceFileMetaSchema as j, instanceFileSchema as k, instancePageBlockSchema as l, instancePageMetaSchema as m, instancePageSchema as n, instanceTerminalMetaSchema as o, positionSchema as p, instanceTerminalFileSchema as q, instanceTerminalSchema as r, instanceTriggerSpecSchema as s, instanceTriggerSchema as t, instanceTriggerInvocationSchema as u, instanceStateSchema as v, instanceStateUpdateSchema as w, createInstanceState as x, applyPartialInstanceState as y, createInstanceStatePatch as z };

package/dist/shared/index.js

@@ -0,0 +1,6 @@
+export { I as CircularDependencyError, V as applyLibraryUpdate, y as applyPartialInstanceState, A as buildDependentInstanceStateMap, c as compositeInstanceSchema, J as createDefaultGraphResolverBackend, R as createInputHashResolver, M as createInputResolver, x as createInstanceState, z as createInstanceStatePatch, S as createValidationResolver, K as defineGraphResolver, U as diffLibraries, B as getAllDependentInstanceIds, Q as getMatchedInjectionInstanceInputs, N as getResolvedHubInputs, P as getResolvedInjectionInstanceInputs, O as getResolvedInstanceInputs, h as hubInstanceInputSchema, d as hubModelPatchSchema, e as hubModelSchema, j as instanceFileMetaSchema, k as instanceFileSchema, i as instanceInputSchema, a as instanceModelPatchSchema, b as instanceModelSchema, l as instancePageBlockSchema, m as instancePageMetaSchema, n as instancePageSchema, v as instanceStateSchema, w as instanceStateUpdateSchema, g as instanceStatusFieldSchema, f as instanceStatusSchema, q as instanceTerminalFileSchema, o as instanceTerminalMetaSchema, r as instanceTerminalSchema, u as instanceTriggerInvocationSchema, t as instanceTriggerSchema, s as instanceTriggerSpecSchema, H as isFinalOperationStatus, E as operationOptionsSchema, D as operationStatusSchema, C as operationTypeSchema, p as positionSchema, F as projectOperationRequestSchema, G as projectOperationSchema, L as resolverFactories, T as terminalSessionSchema } from '../library-BW5oPM7V.js';
+import 'zod';
+import 'remeda';
+import '@highstate/contract';
+import 'crypto-hash';
+import 'ajv';

package/dist/utils-ByadNcv4.js

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+
+async function runWithRetryOnError(runner, tryHandleError, maxRetries = 1) {
+  let lastError;
+  for (let i = 0; i < maxRetries + 1; i++) {
+    try {
+      return await runner();
+    } catch (e) {
+      lastError = e;
+      if (await tryHandleError(e)) {
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw lastError;
+}
+class AbortError extends Error {
+  constructor(options) {
+    super("Operation aborted", options);
+  }
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+const abortMessagePatterns = ["Operation aborted", "Command was killed with SIGINT"];
+function isAbortErrorLike(error) {
+  if (error instanceof Error) {
+    return abortMessagePatterns.some((pattern) => error.message.includes(pattern));
+  }
+  return false;
+}
+function tryWrapAbortErrorLike(error) {
+  if (isAbortErrorLike(error)) {
+    return new AbortError({ cause: error });
+  }
+  return error;
+}
+const stringArrayType = z.string().transform((args) => args.split(",").map((arg) => arg.trim()));
+function errorToString(error) {
+  if (error instanceof Error) {
+    return error.stack || error.message;
+  }
+  return JSON.stringify(error);
+}
+function createAsyncBatcher(fn, { waitMs = 100, maxWaitTimeMs = 1e3 } = {}) {
+  let batch = [];
+  let activeTimeout = null;
+  let maxWaitTimeout = null;
+  let firstCallTimestamp = null;
+  async function processBatch() {
+    if (batch.length === 0) return;
+    const currentBatch = batch;
+    batch = [];
+    await fn(currentBatch);
+    if (maxWaitTimeout) {
+      clearTimeout(maxWaitTimeout);
+      maxWaitTimeout = null;
+    }
+    firstCallTimestamp = null;
+  }
+  function schedule() {
+    if (activeTimeout) clearTimeout(activeTimeout);
+    activeTimeout = setTimeout(() => {
+      activeTimeout = null;
+      void processBatch();
+    }, waitMs);
+    if (!firstCallTimestamp) {
+      firstCallTimestamp = Date.now();
+      maxWaitTimeout = setTimeout(() => {
+        if (activeTimeout) clearTimeout(activeTimeout);
+        activeTimeout = null;
+        void processBatch();
+      }, maxWaitTimeMs);
+    }
+  }
+  return {
+    /**
+     * Add an item to the batch.
+     */
+    call(item) {
+      batch.push(item);
+      schedule();
+    },
+    /**
+     * Immediately flush the pending batch (if any).
+     */
+    async flush() {
+      if (activeTimeout) {
+        clearTimeout(activeTimeout);
+        activeTimeout = null;
+      }
+      if (maxWaitTimeout) {
+        clearTimeout(maxWaitTimeout);
+        maxWaitTimeout = null;
+      }
+      await processBatch();
+    }
+  };
+}
+
+export { AbortError as A, isAbortError as a, createAsyncBatcher as c, errorToString as e, isAbortErrorLike as i, runWithRetryOnError as r, stringArrayType as s, tryWrapAbortErrorLike as t };

package/package.json

@@ -1,36 +1,31 @@
 {
   "name": "@highstate/backend",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "type": "module",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.mjs"
+      "types": "./src/index.ts",
+      "default": "./dist/index.js"
     },
     "./shared": {
-      "types": "./dist/shared/index.d.ts",
-      "default": "./dist/shared/index.mjs"
+      "types": "./src/shared/index.ts",
+      "default": "./dist/shared/index.js"
     },
-    "./library-worker": {
-      "default": "./dist/library/worker/main.mjs"
-    },
-    "./source-resolution-worker": {
-      "default": "./dist/runner/source-resolution-worker.mjs"
-    }
+    "./library-worker": "./dist/library/worker/main.js",
+    "./source-resolution-worker": "./dist/library/source-resolution-worker.js"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "pkgroll --tsconfig=tsconfig.build.json"
+    "build": "pkgroll --clean --tsconfig=tsconfig.build.json"
   },
   "dependencies": {
-    "@highstate/contract": "^0.7.2",
+    "@highstate/contract": "^0.7.3",
     "@types/node": "^22.10.1",
     "ajv": "^8.17.1",
     "better-lock": "^3.2.0",
@@ -44,6 +39,7 @@
     "pino": "^9.6.0",
     "pkg-types": "^1.2.1",
     "remeda": "^2.21.0",
+    "rev-dep": "^1.5.4",
     "uuidv7": "^1.0.2",
     "watcher": "^2.3.1",
     "zod": "^3.23.8"
@@ -61,12 +57,12 @@
     }
   },
   "devDependencies": {
-    "@pulumi/pulumi": "^3.152.0",
+    "@pulumi/pulumi": "patch:@pulumi/pulumi@npm%3A3.159.0#~/.yarn/patches/@pulumi-pulumi-npm-3.159.0-d07eefce5c.patch",
     "classic-level": "^2.0.0",
     "pino-pretty": "^13.0.0",
     "pkgroll": "^2.5.1",
     "rollup": "^4.28.1",
     "typescript": "^5.7.2"
   },
-  "gitHead": "e177535015e0fa3c74ae8ddc0bc6d31b191d2c54"
+  "gitHead": "5cf7cec27262c8fa1d96f6478833b94841459d64"
 }

package/src/common/index.ts

@@ -0,0 +1,3 @@
+export * from "./utils"
+export * from "./pulumi"
+export * from "./local"

package/src/common/local.ts

@@ -0,0 +1,22 @@
+import { basename } from "node:path"
+import { findWorkspaceDir, readPackageJSON } from "pkg-types"
+
+export async function resolveMainLocalProject(
+  projectPath?: string,
+  projectName?: string,
+): Promise<[projecPath: string, projectName: string]> {
+  if (!projectPath) {
+    projectPath = await findWorkspaceDir()
+  }
+
+  if (!projectName) {
+    const packageJson = await readPackageJSON(projectPath)
+    projectName = packageJson.name
+  }
+
+  if (!projectName) {
+    projectName = basename(projectPath)
+  }
+
+  return [projectPath, projectName]
+}