@highstate/backend 0.9.14 → 0.9.16

package/dist/chunk-C2TJAQAD.js

@@ -1,937 +0,0 @@
-// src/shared/project.ts
-import { z } from "zod";
-var positionSchema = z.object({
-  x: z.number(),
-  y: z.number()
-});
-var instanceInputSchema = z.object({
-  instanceId: z.string(),
-  output: z.string()
-});
-var hubInstanceInputSchema = z.object({
-  hubId: z.string()
-});
-var instanceModelPatchSchema = z.object({
-  args: z.record(z.unknown()).optional(),
-  inputs: z.record(z.array(instanceInputSchema)).optional(),
-  hubInputs: z.record(z.array(hubInstanceInputSchema)).optional(),
-  injectionInputs: z.array(hubInstanceInputSchema).optional(),
-  position: positionSchema.optional()
-});
-var instanceModelSchema = z.object({
-  id: z.string(),
-  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(),
-  resolvedOutputs: z.record(z.array(instanceInputSchema)).optional()
-});
-var compositeInstanceSchema = z.object({
-  instance: instanceModelSchema,
-  children: z.array(instanceModelSchema),
-  inputHash: z.string().optional()
-});
-var hubModelPatchSchema = z.object({
-  position: positionSchema.optional(),
-  inputs: z.array(instanceInputSchema).optional(),
-  injectionInputs: z.array(hubInstanceInputSchema).optional()
-});
-var hubModelSchema = z.object({
-  id: z.string().nanoid(),
-  position: positionSchema,
-  inputs: z.array(instanceInputSchema).optional(),
-  injectionInputs: z.array(hubInstanceInputSchema).optional()
-});
-
-// src/shared/state.ts
-import { omit } from "remeda";
-import { z as z2 } from "zod";
-var instanceStatusSchema = z2.enum([
-  "not_created",
-  "updating",
-  "previewing",
-  "destroying",
-  "refreshing",
-  "created",
-  "error",
-  "pending",
-  "unknown"
-]);
-var instanceStatusFieldValueSchema = z2.union([
-  z2.string(),
-  z2.number(),
-  z2.boolean(),
-  z2.array(z2.string())
-]);
-var instanceStatusFieldSchema = z2.object({
-  name: z2.string(),
-  value: instanceStatusFieldValueSchema.optional(),
-  displayName: z2.string().optional(),
-  sensitive: z2.boolean().optional(),
-  url: z2.string().optional(),
-  complementaryTo: z2.string().optional()
-});
-var instanceFileMetaSchema = z2.object({
-  name: z2.string(),
-  contentType: z2.string(),
-  size: z2.number(),
-  isBinary: z2.boolean().optional()
-});
-var instanceFileSchema = z2.object({
-  meta: instanceFileMetaSchema,
-  content: z2.string()
-});
-var instancePageBlockSchema = z2.union([
-  z2.object({
-    type: z2.literal("markdown"),
-    content: z2.string()
-  }),
-  z2.object({
-    type: z2.literal("qr"),
-    content: z2.string(),
-    showContent: z2.coerce.boolean(),
-    language: z2.string().optional()
-  }),
-  z2.object({
-    type: z2.literal("file"),
-    fileMeta: instanceFileMetaSchema
-  })
-]);
-var instancePageMetaSchema = z2.object({
-  name: z2.string(),
-  title: z2.string()
-});
-var instancePageSchema = z2.object({
-  ...instancePageMetaSchema.shape,
-  content: z2.array(instancePageBlockSchema)
-});
-var instanceTerminalMetaSchema = z2.object({
-  name: z2.string(),
-  title: z2.string(),
-  description: z2.string().optional()
-});
-var instanceTerminalFileSchema = z2.object({
-  content: z2.string().optional(),
-  isBinary: z2.boolean().optional(),
-  mode: z2.number().optional()
-});
-var instanceTerminalSchema = z2.object({
-  ...instanceTerminalMetaSchema.shape,
-  image: z2.string(),
-  command: z2.string().array(),
-  cwd: z2.string().optional(),
-  env: z2.record(z2.string()).optional(),
-  files: z2.record(instanceTerminalFileSchema).optional()
-});
-var instanceTriggerSpecSchema = z2.union([
-  z2.object({
-    type: z2.literal("before-destroy")
-  }),
-  z2.object({
-    type: z2.literal("schedule"),
-    schedule: z2.string()
-  })
-]);
-var instanceTriggerSchema = z2.object({
-  name: z2.string(),
-  title: z2.string(),
-  description: z2.string().optional(),
-  spec: instanceTriggerSpecSchema
-});
-var instanceTriggerInvocationSchema = z2.object({
-  name: z2.string()
-});
-var instanceStateSchema = z2.object({
-  id: z2.string(),
-  parentId: z2.string().nullable().default(null),
-  status: instanceStatusSchema,
-  dependencyIds: z2.array(z2.string()).default(() => []),
-  latestOperationId: z2.string().nullable().default(null),
-  currentResourceCount: z2.number().nullable().default(null),
-  totalResourceCount: z2.number().nullable().default(null),
-  inputHash: z2.string().nullable().default(null),
-  outputHash: z2.string().nullable().default(null),
-  error: z2.string().nullable().default(null),
-  evaluationError: z2.string().nullable().default(null),
-  statusFields: z2.array(instanceStatusFieldSchema).default(() => []),
-  files: z2.array(instanceFileMetaSchema).default(() => []),
-  pages: z2.array(instancePageMetaSchema).default(() => []),
-  terminals: z2.array(instanceTerminalMetaSchema).default(() => []),
-  triggers: z2.array(instanceTriggerSchema).default(() => [])
-});
-var instanceStateUpdateSchema = z2.object({
-  ...instanceStateSchema.shape,
-  // secrets updated by the unit
-  secrets: z2.record(z2.string()).nullable(),
-  // log line emitted by the unit
-  logLine: z2.string().nullable()
-}).partial();
-function createInstanceState(id, status = "not_created", fields = {}) {
-  return {
-    id,
-    parentId: null,
-    dependencyIds: [],
-    status,
-    latestOperationId: null,
-    currentResourceCount: null,
-    totalResourceCount: null,
-    inputHash: null,
-    outputHash: null,
-    error: null,
-    evaluationError: null,
-    statusFields: [],
-    files: [],
-    pages: [],
-    terminals: [],
-    triggers: [],
-    ...fields
-  };
-}
-function applyPartialInstanceState(states, patch) {
-  if (!patch.id) {
-    throw new Error("The ID of the instance state is required.");
-  }
-  let state = states.get(patch.id) ?? createInstanceState(patch.id, "unknown");
-  state = { ...state, ...patch };
-  states.set(state.id, state);
-  return state;
-}
-function createInstanceStatePatch(update) {
-  return omit(update, ["secrets", "logLine"]);
-}
-function buildDependentInstanceStateMap(instanceStates) {
-  const dependentMap = /* @__PURE__ */ new Map();
-  for (const state of instanceStates.values()) {
-    for (const dependency of state.dependencyIds) {
-      let dependents = dependentMap.get(dependency);
-      if (!dependents) {
-        dependents = [];
-        dependentMap.set(dependency, dependents);
-      }
-      dependents.push(state.id);
-    }
-  }
-  return dependentMap;
-}
-function getAllDependentInstanceIds(dependentMap, instanceId) {
-  const result = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const traverse = (id) => {
-    if (visited.has(id)) return;
-    visited.add(id);
-    const dependents = dependentMap.get(id);
-    if (!dependents) return;
-    for (const dependent of dependents) {
-      result.add(dependent);
-      traverse(dependent);
-    }
-  };
-  traverse(instanceId);
-  return Array.from(result);
-}
-
-// src/shared/operation.ts
-import { z as z3 } from "zod";
-var operationTypeSchema = z3.enum(["update", "preview", "destroy", "recreate", "refresh"]);
-var operationStatusSchema = z3.enum([
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "cancelled"
-]);
-var operationOptionsSchema = z3.object({
-  /**
-   * Whether to force update all dependencies of the instances even if they are not changed.
-   *
-   * Only applicable for `update`, `preview`, `recreate`, and `refresh` operations.
-   * By default, `false`.
-   */
-  forceUpdateDependencies: z3.boolean().default(false),
-  /**
-   * Whether to force update all children of the composite instances even if they are not changed.
-   *
-   * Only applicable for `update`, `preview`, `recreate`, and `refresh` operations.
-   * By default, `false`.
-   */
-  forceUpdateChildren: z3.boolean().default(false),
-  /**
-   * Whether to destroy all dependents of the instances when destroying them.
-   *
-   * Only applicable for `destroy`.
-   * By default, `true`.
-   */
-  destroyDependentInstances: z3.boolean().default(true),
-  /**
-   * Whether to invoke destroy triggers when destroying the instances.
-   *
-   * Only applicable for `destroy`.
-   * By default, `true`.
-   */
-  invokeDestroyTriggers: z3.boolean().default(true),
-  /**
-   * Whether to delete unreachable resources when updating or destroying the instances.
-   * This is potentially dangerous and should be used with caution.
-   *
-   * By default, `false`.
-   */
-  deleteUnreachableResources: z3.boolean().default(false),
-  /**
-   * Whether to delete the stack state even if the destroy operation fails.
-   * This is very dangerous and should be used only when the stack is unrecoverable.
-   *
-   * By default, `false`.
-   */
-  forceDeleteState: z3.boolean().default(false),
-  /**
-   * Whether to refresh the state before running the operation.
-   *
-   * By default, `false`.
-   */
-  refresh: z3.boolean().default(false)
-});
-var projectOperationRequestSchema = z3.object({
-  projectId: z3.string(),
-  type: operationTypeSchema,
-  instanceIds: z3.array(z3.string()),
-  options: operationOptionsSchema.partial().optional()
-});
-var projectOperationSchema = z3.object({
-  id: z3.string().uuid(),
-  status: operationStatusSchema,
-  projectId: z3.string(),
-  type: operationTypeSchema,
-  requestedInstanceIds: z3.array(z3.string()),
-  instanceIdsToUpdate: z3.array(z3.string()).default(() => []),
-  instanceIdsToDestroy: z3.array(z3.string()).default(() => []),
-  options: operationOptionsSchema.default(() => ({})),
-  error: z3.string().nullable(),
-  startedAt: z3.number(),
-  completedAt: z3.number().nullable()
-});
-function isFinalOperationStatus(status) {
-  return status === "completed" || status === "failed" || status === "cancelled";
-}
-
-// src/shared/resolvers/graph-resolver.ts
-import { unique } from "remeda";
-var GraphResolver = class {
-  constructor(nodes, logger, outputHandler) {
-    this.nodes = nodes;
-    this.logger = logger;
-    this.outputHandler = outputHandler;
-  }
-  workset = /* @__PURE__ */ new Set();
-  dependentMap = /* @__PURE__ */ new Map();
-  outputMap = /* @__PURE__ */ new Map();
-  addToWorkset(nodeId) {
-    this.workset.add(nodeId);
-  }
-  addAllNodesToWorkset() {
-    for (const nodeId of this.nodes.keys()) {
-      this.workset.add(nodeId);
-    }
-  }
-  /**
-   * The map of calculated outputs.
-   */
-  get outputs() {
-    return this.outputMap;
-  }
-  requireOutput(nodeId) {
-    const output = this.outputMap.get(nodeId);
-    if (!output) {
-      throw new Error(`Output for node ${nodeId} is not available`);
-    }
-    return output;
-  }
-  /**
-   * Invalidates the node and all nodes that depend on it.
-   *
-   * Also adds the node to the work set for processing.
-   */
-  invalidate(nodeId) {
-    const stack = [nodeId];
-    while (stack.length > 0) {
-      const nodeId2 = stack.pop();
-      if (!this.nodes.has(nodeId2)) {
-        continue;
-      }
-      this.outputMap.delete(nodeId2);
-      this.workset.add(nodeId2);
-      const dependents = this.dependentMap.get(nodeId2);
-      if (!dependents) {
-        continue;
-      }
-      for (const dependentId of dependents) {
-        if (this.outputMap.has(dependentId)) {
-          stack.push(dependentId);
-        }
-      }
-      this.dependentMap.delete(nodeId2);
-    }
-  }
-  /**
-   * Resolves all not-resolved or invalidated nodes in the graph.
-   *
-   * The abort signal of the previous operation must be called before calling this method again.
-   */
-  async process(signal) {
-    while (this.workset.size > 0) {
-      const rootNodeId = this.workset.values().next().value;
-      const stack = [{ nodeId: rootNodeId, resolved: false, dependencies: [] }];
-      while (stack.length > 0) {
-        const stackItem = stack[stack.length - 1];
-        const { nodeId, resolved } = stackItem;
-        const node = this.nodes.get(nodeId);
-        if (!node) {
-          this.logger.warn({ nodeId }, "node not found in the graph, skipping");
-          stack.pop();
-          continue;
-        }
-        if (this.outputMap.has(nodeId)) {
-          stack.pop();
-          continue;
-        }
-        if (!resolved) {
-          stackItem.dependencies = unique(this.getNodeDependencies(node));
-          let hasUnresolvedDependencies = false;
-          for (const depId of stackItem.dependencies) {
-            if (!this.nodes.has(depId)) {
-              this.logger.warn({ depId, nodeId }, "dependency not found in the graph, skipping");
-              continue;
-            }
-            if (!this.outputMap.has(depId)) {
-              stack.push({ nodeId: depId, resolved: false, dependencies: [] });
-              hasUnresolvedDependencies = true;
-            }
-          }
-          if (hasUnresolvedDependencies) {
-            stackItem.resolved = true;
-            continue;
-          }
-        }
-        const output = await this.processNode(node, this.logger);
-        if (signal?.aborted) {
-          this.logger.warn({ nodeId }, "processing aborted, skipping output");
-          return;
-        }
-        for (const depId of stackItem.dependencies) {
-          let dependantSet = this.dependentMap.get(depId);
-          if (!dependantSet) {
-            dependantSet = /* @__PURE__ */ new Set();
-            this.dependentMap.set(depId, dependantSet);
-          }
-          dependantSet.add(nodeId);
-        }
-        this.outputMap.set(nodeId, output);
-        this.outputHandler?.(nodeId, output);
-        stack.pop();
-      }
-      this.workset.delete(rootNodeId);
-    }
-  }
-};
-
-// src/shared/resolvers/input.ts
-import {
-  isUnitModel
-} from "@highstate/contract";
-import { fromEntries, mapValues } from "remeda";
-var InputResolver = class extends GraphResolver {
-  // constructor(
-  //   nodes: ReadonlyMap<string, InputResolverNode>,
-  //   logger: Logger,
-  //   outputHandler?: ResolverOutputHandler<InputResolverOutput>,
-  // ) {
-  //   super(nodes, logger, outputHandler)
-  // }
-  getNodeDependencies(node) {
-    const dependencies = [];
-    if (node.kind === "hub") {
-      for (const input of node.hub.inputs ?? []) {
-        dependencies.push(`instance:${input.instanceId}`);
-      }
-      for (const input of node.hub.injectionInputs ?? []) {
-        dependencies.push(`hub:${input.hubId}`);
-      }
-      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}`);
-      }
-    }
-    for (const input of node.instance.injectionInputs ?? []) {
-      dependencies.push(`hub:${input.hubId}`);
-    }
-    return dependencies;
-  }
-  processNode(node) {
-    const getHubOutput = (input) => {
-      const output = this.outputs.get(`hub:${input.hubId}`);
-      if (!output) {
-        return { resolvedInputs: [] };
-      }
-      if (output.kind !== "hub") {
-        throw new Error("Expected hub node");
-      }
-      return output;
-    };
-    const getInstanceOutput = (input) => {
-      const output = this.outputs.get(`instance:${input.instanceId}`);
-      if (!output) {
-        return {
-          component: null,
-          resolvedInputs: [],
-          resolvedOutputs: []
-        };
-      }
-      if (output.kind !== "instance") {
-        throw new Error("Expected instance node");
-      }
-      return {
-        component: output.component,
-        resolvedInputs: output.resolvedInputs[input.output] ?? [],
-        resolvedOutputs: output.resolvedOutputs?.[input.output]
-      };
-    };
-    if (node.kind === "hub") {
-      const hubResult = /* @__PURE__ */ new Map();
-      const addHubResult = (input) => {
-        hubResult.set(`${input.input.instanceId}:${input.input.output}`, input);
-      };
-      for (const input of node.hub.inputs ?? []) {
-        const { component } = getInstanceOutput(input);
-        const componentInput = component?.outputs[input.output];
-        if (!componentInput) {
-          this.logger.warn({ msg: "output not found in the component", input, component });
-          continue;
-        }
-        addHubResult({ input, type: componentInput.type });
-      }
-      for (const injectionInput of node.hub.injectionInputs ?? []) {
-        const { resolvedInputs: resolvedInputs2 } = getHubOutput(injectionInput);
-        for (const input of resolvedInputs2) {
-          addHubResult(input);
-        }
-      }
-      return {
-        kind: "hub",
-        resolvedInputs: Array.from(hubResult.values())
-      };
-    }
-    if (node.instance.resolvedInputs) {
-      return {
-        kind: "instance",
-        instance: node.instance,
-        component: node.component,
-        resolvedInputs: mapValues(node.instance.resolvedInputs, (inputs, inputName) => {
-          const componentInput = node.component.inputs[inputName];
-          if (!componentInput) {
-            this.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);
-      if (!inputs) {
-        inputs = /* @__PURE__ */ new Map();
-        resolvedInputsMap.set(inputName, inputs);
-      }
-      inputs.set(`${input.input.instanceId}:${input.input.output}`, input);
-    };
-    const addInstanceInput = (inputName, input) => {
-      const componentInput = node.component.inputs[inputName];
-      if (!componentInput) {
-        this.logger.warn({
-          msg: "input not found in the component",
-          input,
-          component: node.component
-        });
-        return;
-      }
-      const { component, resolvedOutputs } = getInstanceOutput(input);
-      if (!component) {
-        this.logger.warn({ instanceId: node.instance.id, input }, "no output found for the input");
-        return;
-      }
-      if (isUnitModel(component)) {
-        addInstanceResult(inputName, { input, type: componentInput.type });
-        return;
-      }
-      if (resolvedOutputs) {
-        for (const output of resolvedOutputs) {
-          addInstanceResult(inputName, { input: output, type: componentInput.type });
-        }
-      } else {
-        addInstanceResult(inputName, { input, type: componentInput.type });
-      }
-    };
-    for (const [inputName, inputs] of Object.entries(node.instance.inputs ?? {})) {
-      for (const input of inputs) {
-        addInstanceInput(inputName, input);
-      }
-    }
-    const injectionInputs = /* @__PURE__ */ new Map();
-    const matchedInjectionInputs = /* @__PURE__ */ new Map();
-    for (const injectionInput of node.instance.injectionInputs ?? []) {
-      const { resolvedInputs: resolvedInputs2 } = getHubOutput(injectionInput);
-      for (const input of resolvedInputs2) {
-        injectionInputs.set(`${input.input.instanceId}:${input.input.output}`, input);
-      }
-    }
-    for (const [inputName, componentInput] of Object.entries(node.component.inputs ?? {})) {
-      const allInputs = new Map(injectionInputs);
-      const hubInputs = node.instance.hubInputs?.[inputName] ?? [];
-      for (const hubInput of hubInputs) {
-        const { resolvedInputs: resolvedInputs2 } = getHubOutput(hubInput);
-        for (const input of resolvedInputs2) {
-          allInputs.set(`${input.input.instanceId}:${input.input.output}`, input);
-        }
-      }
-      for (const input of allInputs.values()) {
-        if (input.type === componentInput.type) {
-          addInstanceInput(inputName, input.input);
-          const key = `${input.input.instanceId}:${input.input.output}`;
-          if (injectionInputs.has(key)) {
-            matchedInjectionInputs.set(key, input);
-          }
-        }
-      }
-    }
-    const resolvedInputs = fromEntries(
-      Array.from(resolvedInputsMap.entries()).map(([inputName, inputs]) => [
-        inputName,
-        Array.from(inputs.values())
-      ])
-    );
-    return {
-      kind: "instance",
-      instance: node.instance,
-      component: node.component,
-      resolvedInputs,
-      resolvedOutputs: node.instance.resolvedOutputs,
-      resolvedInjectionInputs: Array.from(injectionInputs.values()),
-      matchedInjectionInputs: Array.from(matchedInjectionInputs.values())
-    };
-  }
-};
-function getResolvedHubInputs(output) {
-  if (output.kind !== "hub") {
-    throw new Error("Expected hub node");
-  }
-  return output.resolvedInputs;
-}
-function getResolvedInstanceInputs(output) {
-  if (output.kind !== "instance") {
-    throw new Error("Expected instance node");
-  }
-  return output.resolvedInputs;
-}
-function getResolvedInjectionInstanceInputs(output) {
-  if (output.kind !== "instance") {
-    throw new Error("Expected instance node");
-  }
-  return output.resolvedInjectionInputs;
-}
-function getMatchedInjectionInstanceInputs(output) {
-  if (output.kind !== "instance") {
-    throw new Error("Expected instance node");
-  }
-  return output.matchedInjectionInputs;
-}
-
-// src/shared/resolvers/input-hash.ts
-import { isUnitModel as isUnitModel2 } from "@highstate/contract";
-import { sha256 } from "crypto-hash";
-var InputHashResolver = class extends GraphResolver {
-  getNodeDependencies({ resolvedInputs }) {
-    const dependencies = [];
-    for (const inputs of Object.values(resolvedInputs ?? {})) {
-      for (const input of inputs) {
-        dependencies.push(input.input.instanceId);
-      }
-    }
-    return dependencies;
-  }
-  async processNode({
-    instance,
-    component,
-    resolvedInputs,
-    sourceHash,
-    state
-  }) {
-    let sink = component.definitionHash + JSON.stringify(instance.args ?? {});
-    if (sourceHash) {
-      sink += sourceHash;
-    } else if (isUnitModel2(component)) {
-      this.logger.warn(
-        { instanceId: instance.id },
-        "missing source hash for unit model, this may lead to incorrect input hash"
-      );
-    }
-    const sortedInputs = Object.entries(resolvedInputs).sort(([a], [b]) => a.localeCompare(b));
-    for (const [inputKey, inputs] of sortedInputs) {
-      if (Object.keys(inputs).length === 0) {
-        continue;
-      }
-      sink += inputKey;
-      const instanceIds = inputs.map((input) => input.input.instanceId);
-      instanceIds.sort();
-      for (const instanceId of instanceIds) {
-        const dependency = this.outputs.get(instanceId);
-        if (!dependency) continue;
-        sink += dependency.inputHash;
-        sink += dependency.outputHash;
-      }
-    }
-    return {
-      inputHash: await sha256(sink),
-      outputHash: state?.outputHash ?? ""
-    };
-  }
-};
-
-// src/shared/resolvers/validation.ts
-import { Ajv } from "ajv";
-var ValidationResolver = class extends GraphResolver {
-  getNodeDependencies({ resolvedInputs }) {
-    const dependencies = [];
-    for (const inputs of Object.values(resolvedInputs)) {
-      for (const input of inputs) {
-        dependencies.push(input.input.instanceId);
-      }
-    }
-    return dependencies;
-  }
-  processNode({ instance, component, resolvedInputs }) {
-    const ajv = new Ajv({ strict: false });
-    this.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])) {
-        this.logger.debug({ instanceId: instance.id, argumentName: name }, "invalid argument");
-        return {
-          status: "invalid-args",
-          errorText: `invalid argument "${name}": ${ajv.errorsText()}`
-        };
-      }
-    }
-    for (const inputs of Object.values(resolvedInputs)) {
-      for (const input of inputs) {
-        const inputInstance = this.outputs.get(input.input.instanceId);
-        if (inputInstance?.status !== "ok") {
-          return {
-            status: "invalid-inputs",
-            errorText: `instance "${input.input.instanceId}" has errors`
-          };
-        }
-      }
-    }
-    for (const [name, input] of Object.entries(component.inputs)) {
-      if (!input.required) {
-        continue;
-      }
-      if (!resolvedInputs[name] || !resolvedInputs[name].length) {
-        return {
-          status: "missing-inputs",
-          errorText: `input "${name}" is missing`
-        };
-      }
-    }
-    return { status: "ok" };
-  }
-};
-
-// src/shared/resolvers/registry.ts
-var resolverFactories = {
-  InputResolver,
-  InputHashResolver,
-  ValidationResolver
-};
-
-// src/shared/terminal.ts
-import { z as z4 } from "zod";
-var terminalSessionSchema = z4.object({
-  id: z4.string().nanoid(),
-  projectId: z4.string(),
-  instanceId: z4.string(),
-  terminalName: z4.string(),
-  terminalTitle: z4.string(),
-  createdAt: z4.coerce.date(),
-  finishedAt: z4.coerce.date().optional()
-});
-
-// src/shared/library.ts
-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;
-  }
-}
-
-// src/shared/async-batcher.ts
-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 {
-  positionSchema,
-  instanceInputSchema,
-  hubInstanceInputSchema,
-  instanceModelPatchSchema,
-  instanceModelSchema,
-  compositeInstanceSchema,
-  hubModelPatchSchema,
-  hubModelSchema,
-  instanceStatusSchema,
-  instanceStatusFieldValueSchema,
-  instanceStatusFieldSchema,
-  instanceFileMetaSchema,
-  instanceFileSchema,
-  instancePageBlockSchema,
-  instancePageMetaSchema,
-  instancePageSchema,
-  instanceTerminalMetaSchema,
-  instanceTerminalFileSchema,
-  instanceTerminalSchema,
-  instanceTriggerSpecSchema,
-  instanceTriggerSchema,
-  instanceTriggerInvocationSchema,
-  instanceStateSchema,
-  instanceStateUpdateSchema,
-  createInstanceState,
-  applyPartialInstanceState,
-  createInstanceStatePatch,
-  buildDependentInstanceStateMap,
-  getAllDependentInstanceIds,
-  operationTypeSchema,
-  operationStatusSchema,
-  operationOptionsSchema,
-  projectOperationRequestSchema,
-  projectOperationSchema,
-  isFinalOperationStatus,
-  GraphResolver,
-  InputResolver,
-  getResolvedHubInputs,
-  getResolvedInstanceInputs,
-  getResolvedInjectionInstanceInputs,
-  getMatchedInjectionInstanceInputs,
-  InputHashResolver,
-  ValidationResolver,
-  resolverFactories,
-  terminalSessionSchema,
-  diffLibraries,
-  applyLibraryUpdate,
-  createAsyncBatcher
-};
-//# sourceMappingURL=chunk-C2TJAQAD.js.map