@highstate/designer 0.2.1 → 0.2.2

package/.output/server/chunks/routes/api/_trpc_.mjs

@@ -1,1067 +0,0 @@
-import process from 'node:process';globalThis._importMeta_=globalThis._importMeta_||{url:"file:///_entry.js",env:process.env};import { e as eventHandler, r as readBody, t as toWebRequest, d as defineLazyEventHandler } from '../../nitro/nitro.mjs';
-import { resolveResponse } from '@trpc/server/http';
-import { initTRPC, TRPCError } from '@trpc/server';
-import { z } from 'zod';
-import { createConsola as createConsola$1 } from 'consola/core';
-import { fileURLToPath } from 'node:url';
-import { EventEmitter, on } from 'node:events';
-import { Worker } from 'node:worker_threads';
-import { basename, relative, dirname } from 'node:path';
-import Watcher from 'watcher';
-import { BetterLock } from 'better-lock';
-import { resolve } from 'import-meta-resolve';
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { pickBy, mapValues, debounce } from 'remeda';
-import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
-import { addDependency } from 'nypm';
-import 'node:http';
-import 'node:https';
-import 'node:fs';
-
-// src/server/index.ts
-function getPath(event) {
-  const { params } = event.context;
-  if (typeof params?.trpc === "string") {
-    return params.trpc;
-  }
-  if (params?.trpc && Array.isArray(params.trpc)) {
-    return params.trpc.join("/");
-  }
-  return null;
-}
-function createNuxtApiHandler(opts) {
-  return eventHandler(async (event) => {
-    const createContext = async (innerOpts) => {
-      return await opts.createContext?.(event, innerOpts);
-    };
-    const { req } = event.node;
-    const path = getPath(event);
-    if (event.method === "POST") {
-      req.body = await readBody(event);
-    }
-    const httpResponse = await resolveResponse({
-      ...opts,
-      req: toWebRequest(event),
-      error: null,
-      createContext,
-      path,
-      onError(o) {
-        opts.onError?.({
-          ...o,
-          req
-        });
-      }
-    });
-    return httpResponse;
-  });
-}
-
-const t = initTRPC.context().create();
-const publicProcedure = t.procedure;
-const router = t.router;
-t.middleware;
-
-const stateRouter = router({
-  get: publicProcedure.input(
-    z.object({
-      projectId: z.string()
-    })
-  ).query(async ({ input, ctx }) => {
-    const operator = await ctx.operatorManager.get(input.projectId);
-    return operator.state;
-  }),
-  watchCurrentOperation: publicProcedure.input(
-    z.object({
-      projectId: z.string()
-    })
-  ).subscription(async function* ({ input, ctx, signal }) {
-    const operator = await ctx.operatorManager.get(input.projectId);
-    yield* operator.watchCurrentOperation(signal);
-  }),
-  watchInstanceStates: publicProcedure.input(
-    z.object({
-      projectId: z.string()
-    })
-  ).subscription(async function* ({ input, ctx, signal }) {
-    const operator = await ctx.operatorManager.get(input.projectId);
-    yield* operator.watchInstanceStates(signal);
-  })
-});
-
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
-var _a;
-class LocalPulumiProjectHost {
-  constructor() {
-    __publicField$4(this, "lock", new BetterLock());
-    __publicField$4(this, "password", (_a = process.env.PULUMI_CONFIG_PASSPHRASE) != null ? _a : "");
-  }
-  hasPassword() {
-    return !!this.password;
-  }
-  setPassword(password) {
-    this.password = password;
-  }
-  async runInline(projectName, stackName, program, fn) {
-    return this.lock.acquire(`${projectName}.${stackName}`, async () => {
-      const { LocalWorkspace } = await import('@pulumi/pulumi/automation');
-      const stack = await LocalWorkspace.createOrSelectStack(
-        {
-          projectName,
-          stackName,
-          program
-        },
-        {
-          projectSettings: {
-            name: projectName,
-            runtime: "nodejs"
-          },
-          envVars: { PULUMI_CONFIG_PASSPHRASE: this.password }
-        }
-      );
-      return await fn(stack);
-    });
-  }
-  async runLocal(projectName, stackName, programPathResolver, fn) {
-    return this.lock.acquire(`${projectName}.${stackName}`, async () => {
-      const { LocalWorkspace } = await import('@pulumi/pulumi/automation');
-      const stack = await LocalWorkspace.createOrSelectStack(
-        {
-          stackName,
-          workDir: await programPathResolver()
-        },
-        {
-          envVars: { PULUMI_CONFIG_PASSPHRASE: this.password }
-        }
-      );
-      return await fn(stack);
-    });
-  }
-}
-
-const instanceStatusSchema = z.enum([
-  "not_created",
-  "updating",
-  "destroying",
-  "refreshing",
-  "created",
-  "error"
-]);
-const instanceStateSchema = z.object({
-  key: z.string(),
-  parentKey: z.string().optional(),
-  status: instanceStatusSchema,
-  resources: z.number(),
-  totalResources: z.number(),
-  error: z.string().optional(),
-  message: z.string().optional()
-});
-const operationType = z.enum(["update", "destroy", "recreate", "refresh"]);
-const projectOperation = z.object({
-  type: operationType,
-  instanceIds: z.array(z.string())
-});
-const projectStateSchema = z.object({
-  currentOperation: projectOperation.optional(),
-  instances: z.record(instanceStateSchema.optional())
-});
-const positionSchema = z.object({
-  x: z.number(),
-  y: z.number()
-});
-const outputRefSchema = z.object({
-  instanceId: z.string(),
-  output: z.string()
-});
-const instanceModelSchema = z.object({
-  id: z.string().nanoid(),
-  type: z.string(),
-  name: z.string(),
-  position: positionSchema,
-  args: z.record(z.any()),
-  inputs: z.record(z.union([outputRefSchema, z.array(outputRefSchema)]))
-});
-
-const stringArrayType = z.string().transform((args) => args.split(",").map((arg) => arg.trim()));
-
-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];
-}
-
-class SecretAccessDeniedError extends Error {
-  constructor(projectId, key) {
-    super(`Access to the secrets of component "${projectId}.${key}" is denied.`);
-  }
-}
-
-const localSecretBackendConfig = z.object({
-  HIGHSTATE_BACKEND_SECRET_PROJECT_PATH: z.string().optional(),
-  HIGHSTATE_BACKEND_SECRET_PROJECT_NAME: z.string().optional()
-});
-class LocalSecretBackend {
-  constructor(projectPath, projectName, pulumiProjectHost) {
-    this.projectPath = projectPath;
-    this.projectName = projectName;
-    this.pulumiProjectHost = pulumiProjectHost;
-  }
-  get(projectId, componentKey) {
-    return this.pulumiProjectHost.runLocal(
-      this.projectName,
-      projectId,
-      () => this.projectPath,
-      async (stack) => {
-        const config = await stack.getAllConfig();
-        const componentSecrets = pickBy(config, (_, key) => key.startsWith(`${componentKey}.`));
-        return mapValues(componentSecrets, (value) => value.value);
-      }
-    );
-  }
-  set(projectId, componentKey, values) {
-    return this.pulumiProjectHost.runLocal(
-      this.projectName,
-      projectId,
-      () => this.projectPath,
-      async (stack) => {
-        const componentSecrets = mapValues(values, (value, key) => ({
-          key: `${componentKey}.${key}`,
-          value
-        }));
-        const config = await stack.getAllConfig();
-        Object.assign(config, componentSecrets);
-        await stack.setAllConfig(config);
-      }
-    );
-  }
-  static async create(config, pulumiProjectHost) {
-    const [projectPath, projectName] = await resolveMainLocalProject(
-      config.HIGHSTATE_BACKEND_SECRET_PROJECT_PATH,
-      config.HIGHSTATE_BACKEND_SECRET_PROJECT_NAME
-    );
-    return new LocalSecretBackend(projectPath, projectName, pulumiProjectHost);
-  }
-}
-
-const secretBackendConfig = z.object({
-  HIGHSTATE_BACKEND_SECRET_TYPE: z.enum(["local"]).default("local"),
-  ...localSecretBackendConfig.shape
-});
-function createSecretBackend(config, pulumiProjectHost) {
-  return LocalSecretBackend.create(config, pulumiProjectHost);
-}
-
-const basicReporter = {
-  log(logObj) {
-    (console[logObj.type] || console.log)(...logObj.args);
-  }
-};
-function createConsola(options = {}) {
-  return createConsola$1({
-    reporters: [basicReporter],
-    ...options
-  });
-}
-const consola = createConsola();
-consola.consola = consola;
-
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
-const localLibraryBackendConfig = z.object({
-  HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES: stringArrayType.default("@highstate/library")
-});
-class LocalLibraryBackend {
-  constructor(modulePaths) {
-    this.modulePaths = modulePaths;
-    __publicField$3(this, "watcher");
-    __publicField$3(this, "lock", new BetterLock());
-    __publicField$3(this, "eventEmitter", new EventEmitter());
-    __publicField$3(this, "library", null);
-    this.watcher = new Watcher(modulePaths, { recursive: true, ignoreInitial: true });
-    this.watcher.on("all", (event, path) => {
-      const prefixPath = modulePaths.find((modulePath) => path.startsWith(modulePath));
-      consola.info("Library event:", event, relative(prefixPath, path));
-      void this.updateLibrary();
-    });
-    consola.info("Library watchers set to:", modulePaths);
-  }
-  async loadLibrary() {
-    if (this.library) {
-      return this.library;
-    }
-    return await this.updateLibrary();
-  }
-  async *watchLibrary(signal) {
-    for await (const [library] of on(this.eventEmitter, "library", { signal })) {
-      yield library;
-    }
-  }
-  async evaluateInstances(instances, instanceIds) {
-    const worker = this.createWorker("library-evaluator", {
-      modulePaths: this.modulePaths,
-      instances,
-      instanceIds
-    });
-    for await (const [registrations] of on(worker, "message")) {
-      return registrations;
-    }
-    throw new Error("Worker ended without sending registrations.");
-  }
-  async updateLibrary() {
-    return await this.lock.acquire(async () => {
-      const worker = this.createWorker("library-loader", { modulePaths: this.modulePaths });
-      for await (const [library] of on(worker, "message")) {
-        this.eventEmitter.emit("library", library);
-        this.library = library;
-        consola.success("Library reloaded");
-        return this.library;
-      }
-      throw new Error("Worker ended without sending library model.");
-    });
-  }
-  createWorker(module, workerData) {
-    const workerPathUrl = resolve(`@highstate/backend/${module}`, globalThis._importMeta_.url);
-    const workerPath = fileURLToPath(workerPathUrl);
-    return new Worker(workerPath, { workerData });
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  static async create(config) {
-    const modulePaths = [];
-    for (const module of config.HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES) {
-      const url = resolve(module, globalThis._importMeta_.url);
-      let path = fileURLToPath(url);
-      if (basename(path).includes(".")) {
-        path = dirname(path);
-      }
-      modulePaths.push(path);
-    }
-    return new LocalLibraryBackend(modulePaths);
-  }
-}
-
-const libraryBackendConfig = z.object({
-  HIGHSTATE_BACKEND_LIBRARY_TYPE: z.enum(["local"]).default("local"),
-  ...localLibraryBackendConfig.shape
-});
-function createLibraryBackend(config) {
-  switch (config.HIGHSTATE_BACKEND_LIBRARY_TYPE) {
-    case "local": {
-      return LocalLibraryBackend.create(config);
-    }
-  }
-}
-
-const localProjectBackendConfig = z.object({
-  HIGHSTATE_BACKEND_PROJECT_BLUEPRINTS_DIR: z.string().default("blueprints")
-});
-const blueprintModelSchema = z.object({
-  instances: z.record(instanceModelSchema)
-});
-class LocalProjectBackend {
-  constructor(blueprintsDir) {
-    this.blueprintsDir = blueprintsDir;
-  }
-  async getInstances(projectId) {
-    try {
-      const blueprint = await this.loadBlueprint(projectId);
-      return blueprint.instances;
-    } catch (error) {
-      console.error("Failed to read blueprint", error);
-      return {};
-    }
-  }
-  async updateInstance(projectId, instance) {
-    try {
-      const blueprint = await this.loadBlueprint(projectId);
-      blueprint.instances[instance.id] = instance;
-      await this.writeBlueprint(projectId, blueprint);
-    } catch (error) {
-      console.error("Failed to update blueprint instance", error);
-    }
-  }
-  async deleteInstance(projectId, instanceId) {
-    try {
-      const blueprint = await this.loadBlueprint(projectId);
-      delete blueprint.instances[instanceId];
-      await this.writeBlueprint(projectId, blueprint);
-    } catch (error) {
-      console.error("Failed to delete blueprint instance", error);
-    }
-  }
-  getBlueprintPath(projectId) {
-    return `${this.blueprintsDir}/${projectId}.json`;
-  }
-  async loadBlueprint(projectId) {
-    const blueprintPath = this.getBlueprintPath(projectId);
-    try {
-      const content = await readFile(blueprintPath, "utf-8");
-      return blueprintModelSchema.parse(JSON.parse(content));
-    } catch (error) {
-      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-        return { instances: {} };
-      }
-      throw error;
-    }
-  }
-  async writeBlueprint(projectId, blueprint) {
-    const blueprintPath = this.getBlueprintPath(projectId);
-    const content = JSON.stringify(blueprint, void 0, 2);
-    await writeFile(blueprintPath, content);
-  }
-  static async create(config) {
-    await mkdir(config.HIGHSTATE_BACKEND_PROJECT_BLUEPRINTS_DIR, { recursive: true });
-    return new LocalProjectBackend(config.HIGHSTATE_BACKEND_PROJECT_BLUEPRINTS_DIR);
-  }
-}
-
-const projectBackendConfig = z.object({
-  HIGHSTATE_BACKEND_PROJECT_TYPE: z.enum(["local"]).default("local"),
-  ...localProjectBackendConfig.shape
-});
-function createProjectBackend(config) {
-  return LocalProjectBackend.create(config);
-}
-
-const localStateBackendConfig = z.object({
-  HIGHSTATE_BACKEND_STATE_PROJECT_PATH: z.string().optional(),
-  HIGHSTATE_BACKEND_STATE_PROJECT_NAME: z.string().optional()
-});
-class LocalStateBackend {
-  constructor(projectName, pulumiProjectHost) {
-    this.projectName = projectName;
-    this.pulumiProjectHost = pulumiProjectHost;
-  }
-  get(projectId) {
-    return this.pulumiProjectHost.runInline(
-      this.projectName,
-      projectId,
-      () => Promise.resolve(),
-      (stack) => this.getAllState(stack)
-    );
-  }
-  set(projectId, state) {
-    return this.pulumiProjectHost.runInline(
-      this.projectName,
-      projectId,
-      () => Promise.resolve(),
-      async (stack) => {
-        await stack.setConfig("state", { value: JSON.stringify(state) });
-        await stack.up();
-      }
-    );
-  }
-  async getAllState(stack) {
-    const history = await stack.history(1);
-    if (!history.length) {
-      return { instances: {} };
-    }
-    if (!history[0].config["state"]) {
-      return { instances: {} };
-    }
-    const jsonValue = JSON.parse(history[0].config["state"].value);
-    return projectStateSchema.parse(jsonValue);
-  }
-  static async create(config, pulumiProjectHost) {
-    const [, projectName] = await resolveMainLocalProject(
-      config.HIGHSTATE_BACKEND_STATE_PROJECT_PATH,
-      config.HIGHSTATE_BACKEND_STATE_PROJECT_NAME
-    );
-    return new LocalStateBackend(projectName, pulumiProjectHost);
-  }
-}
-
-const stateBackendConfig = z.object({
-  HIGHSTATE_BACKEND_STATE_TYPE: z.enum(["local"]).default("local"),
-  ...localStateBackendConfig.shape
-});
-function createStateBackend(config, pulumiProjectHost) {
-  return LocalStateBackend.create(config, pulumiProjectHost);
-}
-
-const configSchema = z.object({
-  ...libraryBackendConfig.shape,
-  ...projectBackendConfig.shape,
-  ...secretBackendConfig.shape,
-  ...stateBackendConfig.shape
-});
-async function loadConfig(env = process.env, useDotenv = true) {
-  if (useDotenv) {
-    await import('dotenv/config');
-  }
-  return configSchema.parse(env);
-}
-
-function isUnitModel(model) {
-  return "source" in model;
-}
-
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-class ProjectOperator {
-  constructor(projectId, state, runnerBackend, stateBackend, libraryBackend, projectBackend, secretBackend) {
-    this.projectId = projectId;
-    this.state = state;
-    this.runnerBackend = runnerBackend;
-    this.stateBackend = stateBackend;
-    this.libraryBackend = libraryBackend;
-    this.projectBackend = projectBackend;
-    this.secretBackend = secretBackend;
-    __publicField$2(this, "unitPromises", /* @__PURE__ */ new Map());
-    __publicField$2(this, "eventEmitter", new EventEmitter());
-    __publicField$2(this, "debouncedUpdateState", debounce(() => this.stateBackend.set(this.projectId, this.state), {
-      waitMs: 1e3,
-      maxWaitMs: 1e4
-    }));
-    __publicField$2(this, "abortController", new AbortController());
-  }
-  async *watchInstanceStates(signal) {
-    for await (const [state] of on(this.eventEmitter, "state", { signal })) {
-      yield state;
-    }
-  }
-  async *watchCurrentOperation(signal) {
-    for await (const [operation] of on(this.eventEmitter, "operation", { signal })) {
-      yield operation;
-    }
-  }
-  /**
-   * Launches the project operation.
-   * Throws an error if the operation is already running.
-   *
-   * @param operation The operation to launch.
-   */
-  launch(operation) {
-    if (this.state.currentOperation) {
-      throw new Error("An operation is already running.");
-    }
-    this.abortController = new AbortController();
-    this.updateCurrentOperation(operation);
-    void this.operate().finally(() => {
-      this.updateCurrentOperation(void 0);
-    });
-  }
-  /**
-   * Cancels the current operation.
-   * Does nothing if no operation is running.
-   */
-  cancel() {
-    if (!this.state.currentOperation) {
-      return;
-    }
-    this.abortController.abort();
-  }
-  async operate() {
-    await this.debouncedUpdateState.flush();
-    const operation = this.state.currentOperation;
-    const instances = await this.projectBackend.getInstances(this.projectId);
-    const library = await this.libraryBackend.loadLibrary();
-    const registrations = await this.libraryBackend.evaluateInstances(
-      instances,
-      operation.instanceIds
-    );
-    const promises = [];
-    for (const registration of Object.values(registrations)) {
-      const promise = this.upUnit(library, registrations, registration);
-      promises.push(promise);
-    }
-    await Promise.all(promises);
-  }
-  async upUnit(library, registrations, registration) {
-    const model = library.components[registration.type];
-    if (!isUnitModel(model)) {
-      throw new Error(`The component "${registration.type}" is not a unit.`);
-    }
-    const key = `${registration.type}.${registration.name}`;
-    const dependencyPromises = [];
-    for (const dependency of registration.dependencies) {
-      const state = this.state.instances[dependency];
-      if ((state == null ? void 0 : state.status) === "created") {
-        continue;
-      }
-      const dependencyPromise = this.getOrCreateUnitPromise(
-        key,
-        () => this.upUnit(library, registrations, registrations[dependency])
-      );
-      dependencyPromises.push(dependencyPromise);
-    }
-    await Promise.all(dependencyPromises);
-    await this.runnerBackend.update({
-      projectName: registration.type,
-      stackName: registration.name,
-      config: await this.getUnitConfig(model, key, registration),
-      source: model.source
-    });
-    const stream = this.runnerBackend.watch({
-      projectName: registration.type,
-      stackName: registration.name,
-      finalStatuses: ["created", "error"]
-    });
-    await this.watchStateStream(stream);
-  }
-  async getUnitConfig(model, key, registration) {
-    const secrets = await this.secretBackend.get(this.projectId, `${model.type}.${key}`);
-    return {
-      ...registration.config,
-      ...secrets
-    };
-  }
-  async watchStateStream(stream) {
-    let state;
-    for await (state of stream) {
-      this.updateInstanceState(state);
-    }
-    if (!state) {
-      throw new Error("The stream ended without emitting any state.");
-    }
-    if (state.status === "error") {
-      throw new Error(`The operation on unit "${state.key}" failed.`);
-    }
-  }
-  updateCurrentOperation(operation) {
-    this.state.currentOperation = operation;
-    this.eventEmitter.emit("operation", operation);
-    void this.debouncedUpdateState.call();
-  }
-  updateInstanceState(state) {
-    this.state.instances[state.key] = state;
-    this.eventEmitter.emit("state", state);
-    void this.debouncedUpdateState.call();
-  }
-  getOrCreateUnitPromise(unitKey, fn) {
-    let promise = this.unitPromises.get(unitKey);
-    if (!promise) {
-      promise = fn().then(() => {
-        this.unitPromises.delete(unitKey);
-      });
-      this.unitPromises.set(unitKey, promise);
-    }
-    return promise;
-  }
-  static async create(projectId, runnerBackend, stateBackend, libraryBackend, projectBackend, secretBackend) {
-    const state = await stateBackend.get(projectId);
-    return new ProjectOperator(
-      projectId,
-      state,
-      runnerBackend,
-      stateBackend,
-      libraryBackend,
-      projectBackend,
-      secretBackend
-    );
-  }
-}
-
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
-class OperatorManager {
-  constructor(runnerBackend, stateBackend, libraryBackend, projectBackend, secretBackend) {
-    this.runnerBackend = runnerBackend;
-    this.stateBackend = stateBackend;
-    this.libraryBackend = libraryBackend;
-    this.projectBackend = projectBackend;
-    this.secretBackend = secretBackend;
-    __publicField$1(this, "operators", /* @__PURE__ */ new Map());
-    __publicField$1(this, "lock", new BetterLock());
-  }
-  async get(projectId) {
-    return await this.lock.acquire(projectId, async () => {
-      let orchestrator = this.operators.get(projectId);
-      if (!orchestrator) {
-        orchestrator = await ProjectOperator.create(
-          projectId,
-          this.runnerBackend,
-          this.stateBackend,
-          this.libraryBackend,
-          this.projectBackend,
-          this.secretBackend
-        );
-        this.operators.set(projectId, orchestrator);
-      }
-      return orchestrator;
-    });
-  }
-}
-
-class InvalidInstanceStatusError 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;
-  }
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-class LocalRunnerBackend {
-  constructor() {
-    __publicField(this, "host", new LocalPulumiProjectHost());
-    __publicField(this, "events", new EventEmitter());
-    __publicField(this, "states", /* @__PURE__ */ new Map());
-  }
-  async *watch(options) {
-    const stream = on(
-      //
-      this.events,
-      `state:${LocalRunnerBackend.getInstanceKey(options)}`,
-      { signal: options.signal }
-    );
-    for await (const [state] of stream) {
-      yield state;
-      if (options.finalStatuses.includes(state.status)) {
-        return;
-      }
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async update(options) {
-    const currentStatus = this.validateStatus(options, [
-      "not_created",
-      "updating",
-      "created",
-      "error"
-    ]);
-    if (currentStatus === "updating") {
-      return;
-    }
-    void this.host.runLocal(
-      options.projectName,
-      options.stackName,
-      () => LocalRunnerBackend.resolveProjectPath(options.source),
-      async (stack) => {
-        const configMap = mapValues(options.config, (value) => ({ value }));
-        await stack.setAllConfig(configMap);
-        const state = {
-          key: LocalRunnerBackend.getInstanceKey(options),
-          status: "updating",
-          resources: 0,
-          totalResources: 0
-        };
-        this.updateState(state);
-        try {
-          await stack.up({
-            onEvent: (event) => {
-              if (event.resourcePreEvent) {
-                state.totalResources++;
-                this.updateState(state);
-                return;
-              }
-              if (event.resOutputsEvent) {
-                state.resources++;
-                this.updateState(state);
-                return;
-              }
-            },
-            onOutput: (message) => {
-              state.message = message;
-              this.updateState(state);
-            },
-            signal: options.signal
-          });
-          state.status = "created";
-          this.updateState(state);
-        } catch (e) {
-          state.status = "error";
-          state.error = e instanceof Error ? e.message : String(e);
-          this.updateState(state);
-        }
-      }
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async destroy(options) {
-    const currentStatus = this.validateStatus(options, [
-      "not_created",
-      "destroying",
-      "created",
-      "error"
-    ]);
-    if (currentStatus === "destroying" || currentStatus === "not_created") {
-      return;
-    }
-    void this.host.runLocal(
-      options.projectName,
-      options.stackName,
-      () => LocalRunnerBackend.resolveProjectPath(options.source),
-      async (stack) => {
-        var _a;
-        const stackSumary = await stack.workspace.stack();
-        const resources = (_a = stackSumary == null ? void 0 : stackSumary.resourceCount) != null ? _a : 0;
-        const state = {
-          key: LocalRunnerBackend.getInstanceKey(options),
-          status: "destroying",
-          resources,
-          totalResources: resources
-        };
-        this.updateState(state);
-        try {
-          await stack.destroy({
-            onEvent: (event) => {
-              if (event.resOutputsEvent) {
-                state.resources--;
-                this.updateState(state);
-                return;
-              }
-            },
-            signal: options.signal
-          });
-          state.status = "not_created";
-          this.updateState(state);
-        } catch (e) {
-          state.status = "error";
-          state.error = e instanceof Error ? e.message : String(e);
-          this.updateState(state);
-        }
-      }
-    );
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async refresh(options) {
-    const currentStatus = this.validateStatus(options, [
-      "not_created",
-      "created",
-      "refreshing",
-      "error"
-    ]);
-    if (currentStatus === "refreshing") {
-      return;
-    }
-    void this.host.runLocal(
-      options.projectName,
-      options.stackName,
-      () => LocalRunnerBackend.resolveProjectPath(options.source),
-      async (stack) => {
-        var _a;
-        const stackSumary = await stack.workspace.stack();
-        const resources = (_a = stackSumary == null ? void 0 : stackSumary.resourceCount) != null ? _a : 0;
-        const state = {
-          key: LocalRunnerBackend.getInstanceKey(options),
-          status: "refreshing",
-          resources,
-          totalResources: resources
-        };
-        this.updateState(state);
-        try {
-          await stack.refresh({
-            onEvent: (event) => {
-              if (event.resOutputsEvent) {
-                if (event.resOutputsEvent.metadata.op === "create") {
-                  state.resources++;
-                  this.updateState(state);
-                  return;
-                }
-                if (event.resOutputsEvent.metadata.op === "delete") {
-                  state.totalResources--;
-                  this.updateState(state);
-                  return;
-                }
-                return;
-              }
-            },
-            signal: options.signal
-          });
-          state.status = "created";
-          this.updateState(state);
-        } catch (e) {
-          state.status = "error";
-          state.error = e instanceof Error ? e.message : String(e);
-          this.updateState(state);
-        }
-      }
-    );
-  }
-  updateState(state) {
-    this.states.set(state.key, state);
-    this.events.emit(`state:${state.key}`, state);
-  }
-  validateStatus(options, expectedStatuses) {
-    const key = LocalRunnerBackend.getInstanceKey(options);
-    const existingState = this.states.get(key);
-    if (!existingState) {
-      return;
-    }
-    if (!expectedStatuses.includes(existingState.status)) {
-      throw new InvalidInstanceStatusError(existingState.status, expectedStatuses);
-    }
-    return existingState.status;
-  }
-  static getInstanceKey(options) {
-    return `${options.projectName}.${options.stackName}`;
-  }
-  static async resolveProjectPath(source) {
-    await addDependency(source.package);
-    const url = resolve(source.package, globalThis._importMeta_.url);
-    const path = fileURLToPath(url);
-    const projectPath = dirname(path);
-    return projectPath;
-  }
-  // eslint-disable-next-line @typescript-eslint/require-await
-  static async create() {
-    return new LocalRunnerBackend();
-  }
-}
-
-function createRunnerBackend() {
-  return LocalRunnerBackend.create();
-}
-
-async function createServices(config) {
-  config != null ? config : config = await loadConfig();
-  const pulumiProjectHost = new LocalPulumiProjectHost();
-  const libraryBackend = await createLibraryBackend(config);
-  const secretBackend = await createSecretBackend(config, pulumiProjectHost);
-  const runnerBackend = await createRunnerBackend();
-  const projectBackend = await createProjectBackend(config);
-  const stateBackend = await createStateBackend(config, pulumiProjectHost);
-  const operatorManager = new OperatorManager(
-    runnerBackend,
-    stateBackend,
-    libraryBackend,
-    projectBackend,
-    secretBackend
-  );
-  consola.success("Backend services initialized");
-  return {
-    libraryBackend,
-    secretBackend,
-    runnerBackend,
-    projectBackend,
-    stateBackend,
-    operatorManager
-  };
-}
-
-const secretRouter = router({
-  get: publicProcedure.input(
-    z.object({
-      projectId: z.string(),
-      instanceKey: z.string()
-    })
-  ).query(async ({ input, ctx }) => {
-    try {
-      return await ctx.secretBackend.get(input.projectId, input.instanceKey);
-    } catch (e) {
-      if (e instanceof SecretAccessDeniedError) {
-        throw new TRPCError({
-          code: "FORBIDDEN",
-          message: "Access to the secret is denied",
-          cause: e
-        });
-      }
-      throw e;
-    }
-  }),
-  set: publicProcedure.input(
-    z.object({
-      projectId: z.string(),
-      instanceKey: z.string(),
-      values: z.record(z.string())
-    })
-  ).mutation(async ({ input, ctx }) => {
-    try {
-      await ctx.secretBackend.set(input.projectId, input.instanceKey, input.values);
-    } catch (e) {
-      if (e instanceof SecretAccessDeniedError) {
-        throw new TRPCError({
-          code: "FORBIDDEN",
-          message: "Access to the secret is denied",
-          cause: e
-        });
-      }
-      throw e;
-    }
-  })
-});
-
-const projectRouter = router({
-  getInstances: publicProcedure.input(
-    z.object({
-      projectId: z.string()
-    })
-  ).query(async ({ input, ctx }) => {
-    return await ctx.projectBackend.getInstances(input.projectId);
-  }),
-  updateInstance: publicProcedure.input(
-    z.object({
-      projectId: z.string(),
-      instance: instanceModelSchema
-    })
-  ).mutation(async ({ input, ctx }) => {
-    await ctx.projectBackend.updateInstance(input.projectId, input.instance);
-  }),
-  deleteInstance: publicProcedure.input(
-    z.object({
-      projectId: z.string(),
-      instanceKey: z.string()
-    })
-  ).mutation(async ({ input, ctx }) => {
-    await ctx.projectBackend.deleteInstance(input.projectId, input.instanceKey);
-  })
-});
-
-const libraryRouter = router({
-  get: publicProcedure.query(async ({ ctx }) => {
-    return await ctx.libraryBackend.loadLibrary();
-  }),
-  canWatch: publicProcedure.query(async ({ ctx }) => {
-    return !!ctx.libraryBackend.watchLibrary;
-  }),
-  watch: publicProcedure.subscription(async function* ({ ctx, signal }) {
-    if (!ctx.libraryBackend.watchLibrary) {
-      return;
-    }
-    yield* ctx.libraryBackend.watchLibrary(signal);
-  })
-});
-
-const viewportSchema = z.object({
-  x: z.number(),
-  y: z.number(),
-  zoom: z.number()
-});
-let viewport = { x: 0, y: 0, zoom: 1 };
-const workspaceRouter = router({
-  viewport: publicProcedure.query(() => {
-    return viewport;
-  }),
-  setViewport: publicProcedure.input(viewportSchema).mutation(({ input }) => {
-    viewport = input;
-  })
-});
-
-const appRouter = router({
-  secret: secretRouter,
-  state: stateRouter,
-  project: projectRouter,
-  library: libraryRouter,
-  workspace: workspaceRouter
-});
-
-const _trpc_ = defineLazyEventHandler(async () => {
-  const services = await createServices();
-  return createNuxtApiHandler({
-    router: appRouter,
-    createContext: () => ({
-      ...services
-    }),
-    onError: (error) => {
-      console.error("Server Error", error);
-    }
-  });
-});
-
-export { _trpc_ as default };
-//# sourceMappingURL=_trpc_.mjs.map