@highstate/backend 0.4.1 → 0.4.2

package/dist/index.d.ts

@@ -1,242 +1,71 @@
-import { Stack } from '@pulumi/pulumi/automation';
 import { z } from 'zod';
-import { ComponentModel, Entity, UnitRegistration, UnitSource } from '@highstate/contract';
-
-declare class LocalPulumiProjectHost {
-    private lock;
-    private password;
-    hasPassword(): boolean;
-    setPassword(password: string): void;
-    runInline<T>(projectName: string, stackName: string, program: () => Promise<void> | Promise<Record<string, unknown>>, fn: (stack: Stack) => Promise<T>): Promise<T>;
-    runLocal<T>(projectName: string, stackName: string, programPathResolver: () => Promise<string> | string, fn: (stack: Stack) => Promise<T>): Promise<T>;
-}
-
-declare const instanceStatusSchema: z.ZodEnum<["not_created", "updating", "destroying", "refreshing", "created", "error"]>;
-declare const instanceStateSchema: z.ZodObject<{
-    key: z.ZodString;
-    parentKey: z.ZodOptional<z.ZodString>;
-    status: z.ZodEnum<["not_created", "updating", "destroying", "refreshing", "created", "error"]>;
-    resources: z.ZodNumber;
-    totalResources: z.ZodNumber;
-    error: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-    status: "not_created" | "updating" | "destroying" | "refreshing" | "created" | "error";
-    resources: number;
-    totalResources: number;
-    error?: string | undefined;
-    parentKey?: string | undefined;
-    message?: string | undefined;
-}, {
-    key: string;
-    status: "not_created" | "updating" | "destroying" | "refreshing" | "created" | "error";
-    resources: number;
-    totalResources: number;
-    error?: string | undefined;
-    parentKey?: string | undefined;
-    message?: string | undefined;
-}>;
-declare const operationType: z.ZodEnum<["update", "destroy", "recreate", "refresh"]>;
-declare const projectOperation: z.ZodObject<{
-    type: z.ZodEnum<["update", "destroy", "recreate", "refresh"]>;
-    instanceIds: z.ZodArray<z.ZodString, "many">;
-}, "strip", z.ZodTypeAny, {
-    type: "update" | "destroy" | "recreate" | "refresh";
-    instanceIds: string[];
-}, {
-    type: "update" | "destroy" | "recreate" | "refresh";
-    instanceIds: string[];
-}>;
-declare const projectStateSchema: z.ZodObject<{
-    currentOperation: z.ZodOptional<z.ZodObject<{
-        type: z.ZodEnum<["update", "destroy", "recreate", "refresh"]>;
-        instanceIds: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        type: "update" | "destroy" | "recreate" | "refresh";
-        instanceIds: string[];
-    }, {
-        type: "update" | "destroy" | "recreate" | "refresh";
-        instanceIds: string[];
-    }>>;
-    instances: z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
-        key: z.ZodString;
-        parentKey: z.ZodOptional<z.ZodString>;
-        status: z.ZodEnum<["not_created", "updating", "destroying", "refreshing", "created", "error"]>;
-        resources: z.ZodNumber;
-        totalResources: z.ZodNumber;
-        error: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        key: string;
-        status: "not_created" | "updating" | "destroying" | "refreshing" | "created" | "error";
-        resources: number;
-        totalResources: number;
-        error?: string | undefined;
-        parentKey?: string | undefined;
-        message?: string | undefined;
-    }, {
-        key: string;
-        status: "not_created" | "updating" | "destroying" | "refreshing" | "created" | "error";
-        resources: number;
-        totalResources: number;
-        error?: string | undefined;
-        parentKey?: string | undefined;
-        message?: string | undefined;
-    }>>>;
-}, "strip", z.ZodTypeAny, {
-    instances: Record<string, {
-        key: string;
-        status: "not_created" | "updating" | "destroying" | "refreshing" | "created" | "error";
-        resources: number;
-        totalResources: number;
-        error?: string | undefined;
-        parentKey?: string | undefined;
-        message?: string | undefined;
-    } | undefined>;
-    currentOperation?: {
-        type: "update" | "destroy" | "recreate" | "refresh";
-        instanceIds: string[];
-    } | undefined;
-}, {
-    instances: Record<string, {
-        key: string;
-        status: "not_created" | "updating" | "destroying" | "refreshing" | "created" | "error";
-        resources: number;
-        totalResources: number;
-        error?: string | undefined;
-        parentKey?: string | undefined;
-        message?: string | undefined;
-    } | undefined>;
-    currentOperation?: {
-        type: "update" | "destroy" | "recreate" | "refresh";
-        instanceIds: string[];
-    } | undefined;
-}>;
-declare const positionSchema: z.ZodObject<{
-    x: z.ZodNumber;
-    y: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    x: number;
-    y: number;
-}, {
-    x: number;
-    y: number;
-}>;
-declare const outputRefSchema: z.ZodObject<{
-    instanceId: z.ZodString;
-    output: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    instanceId: string;
-    output: string;
-}, {
-    instanceId: string;
-    output: string;
-}>;
-declare const instanceModelSchema: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodString;
-    name: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        x: number;
-        y: number;
-    }, {
-        x: number;
-        y: number;
-    }>;
-    args: z.ZodRecord<z.ZodString, z.ZodAny>;
-    inputs: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        instanceId: z.ZodString;
-        output: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        instanceId: string;
-        output: string;
-    }, {
-        instanceId: string;
-        output: string;
-    }>, z.ZodArray<z.ZodObject<{
-        instanceId: z.ZodString;
-        output: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        instanceId: string;
-        output: string;
-    }, {
-        instanceId: string;
-        output: string;
-    }>, "many">]>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    type: string;
-    id: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    args: Record<string, any>;
-    inputs: Record<string, {
-        instanceId: string;
-        output: string;
-    } | {
-        instanceId: string;
-        output: string;
-    }[]>;
-}, {
-    name: string;
-    type: string;
-    id: string;
-    position: {
-        x: number;
-        y: number;
-    };
-    args: Record<string, any>;
-    inputs: Record<string, {
-        instanceId: string;
-        output: string;
-    } | {
-        instanceId: string;
-        output: string;
-    }[]>;
-}>;
-type OperationType = z.infer<typeof operationType>;
-type ProjectOperation = z.infer<typeof projectOperation>;
-type InstanceStatus = z.infer<typeof instanceStatusSchema>;
-type InstanceState = z.infer<typeof instanceStateSchema>;
-type ProjectState = z.infer<typeof projectStateSchema>;
-type Position = z.infer<typeof positionSchema>;
-type OutputRef = z.infer<typeof outputRefSchema>;
-type InstanceModel = z.infer<typeof instanceModelSchema>;
-
-declare const stringArrayType: z.ZodEffects<z.ZodString, string[], string>;
-
-declare function resolveMainLocalProject(projectPath: string | undefined, projectName: string | undefined): Promise<[projecPath: string, projectName: string]>;
+import { WhoAmIResult, Stack, ConfigMap } from '@pulumi/pulumi/automation';
+import { Logger } from 'pino';
+import { ComponentModel, Entity, BaseInstanceModel, CompositeInstance, InstanceInputMap, UnitSource } from '@highstate/contract';
+import { I as InstanceModel, P as Position, a as ProjectOperation, b as InstanceState, c as InstanceStatePatch, T as TerminalFactory, d as InstanceStatus, e as ProjectOperationRequest } from './operation-8k4Tv4dw.js';
+import { BetterLock } from 'better-lock/dist/better_lock';
+import { Stream, Writable, PassThrough } from 'node:stream';
 
 declare class SecretAccessDeniedError extends Error {
     constructor(projectId: string, key: string);
 }
 interface SecretBackend {
+    /**
+     * Check if the state and secrets of the project are locked.
+     * The backend may not implement this method.
+     *
+     * @param projectId The ID of the project.
+     *
+     * @returns `true` if the project is locked, `false` if the project is unlocked.
+     */
+    isLocked?(projectId: string): Promise<boolean>;
+    /**
+     * Unlock the state and secrets of the project.
+     * The backend may not implement this method.
+     *
+     * @param projectId The ID of the project.
+     * @param password The password to unlock the secrets.
+     *
+     * @returns `true` if the project is unlocked, `false` if the password is incorrect.
+     */
+    unlock?(projectId: string, password: string): Promise<boolean>;
     /**
      * Get the secrets of the component.
      *
      * @param projectId The ID of the project.
-     * @param instanceKey The key of the component instance.
+     * @param instanceId The ID of the instance.
      *
      * @returns A record of secret key-value pairs or `null` if the secrets are not found.
      * @throws {SecretAccessDeniedError} If access to the secrets is denied.
      */
-    get(projectId: string, instanceKey: string): Promise<Record<string, string>>;
+    get(projectId: string, instanceId: string): Promise<Record<string, unknown>>;
     /**
      * Set the secrets of the component.
      *
      * @param projectId The ID of the project.
-     * @param instanceKey The key of the component instance.
+     * @param instanceId The ID of the instance.
      * @param values The record of secret key-value pairs.
      *
      * @throws {SecretAccessDeniedError} If access to the secrets is denied.
      */
-    set(projectId: string, instanceKey: string, values: Record<string, string>): Promise<void>;
+    set(projectId: string, instanceId: string, values: Record<string, unknown>): Promise<void>;
+}
+
+declare class LocalPulumiHost {
+    private readonly logger;
+    private lock;
+    private constructor();
+    getCurrentUser(): Promise<WhoAmIResult | null>;
+    runInline<T>(projectId: string, pulumiProjectName: string, pulumiStackName: string, program: () => Promise<void> | Promise<Record<string, unknown>>, fn: (stack: Stack) => Promise<T>): Promise<T>;
+    runEmpty<T>(projectId: string, pulumiProjectName: string, pulumiStackName: string, fn: (stack: Stack) => Promise<T>): Promise<T>;
+    runLocal<T>(projectId: string, pulumiProjectName: string, pulumiStackName: string, programPathResolver: () => Promise<string> | string, fn: (stack: Stack) => Promise<T>, stackConfig?: ConfigMap): Promise<T>;
+    private sharedPassword;
+    private passwords;
+    hasPassword(projectId: string): boolean;
+    setPassword(projectId: string, password: string): void;
+    private getPassword;
+    static tryUnlockStack(stack: Stack, error: unknown): Promise<boolean>;
+    static create(logger: Logger): LocalPulumiHost;
 }
 
 declare const secretBackendConfig: z.ZodObject<{
@@ -252,22 +81,12 @@ declare const secretBackendConfig: z.ZodObject<{
     HIGHSTATE_BACKEND_SECRET_PROJECT_NAME?: string | undefined;
     HIGHSTATE_BACKEND_SECRET_TYPE?: "local" | undefined;
 }>;
-declare function createSecretBackend(config: z.infer<typeof secretBackendConfig>, pulumiProjectHost: LocalPulumiProjectHost): Promise<SecretBackend>;
+declare function createSecretBackend(config: z.infer<typeof secretBackendConfig>, localPulumiHost: LocalPulumiHost, logger: Logger): Promise<SecretBackend>;
 
 type LibraryModel = Readonly<{
     components: Readonly<Record<string, ComponentModel>>;
     entities: Readonly<Record<string, Entity>>;
 }>;
-type EvaluationInput = {
-    instanceId: string;
-    output: string;
-};
-type EvaluationInstance = {
-    type: string;
-    name: string;
-    args: Record<string, unknown>;
-    inputs: Record<string, EvaluationInput | EvaluationInput[]>;
-};
 interface LibraryBackend {
     /**
      * Loads the library.
@@ -279,12 +98,18 @@ interface LibraryBackend {
      */
     watchLibrary?(signal?: AbortSignal): AsyncIterable<LibraryModel>;
     /**
-     * Evaluates the instances and returns the stack registrations.
+     * Evaluates the instances and returns the evaluated composite instances.
      *
      * @param allInstances The all instances defined in the project.
-     * @param instanceIds The instance IDs to evaluate. If not provided, all instances are evaluated.
+     * @param instanceIds The instance IDs to evaluate.
      */
-    evaluateInstances(allInstances: Record<string, EvaluationInstance>, instanceIds?: string[]): Promise<Record<string, UnitRegistration>>;
+    evaluateCompositeInstances(allInstances: BaseInstanceModel[], instanceIds: string[]): Promise<readonly CompositeInstance[]>;
+    /**
+     * Evaluates the modules and returns the evaluated instances.
+     *
+     * @param modulePaths The module paths to evaluate.
+     */
+    evaluateModules(modulePaths: string[]): Promise<readonly BaseInstanceModel[]>;
 }
 
 declare const libraryBackendConfig: z.ZodObject<{
@@ -297,16 +122,27 @@ declare const libraryBackendConfig: z.ZodObject<{
     HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES?: string | undefined;
     HIGHSTATE_BACKEND_LIBRARY_TYPE?: "local" | undefined;
 }>;
-declare function createLibraryBackend(config: z.infer<typeof libraryBackendConfig>): Promise<LibraryBackend>;
+declare function createLibraryBackend(config: z.infer<typeof libraryBackendConfig>, logger: Logger): LibraryBackend;
 
 declare const configSchema: z.ZodObject<{
-    HIGHSTATE_BACKEND_STATE_PROJECT_PATH: z.ZodOptional<z.ZodString>;
-    HIGHSTATE_BACKEND_STATE_PROJECT_NAME: z.ZodOptional<z.ZodString>;
+    HIGHSTATE_BACKEND_LOGGER_NAME: z.ZodDefault<z.ZodString>;
+    HIGHSTATE_BACKEND_LOGGER_LEVEL: z.ZodDefault<z.ZodEnum<["fatal", "error", "warn", "info", "debug", "trace"]>>;
+    HIGHSTATE_BACKEND_WORKSPACE_LOCAL_DIR: z.ZodOptional<z.ZodString>;
+    HIGHSTATE_BACKEND_WORKSPACE_TYPE: z.ZodDefault<z.ZodEnum<["local"]>>;
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY: z.ZodDefault<z.ZodString>;
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST: z.ZodOptional<z.ZodString>;
+    HIGHSTATE_BACKEND_TERMINAL_TYPE: z.ZodDefault<z.ZodEnum<["docker"]>>;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_SOURCE_CHECK: z.ZodDefault<z.ZodBoolean>;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK: z.ZodDefault<z.ZodBoolean>;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT: z.ZodDefault<z.ZodBoolean>;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_SOURCE_BASE_PATH: z.ZodOptional<z.ZodString>;
+    HIGHSTATE_BACKEND_RUNNER_TYPE: z.ZodDefault<z.ZodEnum<["local"]>>;
+    HIGHSTATE_BACKEND_STATE_LOCAL_DIR: z.ZodOptional<z.ZodString>;
     HIGHSTATE_BACKEND_STATE_TYPE: z.ZodDefault<z.ZodEnum<["local"]>>;
     HIGHSTATE_BACKEND_SECRET_PROJECT_PATH: z.ZodOptional<z.ZodString>;
     HIGHSTATE_BACKEND_SECRET_PROJECT_NAME: z.ZodOptional<z.ZodString>;
     HIGHSTATE_BACKEND_SECRET_TYPE: z.ZodDefault<z.ZodEnum<["local"]>>;
-    HIGHSTATE_BACKEND_PROJECT_BLUEPRINTS_DIR: z.ZodDefault<z.ZodString>;
+    HIGHSTATE_BACKEND_PROJECT_PROJECTS_DIR: z.ZodOptional<z.ZodString>;
     HIGHSTATE_BACKEND_PROJECT_TYPE: z.ZodDefault<z.ZodEnum<["local"]>>;
     HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES: z.ZodDefault<z.ZodEffects<z.ZodString, string[], string>>;
     HIGHSTATE_BACKEND_LIBRARY_TYPE: z.ZodDefault<z.ZodEnum<["local"]>>;
@@ -314,195 +150,519 @@ declare const configSchema: z.ZodObject<{
     HIGHSTATE_BACKEND_SECRET_TYPE: "local";
     HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES: string[];
     HIGHSTATE_BACKEND_LIBRARY_TYPE: "local";
-    HIGHSTATE_BACKEND_PROJECT_BLUEPRINTS_DIR: string;
     HIGHSTATE_BACKEND_PROJECT_TYPE: "local";
     HIGHSTATE_BACKEND_STATE_TYPE: "local";
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_SOURCE_CHECK: boolean;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK: boolean;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT: boolean;
+    HIGHSTATE_BACKEND_RUNNER_TYPE: "local";
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY: string;
+    HIGHSTATE_BACKEND_TERMINAL_TYPE: "docker";
+    HIGHSTATE_BACKEND_WORKSPACE_TYPE: "local";
+    HIGHSTATE_BACKEND_LOGGER_NAME: string;
+    HIGHSTATE_BACKEND_LOGGER_LEVEL: "fatal" | "error" | "warn" | "info" | "debug" | "trace";
     HIGHSTATE_BACKEND_SECRET_PROJECT_PATH?: string | undefined;
     HIGHSTATE_BACKEND_SECRET_PROJECT_NAME?: string | undefined;
-    HIGHSTATE_BACKEND_STATE_PROJECT_PATH?: string | undefined;
-    HIGHSTATE_BACKEND_STATE_PROJECT_NAME?: string | undefined;
+    HIGHSTATE_BACKEND_PROJECT_PROJECTS_DIR?: string | undefined;
+    HIGHSTATE_BACKEND_STATE_LOCAL_DIR?: string | undefined;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_SOURCE_BASE_PATH?: string | undefined;
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST?: string | undefined;
+    HIGHSTATE_BACKEND_WORKSPACE_LOCAL_DIR?: string | undefined;
 }, {
     HIGHSTATE_BACKEND_SECRET_PROJECT_PATH?: string | undefined;
     HIGHSTATE_BACKEND_SECRET_PROJECT_NAME?: string | undefined;
     HIGHSTATE_BACKEND_SECRET_TYPE?: "local" | undefined;
     HIGHSTATE_BACKEND_LIBRARY_LOCAL_MODULES?: string | undefined;
     HIGHSTATE_BACKEND_LIBRARY_TYPE?: "local" | undefined;
-    HIGHSTATE_BACKEND_PROJECT_BLUEPRINTS_DIR?: string | undefined;
+    HIGHSTATE_BACKEND_PROJECT_PROJECTS_DIR?: string | undefined;
     HIGHSTATE_BACKEND_PROJECT_TYPE?: "local" | undefined;
-    HIGHSTATE_BACKEND_STATE_PROJECT_PATH?: string | undefined;
-    HIGHSTATE_BACKEND_STATE_PROJECT_NAME?: string | undefined;
+    HIGHSTATE_BACKEND_STATE_LOCAL_DIR?: string | undefined;
     HIGHSTATE_BACKEND_STATE_TYPE?: "local" | undefined;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_SOURCE_CHECK?: boolean | undefined;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK?: boolean | undefined;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT?: boolean | undefined;
+    HIGHSTATE_BACKEND_RUNNER_LOCAL_SOURCE_BASE_PATH?: string | undefined;
+    HIGHSTATE_BACKEND_RUNNER_TYPE?: "local" | undefined;
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY?: string | undefined;
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST?: string | undefined;
+    HIGHSTATE_BACKEND_TERMINAL_TYPE?: "docker" | undefined;
+    HIGHSTATE_BACKEND_WORKSPACE_LOCAL_DIR?: string | undefined;
+    HIGHSTATE_BACKEND_WORKSPACE_TYPE?: "local" | undefined;
+    HIGHSTATE_BACKEND_LOGGER_NAME?: string | undefined;
+    HIGHSTATE_BACKEND_LOGGER_LEVEL?: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | undefined;
 }>;
 type Config = z.infer<typeof configSchema>;
 declare function loadConfig(env?: NodeJS.ProcessEnv, useDotenv?: boolean): Promise<Config>;
 
 interface ProjectBackend {
-    getInstances(projectId: string): Promise<Record<string, InstanceModel>>;
-    updateInstance(projectId: string, instance: InstanceModel): Promise<void>;
+    /**
+     * List the names of the available projects.
+     */
+    getProjectNames(): Promise<string[]>;
+    /**
+     * Get the instances of the project.
+     *
+     * @param projectId The ID of the project.
+     */
+    getInstances(projectId: string): Promise<InstanceModel[]>;
+    /**
+     * Create the instance of the project.
+     *
+     * @param projectId The ID of the project.
+     * @param instance The instance to update.
+     */
+    createInstance(projectId: string, instance: InstanceModel): Promise<InstanceModel>;
+    /**
+     * Change the position of the instance in the project.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceId The ID of the instance to move.
+     * @param position The new position of the instance.
+     */
+    moveInstance(projectId: string, instanceId: string, position: Position): Promise<InstanceModel>;
+    /**
+     * Rename the instance of the project.
+     * Changes its id and updates all references to the instance.
+     * Potentially dangerous, but safe when the instance is not yet created.
+     */
+    renameInstance(projectId: string, instanceId: string, newName: string): Promise<InstanceModel>;
+    /**
+     * Update the arguments of the instance.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceId The ID of the instance to update.
+     * @param args The new arguments of the instance.
+     */
+    updateInstanceArgs(projectId: string, instanceId: string, args: Record<string, unknown>): Promise<InstanceModel>;
+    /**
+     * Update the inputs of the instance.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceId The ID of the instance to update.
+     * @param inputs The new inputs of the instance.
+     */
+    updateInstanceInputs(projectId: string, instanceId: string, inputs: InstanceInputMap): Promise<InstanceModel>;
+    /**
+     * Delete the instance of the project.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceId The ID of the instance to delete.
+     */
     deleteInstance(projectId: string, instanceId: string): Promise<void>;
 }
 
-type UnitBaseOptions = {
+declare class ProjectLock {
+    private readonly lock;
+    private readonly projectId;
+    constructor(lock: BetterLock, projectId: string);
+    lockInstance<T>(instanceId: string, fn: () => Promise<T>): Promise<T>;
+    lockInstances<T>(instanceIds: string[], fn: () => Promise<T>): Promise<T>;
+}
+declare class ProjectLockManager {
+    private readonly lock;
+    getLock(projectId: string): ProjectLock;
+}
+
+type LogEntry = [instanceId: string, line: string];
+type EvaluatedCompositeInstance = CompositeInstance & {
+    /**
+     * The hash of the input of the instance at the moment of the evaluation.
+     */
+    inputHash: string;
+};
+interface StateBackend {
     /**
-     * The name of the project to run.
+     * Gets the active operations which are not completed or failed.
      */
-    projectName: string;
+    getActiveOperations(): Promise<ProjectOperation[]>;
     /**
-     * The name of the stack to run.
+     * Gets recent operations of the project.
+     * If `beforeOperationId` is provided, returns the operations before the specified operation ID.
+     * The page size is fixed to 10.
+     *
+     * @param projectId The ID of the project.
+     * @param beforeOperationId The ID of the operation to get the operations before.
+     */
+    getOperations(projectId: string, beforeOperationId?: string): Promise<ProjectOperation[]>;
+    /**
+     * Gets the current (cached) instance states of the project.
+     * Actual states should be retrieved from the runner (and they are still may not be up-to-date).
+     *
+     * @param projectId The ID of the project.
+     */
+    getInstanceStates(projectId: string): Promise<InstanceState[]>;
+    /**
+     * Gets the current (cached) state of the instance.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceId The ID of the instance.
+     */
+    getInstanceState(projectId: string, instanceId: string): Promise<InstanceState | undefined>;
+    /**
+     * Gets the affected instance states at the moment of the operation completion.
+     * The logs are not included.
+     *
+     * @param operationId The ID of the operation.
+     */
+    getAffectedInstanceStates(operationId: string): Promise<InstanceState[]>;
+    /**
+     * Gets the full logs of the instance at the moment of the operation completion.
+     *
+     * @param operationId The ID of the operation.
+     * @param instanceId The ID of the instance.
+     */
+    getInstanceLogs(operationId: string, instanceId: string): Promise<string[]>;
+    /**
+     * Puts the operation to the state.
+     * The operation must have a unique ID sortable chronologically.
+     * Also, the operation must have the project ID.
+     *
+     * @param operation The operation to put.
+     */
+    putOperation(operation: ProjectOperation): Promise<void>;
+    /**
+     * Puts the instance states affected by the operation to the state.
+     *
+     * @param projectId The ID of the project.
+     * @param operationId The ID of the operation.
+     * @param states The instance states to put.
+     */
+    putAffectedInstanceStates(projectId: string, operationId: string, states: InstanceState[]): Promise<void>;
+    /**
+     * Puts the instance states of the project to the state.
+     *
+     * @param projectId The ID of the project.
+     * @param states The instance states to put.
+     */
+    putInstanceStates(projectId: string, states: InstanceState[]): Promise<void>;
+    /**
+     * Appends the log lines to the instance logs.
+     *
+     * @param operationId The ID of the operation.
+     * @param logs The logs to append. Each log is a tuple of the instance ID and the log line.
+     */
+    appendInstanceLogs(operationId: string, logs: LogEntry[]): Promise<void>;
+    /**
+     * Gets the evaluated composite instance.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceId The ID of the instance.
      */
-    stackName: string;
+    getCompositeInstance(projectId: string, instanceId: string): Promise<EvaluatedCompositeInstance | null>;
+    /**
+     * Gets the input hash of the evaluated composite instance.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceId The ID of the instance.
+     */
+    getCompositeInstanceInputHash(projectId: string, instanceId: string): Promise<string | null>;
+    /**
+     * Puts the evaluated composite instances of the project to the state.
+     *
+     * @param projectId The ID of the project.
+     * @param instances The instances to put.
+     */
+    putCompositeInstances(projectId: string, instances: EvaluatedCompositeInstance[]): Promise<void>;
+    /**
+     * Clears the evaluation state of the instance.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceIds The IDs of the instances to clear.
+     */
+    clearCompositeInstances(projectId: string, instanceIds: string[]): Promise<void>;
+}
+
+declare class ProjectManager {
+    private readonly projectBackend;
+    private readonly stateBackend;
+    private readonly operationManager;
+    private readonly library;
+    private readonly logger;
+    private constructor();
+    getCompositeInstance(projectId: string, instanceId: string): Promise<CompositeInstance>;
+    createInstance(projectId: string, instance: InstanceModel): Promise<InstanceModel>;
+    updateInstanceArgs(projectId: string, instanceId: string, args: Record<string, unknown>): Promise<InstanceModel>;
+    updateInstanceInputs(projectId: string, instanceId: string, inputs: InstanceInputMap): Promise<InstanceModel>;
+    moveInstance(projectId: string, instanceId: string, position: Position): Promise<InstanceModel>;
+    renameInstance(projectId: string, instanceId: string, newName: string): Promise<InstanceModel>;
+    deleteInstance(projectId: string, instanceId: string): Promise<void>;
+    private updateInstanceChildren;
+    private waitForCompositeInstance;
+    static create(projectBackend: ProjectBackend, stateBackend: StateBackend, operationManager: OperationManager, library: LibraryBackend, logger: Logger): ProjectManager;
+}
+
+type RunnerBaseOptions = {
+    /**
+     * The HighState project ID.
+     */
+    projectId: string;
+    /**
+     * The type of the instance to run.
+     */
+    instanceType: string;
+    /**
+     * The name of the instance to run.
+     */
+    instanceName: string;
     /**
      * The signal to abort the operation.
      */
     signal?: AbortSignal;
 };
-type UnitRunOptions = UnitBaseOptions & {
+type InstanceUpdateOptions = RunnerBaseOptions & {
     /**
      * The source of the unit.
      */
     source: UnitSource;
-};
-type UnitUpdateOptions = UnitRunOptions & {
     /**
      * The configuration of the stack.
      */
     config: Record<string, string>;
+    /**
+     * The values of the secrets.
+     */
+    secrets: Record<string, string>;
 };
-type UnitWatchOptions = UnitBaseOptions & {
+type InstanceWatchOptions = RunnerBaseOptions & {
     /**
      * The final statuses to watch.
-     * If the unit reaches one of these statuses, it should return the current state and exit.
+     * If the instance reaches one of these statuses, it should return the current state and exit.
      */
-    finalStatuses: InstanceStatus[];
+    finalStatuses?: InstanceStatus[];
 };
 interface RunnerBackend {
     /**
-     * Watches the unit state.
+     * Watches the instance state.
+     *
+     * Returns the async iterable of the instance state patches.
+     * The fields with `undefined` values should be ignored, and the fields with `null` values should be removed.
      */
-    watch(options: UnitWatchOptions): AsyncIterable<InstanceState>;
+    watch(options: InstanceWatchOptions): AsyncIterable<InstanceStatePatch>;
     /**
-     * Updates the unit.
+     * Gets the actual state of the instance.
+     */
+    getState(options: RunnerBaseOptions): Promise<InstanceState>;
+    /**
+     * Gets the content of the representation.
+     */
+    getRepresentationContent(options: RunnerBaseOptions): Promise<string | null>;
+    /**
+     * Gets the terminal factory.
+     */
+    getTerminalFactory(options: RunnerBaseOptions): Promise<TerminalFactory | null>;
+    /**
+     * Updates the instance.
      *
      * The operation must only be aborted by the signal, not even when the connection is closed.
-     * If the unit is already updating, it should exit immediately.
-     * If the unit is running another operation, it should throw an error.
+     * If the instance is already updating, it should exit immediately.
+     * If the instance is running another operation, it should throw an error.
      */
-    update(options: UnitUpdateOptions): Promise<void>;
+    update(options: InstanceUpdateOptions): Promise<void>;
     /**
-     * Destroys the unit.
+     * Destroys the instance.
      *
      * The operation must only be aborted by the signal, not even when the connection is closed.
-     * If the unit is not created, it should exit immediately.
-     * If the unit is running another operation, it should throw an error.
+     * If the instance is not created, it should exit immediately.
+     * If the instance is running another operation, it should throw an error.
      */
-    destroy(options: UnitRunOptions): Promise<void>;
+    destroy(options: RunnerBaseOptions): Promise<void>;
     /**
-     * Refreshes the unit.
+     * Refreshes the instance.
      *
      * The operation must only be aborted by the signal, not even when the connection is closed.
-     * If the unit is not created, it should exit immediately.
-     * If the unit is running another operation, it should throw an error.
-     * If the unit is not running, it should exit immediately.
+     * If the instance is not created, it should exit immediately.
+     * If the instance is running another operation, it should throw an error.
+     * If the instance is not running, it should exit immediately.
      */
-    refresh(options: UnitRunOptions): Promise<void>;
+    refresh(options: RunnerBaseOptions): Promise<void>;
 }
 
-interface StateBackend {
+type OperationEvents = Record<string, [ProjectOperation]>;
+type StateEvents = Record<string, [Partial<InstanceState>]>;
+type CompositeInstanceEvents = Record<string, [CompositeInstance]>;
+type InstanceLogsEvents = Record<string, [string]>;
+declare class OperationManager {
+    private readonly runnerBackend;
+    private readonly stateBackend;
+    private readonly libraryBackend;
+    private readonly projectBackend;
+    private readonly secretBackend;
+    private readonly projectLockManager;
+    private readonly logger;
+    constructor(runnerBackend: RunnerBackend, stateBackend: StateBackend, libraryBackend: LibraryBackend, projectBackend: ProjectBackend, secretBackend: SecretBackend, projectLockManager: ProjectLockManager, logger: Logger);
+    private readonly operationEE;
+    private readonly stateEE;
+    private readonly compositeInstanceEE;
+    private readonly instanceLogsEE;
+    private readonly runtimeOperations;
     /**
-     * Gets all the component states for a project.
+     * Watches for all instance state changes in the project.
      *
-     * @param projectId The ID of the project.
+     * @param projectId The project ID to watch.
+     * @param signal The signal to abort the operation.
      */
-    get(projectId: string): Promise<ProjectState>;
+    watchInstanceStates(projectId: string, signal?: AbortSignal): AsyncIterable<Partial<InstanceState>>;
     /**
-     * Watch the component states for a project.
-     * Returns an async iterable that emits the component states.
+     * Watches for all project operations in the project.
      *
-     * @param projectId The ID of the project.
+     * @param projectId The project ID to watch.
+     * @param signal The signal to abort the operation.
      */
-    watch?(projectId: string): AsyncIterable<InstanceState>;
+    watchOperations(projectId: string, signal?: AbortSignal): AsyncIterable<ProjectOperation>;
     /**
-     * Updates the component states for a project.
-     * Use `null` to delete a component state.
+     * Watches for changes in the composite instance.
      *
-     * @param projectId The ID of the project.
-     * @param state The new project state.
+     * @param projectId The project ID to watch.
+     * @param instanceId The instance ID to watch.
+     * @param signal The signal to abort the operation.
+     */
+    watchCompositeInstance(projectId: string, instanceId: string, signal?: AbortSignal): AsyncIterable<CompositeInstance>;
+    /**
+     * Watches for logs of the instance in the operation.
+     *
+     * @param operationId The operation ID to watch.
+     * @param instanceId The instance ID to watch.
+     * @param signal The signal to abort the operation.
+     */
+    watchInstanceLogs(operationId: string, instanceId: string, signal?: AbortSignal): AsyncIterable<string>;
+    /**
+     * Launches the project operation.
+     *
+     * @param request The operation request to launch.
      */
-    set(projectId: string, state: ProjectState): Promise<void>;
+    launch(request: ProjectOperationRequest): Promise<void>;
+    /**
+     * Cancels the current operation.
+     * Does nothing if no operation is running.
+     */
+    cancel(operationId: string): void;
+    private startOperation;
+    static create(runnerBackend: RunnerBackend, stateBackend: StateBackend, libraryBackend: LibraryBackend, projectBackend: ProjectBackend, secretBackend: SecretBackend, projectLockManager: ProjectLockManager, logger: Logger): Promise<OperationManager>;
 }
 
-declare const stateBackendConfig: z.ZodObject<{
-    HIGHSTATE_BACKEND_STATE_PROJECT_PATH: z.ZodOptional<z.ZodString>;
-    HIGHSTATE_BACKEND_STATE_PROJECT_NAME: z.ZodOptional<z.ZodString>;
-    HIGHSTATE_BACKEND_STATE_TYPE: z.ZodDefault<z.ZodEnum<["local"]>>;
+type TerminalRunOptions = {
+    /**
+     * The factory to use.
+     */
+    factory: TerminalFactory;
+    /**
+     * The input stream.
+     */
+    stdin: Stream;
+    /**
+     * The output stream.
+     */
+    stdout: NodeJS.WritableStream;
+    /**
+     * The signal to abort the terminal.
+     */
+    signal?: AbortSignal;
+};
+interface TerminalBackend {
+    /**
+     * Creates a new terminal and runs it.
+     *
+     * @param options The options.
+     */
+    run(options: TerminalRunOptions): Promise<void>;
+}
+
+declare const terminalBackendConfig: z.ZodObject<{
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY: z.ZodDefault<z.ZodString>;
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST: z.ZodOptional<z.ZodString>;
+    HIGHSTATE_BACKEND_TERMINAL_TYPE: z.ZodDefault<z.ZodEnum<["docker"]>>;
 }, "strip", z.ZodTypeAny, {
-    HIGHSTATE_BACKEND_STATE_TYPE: "local";
-    HIGHSTATE_BACKEND_STATE_PROJECT_PATH?: string | undefined;
-    HIGHSTATE_BACKEND_STATE_PROJECT_NAME?: string | undefined;
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY: string;
+    HIGHSTATE_BACKEND_TERMINAL_TYPE: "docker";
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST?: string | undefined;
 }, {
-    HIGHSTATE_BACKEND_STATE_PROJECT_PATH?: string | undefined;
-    HIGHSTATE_BACKEND_STATE_PROJECT_NAME?: string | undefined;
-    HIGHSTATE_BACKEND_STATE_TYPE?: "local" | undefined;
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_BINARY?: string | undefined;
+    HIGHSTATE_BACKEND_TERMINAL_DOCKER_HOST?: string | undefined;
+    HIGHSTATE_BACKEND_TERMINAL_TYPE?: "docker" | undefined;
 }>;
-declare function createStateBackend(config: z.infer<typeof stateBackendConfig>, pulumiProjectHost: LocalPulumiProjectHost): Promise<StateBackend>;
+declare function createTerminalBackend(config: z.infer<typeof terminalBackendConfig>, logger: Logger): TerminalBackend;
 
-declare class ProjectOperator {
-    private readonly projectId;
-    readonly state: ProjectState;
-    private readonly runnerBackend;
-    private readonly stateBackend;
-    private readonly libraryBackend;
-    private readonly projectBackend;
-    private readonly secretBackend;
-    constructor(projectId: string, state: ProjectState, runnerBackend: RunnerBackend, stateBackend: StateBackend, libraryBackend: LibraryBackend, projectBackend: ProjectBackend, secretBackend: SecretBackend);
-    private readonly unitPromises;
-    private readonly eventEmitter;
-    private debouncedUpdateState;
-    private abortController;
-    watchInstanceStates(signal?: AbortSignal): AsyncIterable<InstanceState>;
-    watchCurrentOperation(signal?: AbortSignal): AsyncIterable<ProjectOperation | undefined>;
+type Terminal = {
+    readonly id: string;
+    readonly abortController: AbortController;
+    readonly stdin: PassThrough;
+    readonly stdout: PassThrough;
+    readonly history: string[];
+    attached: boolean;
+};
+declare class TerminalManager {
+    private readonly terminalBackend;
+    private readonly logger;
+    private readonly terminals;
+    private constructor();
+    create(factory: TerminalFactory): Terminal;
+    close(id: string): void;
+    attach(id: string, stdin: Stream, stdout: Writable, signal: AbortSignal): void;
+    private closeTerminalIfNotAttached;
+    static create(terminalBackend: TerminalBackend, logger: Logger): TerminalManager;
+}
+
+interface WorkspaceBackend {
     /**
-     * Launches the project operation.
-     * Throws an error if the operation is already running.
+     * Gets the layout of the workspace.
+     */
+    getWorkspaceLayout(): Promise<unknown>;
+    /**
+     * Sets the layout of the workspace.
+     */
+    setWorkspaceLayout(layout: unknown): Promise<void>;
+    /**
+     * Gets the viewport of the project.
      *
-     * @param operation The operation to launch.
+     * @param projectId The ID of the project.
      */
-    launch(operation: ProjectOperation): void;
+    getProjectViewport(projectId: string): Promise<unknown>;
     /**
-     * Cancels the current operation.
-     * Does nothing if no operation is running.
+     * Sets the viewport of the project.
+     *
+     * @param projectId The ID of the project.
      */
-    cancel(): void;
-    private operate;
-    private upUnit;
-    private getUnitConfig;
-    private watchStateStream;
-    private updateCurrentOperation;
-    private updateInstanceState;
-    private getOrCreateUnitPromise;
-    static create(projectId: string, runnerBackend: RunnerBackend, stateBackend: StateBackend, libraryBackend: LibraryBackend, projectBackend: ProjectBackend, secretBackend: SecretBackend): Promise<ProjectOperator>;
-}
-
-declare class OperatorManager {
-    private readonly runnerBackend;
-    private readonly stateBackend;
-    private readonly libraryBackend;
-    private readonly projectBackend;
-    private readonly secretBackend;
-    private readonly operators;
-    private readonly lock;
-    constructor(runnerBackend: RunnerBackend, stateBackend: StateBackend, libraryBackend: LibraryBackend, projectBackend: ProjectBackend, secretBackend: SecretBackend);
-    get(projectId: string): Promise<ProjectOperator>;
+    setProjectViewport(projectId: string, viewport: unknown): Promise<void>;
+    /**
+     * Gets the viewport of the composite instance.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceId The ID of the instance.
+     */
+    getInstanceViewport(projectId: string, instanceId: string): Promise<unknown>;
+    /**
+     * Sets the viewport of the composite instance.
+     *
+     * @param projectId The ID of the project.
+     * @param instanceId The ID of the instance.
+     */
+    setInstanceViewport(projectId: string, instanceId: string, viewport: unknown): Promise<void>;
 }
 
 type Services = {
+    readonly logger: Logger;
     readonly libraryBackend: LibraryBackend;
     readonly secretBackend: SecretBackend;
     readonly runnerBackend: RunnerBackend;
     readonly projectBackend: ProjectBackend;
+    readonly projectManager: ProjectManager;
     readonly stateBackend: StateBackend;
-    readonly operatorManager: OperatorManager;
+    readonly operationManager: OperationManager;
+    readonly terminalBackend: TerminalBackend;
+    readonly terminalManager: TerminalManager;
+    readonly workspaceBackend: WorkspaceBackend;
 };
-declare function createServices(config?: Config): Promise<Services>;
+interface CreateServicesOptions {
+    /**
+     * The config to use. If not provided, it will be loaded from the environment.
+     */
+    readonly config?: Config;
+    /**
+     * The already created services to use. If the particular service is not provided, it will be created.
+     */
+    readonly services?: Partial<Services>;
+}
+declare function createServices({ config, services: { logger, libraryBackend, secretBackend, runnerBackend, projectBackend, projectManager, stateBackend, operationManager, terminalBackend, terminalManager, workspaceBackend, }, }?: CreateServicesOptions): Promise<Services>;
+declare function getSharedServices(options?: CreateServicesOptions): Promise<Services>;
 
-export { type Config, type EvaluationInput, type EvaluationInstance, type InstanceModel, type InstanceState, type InstanceStatus, type LibraryBackend, type LibraryModel, LocalPulumiProjectHost, type OperationType, OperatorManager, type OutputRef, type Position, type ProjectOperation, ProjectOperator, type ProjectState, SecretAccessDeniedError, type SecretBackend, type Services, type StateBackend, createLibraryBackend, createSecretBackend, createServices, createStateBackend, instanceModelSchema, instanceStateSchema, instanceStatusSchema, libraryBackendConfig, loadConfig, operationType, outputRefSchema, positionSchema, projectOperation, projectStateSchema, resolveMainLocalProject, secretBackendConfig, stateBackendConfig, stringArrayType };
+export { type CompositeInstanceEvents, type Config, type CreateServicesOptions, type InstanceLogsEvents, type LibraryBackend, type LibraryModel, type OperationEvents, OperationManager, SecretAccessDeniedError, type SecretBackend, type Services, type StateEvents, type TerminalBackend, TerminalManager, type TerminalRunOptions, createLibraryBackend, createSecretBackend, createServices, createTerminalBackend, getSharedServices, libraryBackendConfig, loadConfig, secretBackendConfig, terminalBackendConfig };