@highstate/backend 0.19.1 → 0.21.1

package/dist/{chunk-V2NILDHS.js → chunk-gxjwa93h.js}

@@ -1,13 +1,6 @@
-import { z, commonObjectMetaSchema, genericNameSchema, timestampsSchema, objectMetaSchema, serviceAccountMetaSchema, instanceIdSchema, instanceModelSchema, hubModelSchema, pageBlockSchema, globalCommonObjectMetaSchema, terminalSpecSchema, isUnitModel, parseArgumentValue } from '@highstate/contract';
-import { z as z$1 } from 'zod';
-import { mapValues, constant, unique, fromEntries } from 'remeda';
-import { crc32 } from '@aws-crypto/crc32';
-import { encode } from '@msgpack/msgpack';
-import { Buffer } from 'buffer-polyfill';
-import { Ajv } from 'ajv';
-import styles from 'ansi-styles';
-
+// @bun
 // src/shared/models/backend/library.ts
+import { z } from "@highstate/contract";
 var librarySpecSchema = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("host")
@@ -55,6 +48,8 @@ function applyLibraryUpdate(components, entities, update) {
       break;
   }
 }
+// src/shared/models/backend/project.ts
+import { commonObjectMetaSchema, genericNameSchema, timestampsSchema, z as z2 } from "@highstate/contract";
 
 // src/shared/models/backend/well-known.ts
 var globalProjectSpace = {
@@ -104,219 +99,202 @@ var databaseProjectModelStorage = {
 };
 
 // src/shared/models/backend/project.ts
-var projectModelStorageSpecSchema = z.discriminatedUnion("type", [
-  z.object({
-    /**
-     * The project model is stored in the codebase where Highstate is running.
-     */
-    type: z.literal("codebase")
+var projectModelStorageSpecSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("codebase")
   }),
-  z.object({
-    /**
-     * The project model is stored in the project database alongside the project data.
-     */
-    type: z.literal("database")
+  z2.object({
+    type: z2.literal("database")
   })
 ]);
-var projectInputSchema = z.object({
+var projectInputSchema = z2.object({
   name: genericNameSchema,
-  spaceId: z.cuid2().default(globalProjectSpace.id),
-  modelStorageId: z.cuid2().default(codebaseProjectModelStorage.id),
-  libraryId: z.cuid2().default(codebaseLibrary.id),
-  pulumiBackendId: z.cuid2().default(hostPulumiBackend.id),
+  spaceId: z2.cuid2().default(globalProjectSpace.id),
+  modelStorageId: z2.cuid2().default(codebaseProjectModelStorage.id),
+  libraryId: z2.cuid2().default(codebaseLibrary.id),
+  pulumiBackendId: z2.cuid2().default(hostPulumiBackend.id),
   meta: commonObjectMetaSchema
 });
-var projectOutputSchema = z.object({
-  id: z.string(),
+var projectOutputSchema = z2.object({
+  id: z2.string(),
   name: genericNameSchema,
   meta: commonObjectMetaSchema,
-  spaceId: z.cuid2(),
-  modelStorageId: z.cuid2(),
-  libraryId: z.cuid2(),
-  pulumiBackendId: z.cuid2(),
+  spaceId: z2.cuid2(),
+  modelStorageId: z2.cuid2(),
+  libraryId: z2.cuid2(),
+  pulumiBackendId: z2.cuid2(),
   ...timestampsSchema.shape
 });
-var projectUnlockSuiteSchema = z.object({
-  /**
-   * The list of encrypted AGE identities that can be used to decrypt the master key of the project.
-   *
-   * The frontend should try to decrypt at least one of these identities
-   * using the password or passkey.
-   */
-  encryptedIdentities: z.array(z.string()),
-  /**
-   * Whether one of the identities is a passkey and user should be asked to use it.
-   */
-  hasPasskey: z.boolean()
+var projectUnlockSuiteSchema = z2.object({
+  encryptedIdentities: z2.array(z2.string()),
+  hasPasskey: z2.boolean()
 });
-var projectUnlockStateSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("locked"),
+var projectUnlockStateSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("locked"),
     unlockSuite: projectUnlockSuiteSchema.optional()
   }),
-  z.object({
-    type: z.literal("unlocked")
+  z2.object({
+    type: z2.literal("unlocked")
   })
 ]);
-var pulumiBackendSpecSchema = z.discriminatedUnion("type", [
-  z.object({
-    /**
-     * Use the Pulumi backend configured on the host where Highstate backend is running.
-     *
-     * The backend is expected to be configured with the `pulumi login` command by the user.
-     */
-    type: z.literal("host")
+// src/shared/models/backend/pulumi.ts
+import { z as z3 } from "@highstate/contract";
+var pulumiBackendSpecSchema = z3.discriminatedUnion("type", [
+  z3.object({
+    type: z3.literal("host")
   })
 ]);
+// src/shared/models/backend/unlock-method.ts
+import { objectMetaSchema } from "@highstate/contract";
+import { z as z4 } from "zod";
 var backendUnlockMethodMetaSchema = objectMetaSchema.pick({ title: true, description: true }).required({ title: true });
-var backendUnlockMethodInputSchema = z$1.object({
+var backendUnlockMethodInputSchema = z4.object({
   meta: backendUnlockMethodMetaSchema,
-  recipient: z$1.string()
+  recipient: z4.string()
 });
+// src/shared/models/base.ts
+import { constant, mapValues } from "remeda";
+import { z as z5 } from "zod";
 function hasObjectMeta(value) {
   return typeof value === "object" && value !== null && "meta" in value;
 }
-var sortBySchema = z$1.object({
-  key: z$1.string(),
-  order: z$1.enum(["asc", "desc"])
+var sortBySchema = z5.object({
+  key: z5.string(),
+  order: z5.enum(["asc", "desc"])
 });
-var collectionQuerySchema = z$1.object({
-  /**
-   * The search string to filter documents by display name, description, or other text fields.
-   */
-  search: z$1.string().optional(),
-  /**
-   * The sorting configuration for the results.
-   *
-   * Can be a single sort field or an array of sort fields.
-   * Each sort field contains the key and order.
-   */
-  sortBy: z$1.array(sortBySchema).optional(),
-  /**
-   * The number of items to skip.
-   *
-   * Defaults to 0 if not specified.
-   */
-  skip: z$1.number().int().nonnegative().default(0).optional(),
-  /**
-   * The count of documents to return.
-   *
-   * Defaults to 20 if not specified.
-   * Maximum value is 100.
-   */
-  count: z$1.number().int().positive().max(100).default(20).optional()
+var collectionQuerySchema = z5.object({
+  search: z5.string().optional(),
+  sortBy: z5.array(sortBySchema).optional(),
+  skip: z5.number().int().nonnegative().default(0).optional(),
+  count: z5.number().int().positive().max(100).default(20).optional()
 });
 function collectionQueryResult(schema) {
-  return z$1.object({
-    items: z$1.array(schema),
-    total: z$1.number().int().nonnegative()
+  return z5.object({
+    items: z5.array(schema),
+    total: z5.number().int().nonnegative()
   });
 }
 function forSchema(schema) {
   return mapValues(schema.shape, constant(true));
 }
-
 // src/shared/models/errors.ts
-var BackendError = class extends Error {
+class BackendError extends Error {
   constructor(message, cause) {
     super(message, { cause });
     this.name = "BackendError";
   }
-};
-var AccessError = class extends BackendError {
+}
+
+class AccessError extends BackendError {
   constructor(message) {
     super(message);
     this.name = "AccessError";
   }
-};
-var ProjectLockedError = class extends AccessError {
+}
+
+class ProjectLockedError extends AccessError {
   constructor(projectId) {
     super(`The project with ID "${projectId}" is locked, decryption is not possible.`);
   }
-};
-var ProjectNotFoundError = class extends BackendError {
+}
+
+class ProjectNotFoundError extends BackendError {
   constructor(projectId) {
     super(`Project with ID "${projectId}" not found.`);
     this.name = "ProjectNotFoundError";
   }
-};
-var CannotDeleteLastUnlockMethodError = class extends BackendError {
+}
+
+class CannotDeleteLastUnlockMethodError extends BackendError {
   constructor(projectId) {
     super(`Refused to delete the last unlock method for project "${projectId}".`);
     this.name = "CannotDeleteLastUnlockMethodError";
   }
-};
-var InstanceNotFoundError = class extends BackendError {
+}
+
+class InstanceNotFoundError extends BackendError {
   constructor(projectId, instanceId) {
     super(`Instance with ID "${instanceId}" not found in project "${projectId}".`);
     this.name = "InstanceNotFoundError";
   }
-};
-var InvalidInstanceKindError = class extends BackendError {
+}
+
+class InvalidInstanceKindError extends BackendError {
   constructor(projectId, instanceId, expectedKind, actualKind) {
-    super(
-      `Instance "${instanceId}" in project "${projectId}" has kind "${actualKind}", but expected "${expectedKind}".`
-    );
+    super(`Instance "${instanceId}" in project "${projectId}" has kind "${actualKind}", but expected "${expectedKind}".`);
     this.name = "InvalidInstanceKindError";
   }
-};
-var OperationNotFoundError = class extends BackendError {
+}
+
+class OperationNotFoundError extends BackendError {
   constructor(projectId, operationId) {
     super(`Operation with ID "${operationId}" not found in project "${projectId}".`);
     this.name = "OperationNotFoundError";
   }
-};
-var InstanceLockLostError = class extends BackendError {
+}
+
+class InstanceLockLostError extends BackendError {
   constructor(projectId, instanceIds, token) {
-    super(
-      `Instance lock lost for instances [${instanceIds.join(", ")}] in project "${projectId}" with token "${token}".`
-    );
+    super(`Instance lock lost for instances [${instanceIds.join(", ")}] in project "${projectId}" with token "${token}".`);
     this.name = "InstanceLockLostError";
   }
-};
-var InstanceStateNotFoundError = class extends BackendError {
+}
+
+class InstanceStateNotFoundError extends BackendError {
   constructor(projectId, instanceId) {
     super(`State for instance with ID "${instanceId}" not found in project "${projectId}".`);
     this.name = "InstanceStateNotFoundError";
   }
-};
-var InstanceLockedError = class extends BackendError {
+}
+
+class InstanceLockedError extends BackendError {
   constructor(projectId, instanceId) {
     super(`Instance with ID "${instanceId}" in project "${projectId}" is locked.`);
     this.name = "InstanceLockedError";
   }
-};
-var WorkerVersionNotFoundError = class extends BackendError {
+}
+
+class WorkerVersionNotFoundError extends BackendError {
   constructor(projectId, workerVersionId) {
     super(`Worker version with ID "${workerVersionId}" not found in project "${projectId}".`);
     this.name = "WorkerVersionNotFoundError";
   }
-};
-var BackendUnlockMethodNotFoundError = class extends BackendError {
+}
+
+class BackendUnlockMethodNotFoundError extends BackendError {
   constructor(id) {
     super(`Backend unlock method with ID "${id}" not found.`);
     this.name = "BackendUnlockMethodNotFoundError";
   }
-};
-var CannotDeleteLastBackendUnlockMethodError = class extends BackendError {
+}
+
+class CannotDeleteLastBackendUnlockMethodError extends BackendError {
   constructor() {
     super(`Refused to delete the last backend unlock method.`);
     this.name = "CannotDeleteLastBackendUnlockMethodError";
   }
-};
-var apiKeyMetaSchema = objectMetaSchema.pick({
+}
+// src/shared/models/project/api-key.ts
+import {
+  commonObjectMetaSchema as commonObjectMetaSchema2,
+  objectMetaSchema as objectMetaSchema2,
+  serviceAccountMetaSchema,
+  z as z6
+} from "@highstate/contract";
+var apiKeyMetaSchema = objectMetaSchema2.pick({
   title: true,
   description: true
 }).required({ title: true });
-var apiKeyOutputSchema = z.object({
-  id: z.cuid2(),
-  meta: commonObjectMetaSchema,
-  serviceAccountId: z.cuid2(),
+var apiKeyOutputSchema = z6.object({
+  id: z6.cuid2(),
+  meta: commonObjectMetaSchema2,
+  serviceAccountId: z6.cuid2(),
   serviceAccountMeta: serviceAccountMetaSchema.nullable(),
-  createdAt: z.date()
+  createdAt: z6.date()
 });
 var apiKeyQuerySchema = collectionQuerySchema.extend({
-  serviceAccountId: z.string().optional()
+  serviceAccountId: z6.string().optional()
 });
 function toApiKeyOutput(apiKey, serviceAccount) {
   return {
@@ -324,230 +302,184 @@ function toApiKeyOutput(apiKey, serviceAccount) {
     serviceAccountMeta: serviceAccount?.meta ?? null
   };
 }
-var artifactOutputSchema = z$1.object({
-  id: z$1.cuid2(),
-  hash: z$1.string(),
-  size: z$1.number(),
-  meta: commonObjectMetaSchema,
-  createdAt: z$1.date(),
-  updatedAt: z$1.date()
+// src/shared/models/project/artifact.ts
+import { commonObjectMetaSchema as commonObjectMetaSchema3 } from "@highstate/contract";
+import { z as z7 } from "zod";
+var artifactOutputSchema = z7.object({
+  id: z7.cuid2(),
+  hash: z7.string(),
+  size: z7.number(),
+  meta: commonObjectMetaSchema3,
+  createdAt: z7.date(),
+  updatedAt: z7.date()
 });
 var artifactQuerySchema = collectionQuerySchema.extend({
-  stateId: z$1.string().optional(),
-  serviceAccountId: z$1.string().optional(),
-  terminalId: z$1.string().optional(),
-  pageId: z$1.string().optional()
+  stateId: z7.string().optional(),
+  serviceAccountId: z7.string().optional(),
+  terminalId: z7.string().optional(),
+  pageId: z7.string().optional()
 });
-var instanceCustomStatusInputSchema = z$1.object({
-  name: z$1.string(),
-  meta: commonObjectMetaSchema,
-  value: z$1.string(),
-  message: z$1.string().optional(),
-  order: z$1.number().min(0).max(100).optional()
+// src/shared/models/project/custom-status.ts
+import { commonObjectMetaSchema as commonObjectMetaSchema4 } from "@highstate/contract";
+import { z as z8 } from "zod";
+var instanceCustomStatusInputSchema = z8.object({
+  name: z8.string(),
+  meta: commonObjectMetaSchema4,
+  value: z8.string(),
+  message: z8.string().optional(),
+  order: z8.number().min(0).max(100).optional()
 });
-var instanceLockOutputSchema = z$1.object({
-  stateId: z$1.cuid2(),
-  meta: commonObjectMetaSchema,
-  acquiredAt: z$1.date()
+// src/shared/models/project/entity.ts
+import { commonObjectMetaSchema as commonObjectMetaSchema5 } from "@highstate/contract";
+import { z as z9 } from "zod";
+var rawEntityMetaSchema = z9.object({
+  identity: z9.string().optional(),
+  title: z9.string().optional(),
+  description: z9.string().optional(),
+  icon: z9.string().optional(),
+  iconColor: z9.string().optional()
+}).passthrough();
+var entityOutputSchema = z9.object({
+  id: z9.string(),
+  type: z9.string(),
+  identity: z9.string(),
+  meta: commonObjectMetaSchema5,
+  snapshotId: z9.string().optional(),
+  createdAt: z9.date().optional()
+});
+var entityQuerySchema = collectionQuerySchema.extend({
+  type: z9.string().optional()
+});
+var entitySnapshotOutputSchema = z9.object({
+  id: z9.string(),
+  meta: commonObjectMetaSchema5,
+  content: z9.unknown(),
+  operationId: z9.string(),
+  stateId: z9.string(),
+  referencedInOutputs: z9.string().array(),
+  exportedInOutputs: z9.string().array(),
+  createdAt: z9.date()
 });
-var instanceLockEventSchema = z$1.discriminatedUnion("type", [
-  z$1.object({
-    type: z$1.literal("locked"),
+var entitySnapshotListItemOutputSchema = z9.object({
+  id: z9.string(),
+  meta: commonObjectMetaSchema5,
+  operationId: z9.string(),
+  stateId: z9.string(),
+  createdAt: z9.date()
+});
+var entitySnapshotDetailsOutputSchema = z9.object({
+  entity: z9.object({
+    id: z9.string(),
+    type: z9.string(),
+    identity: z9.string()
+  }),
+  snapshot: entitySnapshotOutputSchema
+});
+var entityDetailsOutputSchema = z9.object({
+  ...entityOutputSchema.shape,
+  lastSnapshot: entitySnapshotOutputSchema.nullable()
+});
+var entityReferenceOutputSchema = z9.object({
+  id: z9.string(),
+  meta: commonObjectMetaSchema5,
+  group: z9.string(),
+  fromSnapshotId: z9.string(),
+  fromEntityId: z9.string(),
+  fromEntityType: z9.string(),
+  fromEntityIdentity: z9.string(),
+  fromEntityMeta: commonObjectMetaSchema5,
+  toSnapshotId: z9.string(),
+  toEntityId: z9.string(),
+  toEntityType: z9.string(),
+  toEntityIdentity: z9.string(),
+  toEntityMeta: commonObjectMetaSchema5
+});
+function toCommonEntityMeta(meta) {
+  const parsedRawMeta = rawEntityMetaSchema.safeParse(meta);
+  if (parsedRawMeta.success) {
+    return {
+      title: parsedRawMeta.data.title ?? parsedRawMeta.data.identity ?? "Unknown",
+      description: parsedRawMeta.data.description,
+      icon: parsedRawMeta.data.icon,
+      iconColor: parsedRawMeta.data.iconColor
+    };
+  }
+  return {
+    title: "Unknown"
+  };
+}
+// src/shared/models/project/lock.ts
+import { commonObjectMetaSchema as commonObjectMetaSchema6 } from "@highstate/contract";
+import { z as z10 } from "zod";
+var instanceLockOutputSchema = z10.object({
+  stateId: z10.cuid2(),
+  meta: commonObjectMetaSchema6,
+  acquiredAt: z10.date()
+});
+var instanceLockEventSchema = z10.discriminatedUnion("type", [
+  z10.object({
+    type: z10.literal("locked"),
     locks: instanceLockOutputSchema.array()
   }),
-  z$1.object({
-    type: z$1.literal("unlocked"),
-    stateIds: z$1.array(z$1.string())
+  z10.object({
+    type: z10.literal("unlocked"),
+    stateIds: z10.array(z10.string())
   })
 ]);
-var projectModelEventSchema = z$1.object({
+// src/shared/models/project/model.ts
+import {
+  hubModelSchema,
+  instanceIdSchema,
+  instanceModelSchema
+} from "@highstate/contract";
+import { z as z11 } from "zod";
+var projectModelEventSchema = z11.object({
   updatedInstances: instanceModelSchema.array().optional(),
   updatedHubs: hubModelSchema.array().optional(),
   updatedVirtualInstances: instanceModelSchema.array().optional(),
   updatedGhostInstances: instanceModelSchema.array().optional(),
   deletedInstanceIds: instanceIdSchema.array().optional(),
-  deletedHubIds: z$1.string().array().optional(),
+  deletedHubIds: z11.string().array().optional(),
   deletedVirtualInstanceIds: instanceIdSchema.array().optional(),
   deletedGhostInstanceIds: instanceIdSchema.array().optional()
 });
-var operationPhaseTypeSchema = z.enum(["destroy", "preview", "update", "refresh"]);
-var operationPhaseInstanceSchema = z.object({
-  /**
-   * The ID of the instance.
-   */
-  id: instanceIdSchema,
-  /**
-   * The parent ID of the instance, either from the model or the state.
-   */
-  parentId: z.string().optional(),
-  /**
-   * Human-readable explanation of the decision.
-   * */
-  message: z.string()
+// src/shared/models/project/operation.ts
+import { instanceIdSchema as instanceIdSchema2, objectMetaSchema as objectMetaSchema3, z as z12 } from "@highstate/contract";
+var operationPhaseTypeSchema = z12.enum(["destroy", "preview", "update", "refresh"]);
+var operationPhaseInstanceSchema = z12.object({
+  id: instanceIdSchema2,
+  parentId: z12.string().optional(),
+  message: z12.string()
 });
-var operationPhaseSchema = z.object({
-  /**
-   * Type of phase being executed.
-   */
+var operationPhaseSchema = z12.object({
   type: operationPhaseTypeSchema,
-  /**
-   * List of instances to be processed in this phase.
-   */
-  instances: z.array(operationPhaseInstanceSchema)
+  instances: z12.array(operationPhaseInstanceSchema)
 });
-var operationOptionsSchema = z.object({
-  /**
-   * Force update all dependencies regardless of their current state.
-   *
-   * **Operation Behavior Impact:**
-   * - bypasses hash-based change detection for dependency chains;
-   * - includes **ALL** dependencies (up-to-date, out-of-date, and error states);
-   * - traverses the entire dependency graph from requested instances.
-   *
-   * **Usage with other options:**
-   * - combined with `forceUpdateChildren`: updates entire dependency tree **AND** all composite children;
-   * - independent of `allowPartialCompositeInstanceCreation`: affects dependency traversal, not composite logic.
-   */
-  forceUpdateDependencies: z.boolean().default(false),
-  /**
-   * Ignore dependencies and operate only on explicitly requested instances.
-   *
-   * **Operation Behavior Impact:**
-   * - skips dependency inclusion even when dependencies are failed or undeployed;
-   * - caller must explicitly include every prerequisite instance to avoid failures;
-   * - complements on-demand or targeted updates where dependency safety is managed externally.
-   *
-   * **Usage with other options:**
-   * - mutually exclusive with `forceUpdateDependencies`;
-   * - independent of child/composite inclusion options.
-   */
-  ignoreDependencies: z.boolean().default(false),
-  /**
-   * Force update all children of composite instances regardless of their state.
-   *
-   * **Operation Behavior Impact:**
-   * - overrides selective child inclusion logic for composites;
-   * - includes **ALL** children of affected composites (up-to-date, out-of-date, and error states);
-   * - applied after dependency traversal and parent inclusion.
-   *
-   * **Usage with other options:**
-   * - combined with `forceUpdateDependencies`: creates comprehensive force-update behavior;
-   * - overrides `allowPartialCompositeInstanceCreation`: when enabled, **ALL** children are included regardless of existence.
-   */
-  forceUpdateChildren: z.boolean().default(false),
-  /**
-   * Include dependent instances when destroying instances.
-   *
-   * **Operation Behavior Impact:**
-   * - extends destroy operations to include instances that depend on the target;
-   * - traverses the dependency graph in reverse (dependents, not dependencies);
-   * - prevents orphaned instances that would fail without their dependencies.
-   *
-   * **Usage with other options:**
-   * - works with `invokeDestroyTriggers`: ensures triggers run for all dependents;
-   * - independent of update-related options.
-   */
-  destroyDependentInstances: z.boolean().default(true),
-  /**
-   * Execute destroy triggers when destroying instances.
-   *
-   * **Operation Behavior Impact:**
-   * - affects how individual units are destroyed (triggers vs direct deletion);
-   * - does not change which instances are selected for destruction;
-   * - controls trigger execution during the destruction phase.
-   *
-   * **Usage with other options:**
-   * - used with `destroyDependentInstances`: ensures triggers run for cascade deletions;
-   * - independent of update-related options.
-   */
-  invokeDestroyTriggers: z.boolean().default(true),
-  /**
-   * Delete Pulumi resources that are no longer referenced in the state.
-   *
-   * **Operation Behavior Impact:**
-   * - does not affect which instances are selected for operations;
-   * - deletes orphaned Pulumi resources within individual instances.
-   *
-   * **Usage with other options:**
-   * - independent of instance selection options;
-   * - complements destroy-related options for thorough cleanup.
-   */
-  deleteUnreachableResources: z.boolean().default(false),
-  /**
-   * Force deletion of instance state even if the destroy operation fails.
-   *
-   * **Operation Behavior Impact:**
-   * - forces state deletion even when destroy operations fail;
-   * - does not affect which instances are selected for operations;
-   * - bypasses normal destroy procedures as emergency fallback.
-   *
-   * **Usage with other options:**
-   * - used with destroy-related options when normal cleanup fails;
-   * - should be used cautiously as it can create state inconsistencies.
-   */
-  forceDeleteState: z.boolean().default(false),
-  /**
-   * Allow partial update of composite instances without requiring all outdated children.
-   *
-   * **Operation Behavior Impact:**
-   * - controls whether composite operations must include all outdated children or only necessary ones;
-   * - when `false` (default): all outdated children of substantive composites are included in operations;
-   * - when `true`: only necessary children are included, allowing partial composite operations;
-   * - applied during composite child traversal phase for substantive composites only.
-   *
-   * **Usage with other options:**
-   * - overridden by `forceUpdateChildren`: when force is enabled, **ALL** children are included regardless;
-   * - independent of `forceUpdateDependencies`: affects composite logic, not dependency traversal.
-   */
-  allowPartialCompositeInstanceUpdate: z.boolean().default(false),
-  /**
-   * Allow partial destruction of composite instances during cascade operations.
-   *
-   * **Operation Behavior Impact:**
-   * - controls whether cascade destruction must include all children or only necessary ones;
-   * - when `false` (default): cascade destruction includes **ALL** children of affected composites;
-   * - when `true`: cascade destruction includes only directly dependent children;
-   * - does not affect explicit composite destruction (always destroys all children);
-   * - does not affect parent propagation when destroying sibling composites.
-   *
-   * **Usage with other options:**
-   * - works with `destroyDependentInstances`: controls completeness of cascade destruction;
-   * - independent of update-related options.
-   */
-  allowPartialCompositeInstanceDestruction: z.boolean().default(false),
-  /**
-   * Also refresh the state of instances during the operation.
-   *
-   * **Operation Behavior Impact:**
-   * - does not change which instances are selected for operations;
-   * - synchronizes state with actual infrastructure during the operation.
-   *
-   * **Usage with other options:**
-   * - additive with dependency resolution options: refreshes all selected instances;
-   * - works with both all operation types.
-   */
-  refresh: z.boolean().default(false),
-  /**
-   * Enable debug logging for Pulumi engine and resource providers.
-   *
-   * **Security Note:**
-   * Debug mode may expose sensitive information including credentials in the logs.
-   * Use only when absolutely necessary for troubleshooting.
-   *
-   * **Implementation:**
-   * - sets Pulumi's debug option to true;
-   * - sets TF_LOG=DEBUG environment variable for Terraform providers.
-   */
-  debug: z.boolean().default(false)
+var operationOptionsSchema = z12.object({
+  forceUpdateDependencies: z12.boolean().default(false),
+  ignoreChangedDependencies: z12.boolean().default(false),
+  ignoreDependencies: z12.boolean().default(false),
+  forceUpdateChildren: z12.boolean().default(false),
+  onlyDestroyGhosts: z12.boolean().default(false),
+  firstDestroyGhosts: z12.boolean().default(false),
+  ignoreGhosts: z12.boolean().default(false),
+  destroyDependentInstances: z12.boolean().default(true),
+  invokeDestroyTriggers: z12.boolean().default(true),
+  deleteUnreachableResources: z12.boolean().default(false),
+  forceDeleteState: z12.boolean().default(false),
+  allowPartialCompositeInstanceUpdate: z12.boolean().default(false),
+  allowPartialCompositeInstanceDestruction: z12.boolean().default(false),
+  refresh: z12.boolean().default(false),
+  debug: z12.boolean().default(false)
 }).partial();
-var operationTypeSchema = z.enum([
+var operationTypeSchema = z12.enum([
   "update",
   "preview",
   "destroy",
   "recreate",
   "refresh"
 ]);
-var operationStatusSchema = z.enum([
+var operationStatusSchema = z12.enum([
   "pending",
   "running",
   "failing",
@@ -556,38 +488,38 @@ var operationStatusSchema = z.enum([
   "cancelled",
   "cancelling"
 ]);
-var operationMetaSchema = objectMetaSchema.pick({
+var operationMetaSchema = objectMetaSchema3.pick({
   title: true,
   description: true
 }).required({ title: true });
-var operationPlanInputSchema = z.object({
-  projectId: z.string(),
+var operationPlanInputSchema = z12.object({
+  projectId: z12.string(),
   type: operationTypeSchema,
-  instanceIds: z.array(instanceIdSchema).min(1),
+  instanceIds: z12.array(instanceIdSchema2).min(1),
   options: operationOptionsSchema.partial().optional()
 });
 var operationLaunchInputSchema = operationPlanInputSchema.extend({
   meta: operationMetaSchema,
   plan: operationPhaseSchema.array().optional()
 });
-var operationEventSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("updated"),
-    operation: z.custom()
+var operationEventSchema = z12.discriminatedUnion("type", [
+  z12.object({
+    type: z12.literal("updated"),
+    operation: z12.custom()
   }),
-  z.object({
-    type: z.literal("deleted"),
-    operationId: z.string()
+  z12.object({
+    type: z12.literal("deleted"),
+    operationId: z12.string()
   })
 ]);
-var operationOutputSchema = z.object({
-  id: z.cuid2(),
+var operationOutputSchema = z12.object({
+  id: z12.cuid2(),
   type: operationTypeSchema,
   status: operationStatusSchema,
   meta: operationMetaSchema,
-  startedAt: z.date(),
-  updatedAt: z.date(),
-  finishedAt: z.date().nullable()
+  startedAt: z12.date(),
+  updatedAt: z12.date(),
+  finishedAt: z12.date().nullable()
 });
 var finalOperationStatuses = ["completed", "failed", "cancelled"];
 function isFinalOperationStatus(status) {
@@ -596,24 +528,31 @@ function isFinalOperationStatus(status) {
 function isTransientOperationStatus(status) {
   return !!status && !finalOperationStatuses.includes(status);
 }
-var pageOutputSchema = z$1.object({
-  id: z$1.cuid2(),
-  meta: commonObjectMetaSchema,
-  name: z$1.string().nullable(),
-  stateId: z$1.cuid2().nullable(),
-  serviceAccountId: z$1.cuid2().nullable(),
-  serviceAccountMeta: serviceAccountMetaSchema.nullable(),
-  createdAt: z$1.date(),
-  updatedAt: z$1.date()
+// src/shared/models/project/page.ts
+import {
+  commonObjectMetaSchema as commonObjectMetaSchema7,
+  pageBlockSchema,
+  serviceAccountMetaSchema as serviceAccountMetaSchema2
+} from "@highstate/contract";
+import { z as z13 } from "zod";
+var pageOutputSchema = z13.object({
+  id: z13.cuid2(),
+  meta: commonObjectMetaSchema7,
+  name: z13.string().nullable(),
+  stateId: z13.cuid2().nullable(),
+  serviceAccountId: z13.cuid2().nullable(),
+  serviceAccountMeta: serviceAccountMetaSchema2.nullable(),
+  createdAt: z13.date(),
+  updatedAt: z13.date()
 });
 var pageQuerySchema = collectionQuerySchema.extend({
-  serviceAccountId: z$1.string().optional(),
-  stateId: z$1.string().optional(),
-  artifactId: z$1.string().optional()
+  serviceAccountId: z13.string().optional(),
+  stateId: z13.string().optional(),
+  artifactId: z13.string().optional()
 });
-var pageDetailsOutputSchema = z$1.object({
+var pageDetailsOutputSchema = z13.object({
   ...pageOutputSchema.shape,
-  content: z$1.array(pageBlockSchema)
+  content: z13.array(pageBlockSchema)
 });
 function toPageOutput(page, serviceAccount) {
   return {
@@ -621,20 +560,22 @@ function toPageOutput(page, serviceAccount) {
     serviceAccountMeta: serviceAccount?.meta ?? null
   };
 }
-var secretOutputSchema = z.object({
-  id: z.cuid2(),
+// src/shared/models/project/secret.ts
+import { globalCommonObjectMetaSchema, serviceAccountMetaSchema as serviceAccountMetaSchema3, z as z14 } from "@highstate/contract";
+var secretOutputSchema = z14.object({
+  id: z14.cuid2(),
   meta: globalCommonObjectMetaSchema,
-  name: z.string().nullable(),
-  systemName: z.string().nullable(),
-  stateId: z.cuid2().nullable(),
-  serviceAccountId: z.cuid2().nullable(),
-  serviceAccountMeta: serviceAccountMetaSchema.nullable(),
-  createdAt: z.date(),
-  updatedAt: z.date()
+  name: z14.string().nullable(),
+  systemName: z14.string().nullable(),
+  stateId: z14.cuid2().nullable(),
+  serviceAccountId: z14.cuid2().nullable(),
+  serviceAccountMeta: serviceAccountMetaSchema3.nullable(),
+  createdAt: z14.date(),
+  updatedAt: z14.date()
 });
 var secretQuerySchema = collectionQuerySchema.extend({
-  serviceAccountId: z.string().optional(),
-  stateId: z.string().optional()
+  serviceAccountId: z14.string().optional(),
+  stateId: z14.string().optional()
 });
 function toSecretOutput(secret, serviceAccount) {
   return {
@@ -642,41 +583,55 @@ function toSecretOutput(secret, serviceAccount) {
     serviceAccountMeta: serviceAccount?.meta ?? null
   };
 }
-var SystemSecretNames = /* @__PURE__ */ ((SystemSecretNames2) => {
+var SystemSecretNames;
+((SystemSecretNames2) => {
   SystemSecretNames2["PulumiPassword"] = "pulumi-password";
-  return SystemSecretNames2;
-})(SystemSecretNames || {});
-var serviceAccountOutputSchema = z.object({
-  id: z.cuid2(),
-  meta: serviceAccountMetaSchema,
-  createdAt: z.date(),
-  updatedAt: z.date()
+})(SystemSecretNames ||= {});
+// src/shared/models/project/service-account.ts
+import { serviceAccountMetaSchema as serviceAccountMetaSchema4, z as z15 } from "@highstate/contract";
+var serviceAccountOutputSchema = z15.object({
+  id: z15.cuid2(),
+  meta: serviceAccountMetaSchema4,
+  createdAt: z15.date(),
+  updatedAt: z15.date()
 });
 var serviceAccountQuerySchema = collectionQuerySchema.extend({
-  artifactId: z.string().optional()
+  artifactId: z15.string().optional()
 });
-var stableInstanceInputSchema = z$1.object({
-  stateId: z$1.string(),
-  output: z$1.string()
+// src/shared/models/project/state.ts
+import { z as z16 } from "zod";
+var stableInstanceInputSchema = z16.object({
+  stateId: z16.string(),
+  output: z16.string(),
+  path: z16.string().optional()
 });
-var instanceStateEventSchema = z$1.discriminatedUnion("type", [
-  z$1.object({
-    type: z$1.literal("updated"),
-    state: z$1.custom()
+var instanceStateEventSchema = z16.discriminatedUnion("type", [
+  z16.object({
+    type: z16.literal("updated"),
+    state: z16.custom()
   }),
-  z$1.object({
-    type: z$1.literal("patched"),
-    stateId: z$1.string(),
-    patch: z$1.custom()
+  z16.object({
+    type: z16.literal("patched"),
+    stateId: z16.string(),
+    patch: z16.custom()
   }),
-  z$1.object({
-    type: z$1.literal("deleted"),
-    stateId: z$1.string()
+  z16.object({
+    type: z16.literal("patched-batch"),
+    patches: z16.array(z16.object({
+      stateId: z16.string(),
+      patch: z16.custom()
+    }))
+  }),
+  z16.object({
+    type: z16.literal("deleted"),
+    stateId: z16.string()
   })
 ]);
 function isVirtualGhostInstance(state) {
-  if (state.source !== "virtual") return false;
-  if (state.status === "undeployed") return false;
+  if (state.source !== "virtual")
+    return false;
+  if (state.status === "undeployed")
+    return false;
   return !state.evaluationState;
 }
 function isInstanceDeployed(state) {
@@ -694,43 +649,51 @@ var finalInstanceOperationStatuses = [
 function isTransientInstanceOperationStatus(status) {
   return !!status && !finalInstanceOperationStatuses.includes(status);
 }
-var workerUnitRegistrationEventSchema = z$1.discriminatedUnion("type", [
-  z$1.object({
-    type: z$1.literal("registered"),
-    instanceId: z$1.string(),
-    params: z$1.record(z$1.string(), z$1.unknown())
+var workerUnitRegistrationEventSchema = z16.discriminatedUnion("type", [
+  z16.object({
+    type: z16.literal("registered"),
+    instanceId: z16.string(),
+    params: z16.record(z16.string(), z16.unknown())
   }),
-  z$1.object({
-    type: z$1.literal("deregistered"),
-    instanceId: z$1.string()
+  z16.object({
+    type: z16.literal("deregistered"),
+    instanceId: z16.string()
   })
 ]);
-var terminalStatusSchema = z$1.enum([
+// src/shared/models/project/terminal.ts
+import {
+  commonObjectMetaSchema as commonObjectMetaSchema8,
+  globalCommonObjectMetaSchema as globalCommonObjectMetaSchema2,
+  serviceAccountMetaSchema as serviceAccountMetaSchema5,
+  terminalSpecSchema
+} from "@highstate/contract";
+import { z as z17 } from "zod";
+var terminalStatusSchema = z17.enum([
   "active",
   "unavailable"
 ]);
-var terminalSessionOutputSchema = z$1.object({
-  id: z$1.cuid2(),
-  terminalId: z$1.cuid2(),
-  meta: globalCommonObjectMetaSchema,
-  startedAt: z$1.date(),
-  finishedAt: z$1.date().nullable()
+var terminalSessionOutputSchema = z17.object({
+  id: z17.cuid2(),
+  terminalId: z17.cuid2(),
+  meta: globalCommonObjectMetaSchema2,
+  startedAt: z17.date(),
+  finishedAt: z17.date().nullable()
 });
-var terminalOutputSchema = z$1.object({
-  id: z$1.cuid2(),
-  name: z$1.string().nullable(),
-  meta: commonObjectMetaSchema,
+var terminalOutputSchema = z17.object({
+  id: z17.cuid2(),
+  name: z17.string().nullable(),
+  meta: commonObjectMetaSchema8,
   status: terminalStatusSchema,
-  stateId: z$1.string().nullable(),
-  serviceAccountId: z$1.string().nullable(),
-  serviceAccountMeta: serviceAccountMetaSchema.nullable(),
-  createdAt: z$1.date(),
-  updatedAt: z$1.date()
+  stateId: z17.string().nullable(),
+  serviceAccountId: z17.string().nullable(),
+  serviceAccountMeta: serviceAccountMetaSchema5.nullable(),
+  createdAt: z17.date(),
+  updatedAt: z17.date()
 });
 var terminalQuerySchema = collectionQuerySchema.extend({
-  serviceAccountId: z$1.string().optional(),
-  stateId: z$1.string().optional(),
-  artifactId: z$1.string().optional()
+  serviceAccountId: z17.string().optional(),
+  stateId: z17.string().optional(),
+  artifactId: z17.string().optional()
 });
 function toTerminalOutput(terminal, serviceAccount) {
   return {
@@ -744,7 +707,7 @@ function toTerminalDetailsOutput(terminal, serviceAccount) {
     serviceAccountMeta: serviceAccount?.meta ?? null
   };
 }
-var terminalDetailsOutputSchema = z$1.object({
+var terminalDetailsOutputSchema = z17.object({
   ...terminalOutputSchema.shape,
   spec: terminalSpecSchema
 });
@@ -757,36 +720,44 @@ function toTerminalSessionOutput(terminal, session) {
     finishedAt: session.finishedAt
   };
 }
-var triggerOutputSchema = z$1.object({
-  id: z$1.cuid2(),
-  meta: commonObjectMetaSchema,
-  name: z$1.string(),
-  stateId: z$1.cuid2(),
-  createdAt: z$1.date(),
-  updatedAt: z$1.date()
+// src/shared/models/project/trigger.ts
+import { commonObjectMetaSchema as commonObjectMetaSchema9 } from "@highstate/contract";
+import { z as z18 } from "zod";
+var triggerOutputSchema = z18.object({
+  id: z18.cuid2(),
+  meta: commonObjectMetaSchema9,
+  name: z18.string(),
+  stateId: z18.cuid2(),
+  createdAt: z18.date(),
+  updatedAt: z18.date()
 });
 var triggerQuerySchema = collectionQuerySchema.extend({
-  stateId: z$1.string().optional()
+  stateId: z18.string().optional()
 });
-var unlockMethodType = z.enum(["password", "passkey"]);
-var unlockMethodMetaSchema = objectMetaSchema.pick({
+// src/shared/models/project/unlock-method.ts
+import { objectMetaSchema as objectMetaSchema4, z as z19 } from "@highstate/contract";
+var unlockMethodType = z19.enum(["password", "passkey"]);
+var unlockMethodMetaSchema = objectMetaSchema4.pick({
   title: true,
   description: true
 }).required({ title: true });
-var unlockMethodInputSchema = z.object({
+var unlockMethodInputSchema = z19.object({
   meta: unlockMethodMetaSchema,
   type: unlockMethodType,
-  encryptedIdentity: z.string(),
-  recipient: z.string()
+  encryptedIdentity: z19.string(),
+  recipient: z19.string()
 });
-var unlockMethodOutputSchema = z.object({
-  id: z.cuid2(),
+var unlockMethodOutputSchema = z19.object({
+  id: z19.cuid2(),
   type: unlockMethodType,
   meta: unlockMethodMetaSchema,
-  recipient: z.string(),
-  createdAt: z.date(),
-  updatedAt: z.date()
+  recipient: z19.string(),
+  createdAt: z19.date(),
+  updatedAt: z19.date()
 });
+// src/shared/models/project/worker.ts
+import { commonObjectMetaSchema as commonObjectMetaSchema10, serviceAccountMetaSchema as serviceAccountMetaSchema6 } from "@highstate/contract";
+import { z as z20 } from "zod";
 var MAX_WORKER_START_ATTEMPTS = 3;
 var SHA256_PREFIX = "sha256:";
 var SHA256_REGEX = /^[a-f0-9]{64}$/;
@@ -815,7 +786,7 @@ function getWorkerIdentity(image) {
   }
   return withoutDigest;
 }
-var workerVersionStatusSchema = z$1.enum([
+var workerVersionStatusSchema = z20.enum([
   "unknown",
   "starting",
   "running",
@@ -823,27 +794,31 @@ var workerVersionStatusSchema = z$1.enum([
   "stopped",
   "error"
 ]);
-var workerVersionOutputSchema = z$1.object({
-  id: z$1.cuid2(),
-  digest: z$1.string(),
-  meta: commonObjectMetaSchema,
+var workerVersionStatusEventSchema = z20.object({
+  workerVersionId: z20.cuid2(),
+  status: workerVersionStatusSchema
+});
+var workerVersionOutputSchema = z20.object({
+  id: z20.cuid2(),
+  digest: z20.string(),
+  meta: commonObjectMetaSchema10,
   status: workerVersionStatusSchema,
-  enabled: z$1.boolean(),
-  apiKeyId: z$1.string(),
+  enabled: z20.boolean(),
+  apiKeyId: z20.string(),
   apiKeyMeta: apiKeyMetaSchema,
-  createdAt: z$1.date(),
-  updatedAt: z$1.date()
+  createdAt: z20.date(),
+  updatedAt: z20.date()
 });
-var workerOutputSchema = z$1.object({
-  id: z$1.cuid2(),
-  identity: z$1.string(),
-  meta: commonObjectMetaSchema,
-  serviceAccountId: z$1.string(),
-  serviceAccountMeta: serviceAccountMetaSchema,
-  createdAt: z$1.date()
+var workerOutputSchema = z20.object({
+  id: z20.cuid2(),
+  identity: z20.string(),
+  meta: commonObjectMetaSchema10,
+  serviceAccountId: z20.string(),
+  serviceAccountMeta: serviceAccountMetaSchema6,
+  createdAt: z20.date()
 });
 var workerQuerySchema = collectionQuerySchema.extend({
-  serviceAccountId: z$1.string().optional()
+  serviceAccountId: z20.string().optional()
 });
 function toWorkerOutput(worker, lastVersion, serviceAccount) {
   return {
@@ -858,17 +833,119 @@ function toWorkerVersionOutput(version, apiKey) {
     apiKeyMeta: apiKey.meta
   };
 }
-var GraphResolver = class {
+// src/shared/resolvers/effective-output-type.ts
+function resolveEffectiveOutputType(options) {
+  const visited = options.visited ?? new Set;
+  const producer = options.getInstanceContext(options.input.instanceId);
+  if (!producer) {
+    return resolveTypeByPathOrFallbackInclusion({
+      rootType: options.fallbackType,
+      path: options.input.path,
+      entities: undefined,
+      fallbackType: options.fallbackType
+    });
+  }
+  const outputSpec = producer.component.outputs[options.input.output];
+  if (!outputSpec) {
+    return resolveTypeByPathOrFallbackInclusion({
+      rootType: options.fallbackType,
+      path: options.input.path,
+      entities: producer.entities,
+      fallbackType: options.fallbackType
+    });
+  }
+  let effectiveType = outputSpec.type;
+  if (outputSpec.fromInput) {
+    const visitedKey = `${producer.instance.id}:${options.input.output}`;
+    if (!visited.has(visitedKey)) {
+      visited.add(visitedKey);
+      const forwardedInputName = outputSpec.fromInput;
+      const forwardedFallback = producer.component.inputs[forwardedInputName]?.type ?? effectiveType;
+      const hasHubInputs = (producer.instance.hubInputs?.[forwardedInputName]?.length ?? 0) > 0;
+      const hasInjectionInputs = (producer.instance.injectionInputs?.length ?? 0) > 0;
+      const directInputs = producer.instance.inputs?.[forwardedInputName] ?? [];
+      if (!hasHubInputs && !hasInjectionInputs && directInputs.length === 1) {
+        const forwardedInput = directInputs[0];
+        if (forwardedInput) {
+          effectiveType = resolveEffectiveOutputType({
+            input: forwardedInput,
+            fallbackType: forwardedFallback,
+            getInstanceContext: options.getInstanceContext,
+            visited
+          });
+        } else {
+          effectiveType = forwardedFallback;
+        }
+      } else {
+        effectiveType = forwardedFallback;
+      }
+    }
+  }
+  return resolveTypeByPathOrFallbackInclusion({
+    rootType: effectiveType,
+    path: options.input.path,
+    entities: producer.entities,
+    fallbackType: options.fallbackType
+  });
+}
+function resolveTypeByPathOrFallbackInclusion(options) {
+  const { rootType, path, entities, fallbackType } = options;
+  if (!path || !entities) {
+    return resolveTypeByImplicitInclusion(rootType, fallbackType, entities);
+  }
+  let currentType = rootType;
+  const segments = path.split(".");
+  for (const segment of segments) {
+    const entity2 = entities[currentType];
+    if (!entity2) {
+      return rootType;
+    }
+    const inclusion = entity2.inclusions?.find((inc) => inc.field === segment);
+    if (!inclusion) {
+      return rootType;
+    }
+    currentType = inclusion.type;
+  }
+  return currentType;
+}
+function resolveTypeByImplicitInclusion(rootType, fallbackType, entities) {
+  if (!entities) {
+    return rootType;
+  }
+  if (rootType === fallbackType) {
+    return rootType;
+  }
+  const rootEntity = entities[rootType];
+  if (!rootEntity) {
+    return rootType;
+  }
+  if (rootEntity.extensions?.includes(fallbackType)) {
+    return rootType;
+  }
+  const inclusion = rootEntity.inclusions?.find((inc) => inc.type === fallbackType);
+  if (inclusion) {
+    return fallbackType;
+  }
+  return rootType;
+}
+// src/shared/resolvers/graph-resolver.ts
+import { unique } from "remeda";
+
+class GraphResolver {
+  nodes;
+  logger;
+  outputHandler;
+  dependentSetHandler;
+  workset = new Set;
+  dependencyMap = new Map;
+  dependentMap = new Map;
+  outputMap = new Map;
   constructor(nodes, logger, outputHandler, dependentSetHandler) {
     this.nodes = nodes;
     this.logger = logger;
     this.outputHandler = outputHandler;
     this.dependentSetHandler = dependentSetHandler;
   }
-  workset = /* @__PURE__ */ new Set();
-  dependencyMap = /* @__PURE__ */ new Map();
-  dependentMap = /* @__PURE__ */ new Map();
-  outputMap = /* @__PURE__ */ new Map();
   addToWorkset(nodeId) {
     this.workset.add(nodeId);
   }
@@ -877,17 +954,9 @@ var GraphResolver = class {
       this.workset.add(nodeId);
     }
   }
-  /**
-   * The map of calculated outputs.
-   */
   get outputs() {
     return this.outputMap;
   }
-  /**
-   * The map of dependencies for each node.
-   *
-   * The key is the node identifier, and the value is an array of identifiers of the nodes which depend on it.
-   */
   get dependents() {
     return this.dependentMap;
   }
@@ -898,11 +967,6 @@ var GraphResolver = class {
     }
     return output;
   }
-  /**
-   * Gets the identifiers of the nodes that depend on the given node directly.
-   *
-   * Returns an empty array if there are no dependents.
-   */
   getDependents(nodeId) {
     const dependents = this.dependentMap.get(nodeId);
     if (!dependents) {
@@ -910,11 +974,6 @@ var GraphResolver = class {
     }
     return Array.from(dependents);
   }
-  /**
-   * 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) {
@@ -935,13 +994,6 @@ var GraphResolver = class {
       }
     }
   }
-  /**
-   * Invalidates a single node without invalidating its dependents.
-   *
-   * Also adds the node to the work set for processing.
-   *
-   * Should be used with caution, as it may lead to inconsistent state if the dependents are not re-processed separately.
-   */
   invalidateSingle(nodeId) {
     if (!this.nodes.has(nodeId)) {
       return;
@@ -949,11 +1001,6 @@ var GraphResolver = class {
     this.outputMap.delete(nodeId);
     this.workset.add(nodeId);
   }
-  /**
-   * 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;
@@ -994,7 +1041,7 @@ var GraphResolver = class {
           this.logger.warn({ nodeId }, "processing aborted, skipping output");
           return;
         }
-        const changedDependentMaps = /* @__PURE__ */ new Set();
+        const changedDependentMaps = new Set;
         const oldDependencies = this.dependencyMap.get(nodeId) ?? [];
         for (const depId of oldDependencies) {
           const dependantSet = this.dependentMap.get(depId);
@@ -1009,7 +1056,7 @@ var GraphResolver = class {
         for (const depId of stackItem.dependencies) {
           let dependantSet = this.dependentMap.get(depId);
           if (!dependantSet) {
-            dependantSet = /* @__PURE__ */ new Set();
+            dependantSet = new Set;
             this.dependentMap.set(depId, dependantSet);
           }
           dependantSet.add(nodeId);
@@ -1029,9 +1076,9 @@ var GraphResolver = class {
       this.workset.delete(rootNodeId);
     }
   }
-};
+}
 function getAllDependents(dependentMap, nodeId) {
-  const result = /* @__PURE__ */ new Set();
+  const result = new Set;
   const stack = [nodeId];
   while (stack.length > 0) {
     const dependents = dependentMap.get(stack.pop());
@@ -1047,7 +1094,13 @@ function getAllDependents(dependentMap, nodeId) {
   }
   return Array.from(result);
 }
-var InputResolver = class extends GraphResolver {
+// src/shared/resolvers/input.ts
+import {
+  inputKey,
+  isUnitModel
+} from "@highstate/contract";
+import { fromEntries, mapValues as mapValues2 } from "remeda";
+class InputResolver extends GraphResolver {
   getNodeDependencies(node) {
     const dependencies = [];
     if (node.kind === "hub") {
@@ -1074,6 +1127,23 @@ var InputResolver = class extends GraphResolver {
     }
     return dependencies;
   }
+  resolveOutputTypeForInput(input, fallbackType) {
+    return resolveEffectiveOutputType({
+      input,
+      fallbackType,
+      getInstanceContext: (instanceId) => {
+        const output = this.outputs.get(`instance:${instanceId}`);
+        if (!output || output.kind !== "instance") {
+          return;
+        }
+        return {
+          instance: output.instance,
+          component: output.component,
+          entities: output.entities
+        };
+      }
+    });
+  }
   processNode(node) {
     const getHubOutput = (input) => {
       const output = this.outputs.get(`hub:${input.hubId}`);
@@ -1104,9 +1174,9 @@ var InputResolver = class extends GraphResolver {
       };
     };
     if (node.kind === "hub") {
-      const hubResult = /* @__PURE__ */ new Map();
+      const hubResult = new Map;
       const addHubResult = (input) => {
-        hubResult.set(`${input.input.instanceId}:${input.input.output}`, input);
+        hubResult.set(inputKey(input.input), input);
       };
       for (const input of node.hub.inputs ?? []) {
         const { component } = getInstanceOutput(input);
@@ -1115,7 +1185,10 @@ var InputResolver = class extends GraphResolver {
           this.logger.warn({ msg: "output not found in the component", input, component });
           continue;
         }
-        addHubResult({ input, type: componentInput.type });
+        addHubResult({
+          input,
+          type: this.resolveOutputTypeForInput(input, componentInput.type)
+        });
       }
       for (const injectionInput of node.hub.injectionInputs ?? []) {
         const { resolvedInputs: resolvedInputs2 } = getHubOutput(injectionInput);
@@ -1134,7 +1207,8 @@ var InputResolver = class extends GraphResolver {
         kind: "instance",
         instance: node.instance,
         component: node.component,
-        resolvedInputs: mapValues(node.instance.resolvedInputs, (inputs, inputName) => {
+        entities: node.entities,
+        resolvedInputs: mapValues2(node.instance.resolvedInputs, (inputs, inputName) => {
           const componentInput = node.component.inputs[inputName];
           if (!componentInput) {
             this.logger.warn({
@@ -1151,14 +1225,14 @@ var InputResolver = class extends GraphResolver {
         matchedInjectionInputs: []
       };
     }
-    const resolvedInputsMap = /* @__PURE__ */ new Map();
+    const resolvedInputsMap = new Map;
     const addInstanceResult = (inputName, input) => {
       let inputs = resolvedInputsMap.get(inputName);
       if (!inputs) {
-        inputs = /* @__PURE__ */ new Map();
+        inputs = new Map;
         resolvedInputsMap.set(inputName, inputs);
       }
-      inputs.set(`${input.input.instanceId}:${input.input.output}`, input);
+      inputs.set(inputKey(input.input), input);
     };
     const addInstanceInput = (inputName, input) => {
       const componentInput = node.component.inputs[inputName];
@@ -1176,15 +1250,31 @@ var InputResolver = class extends GraphResolver {
         return;
       }
       if (isUnitModel(component)) {
-        addInstanceResult(inputName, { input, type: componentInput.type });
+        addInstanceResult(inputName, {
+          input,
+          type: this.resolveOutputTypeForInput(input, componentInput.type)
+        });
         return;
       }
       if (resolvedOutputs) {
         for (const output of resolvedOutputs) {
-          addInstanceResult(inputName, { input: output, type: componentInput.type });
+          addInstanceResult(inputName, {
+            input: {
+              ...output,
+              path: input.path ?? output.path
+            },
+            type: this.resolveOutputTypeForInput({
+              instanceId: input.instanceId,
+              output: input.output,
+              path: input.path ?? output.path
+            }, componentInput.type)
+          });
         }
       } else {
-        addInstanceResult(inputName, { input, type: componentInput.type });
+        addInstanceResult(inputName, {
+          input,
+          type: this.resolveOutputTypeForInput(input, componentInput.type)
+        });
       }
     };
     for (const [inputName, inputs] of Object.entries(node.instance.inputs ?? {})) {
@@ -1192,12 +1282,12 @@ var InputResolver = class extends GraphResolver {
         addInstanceInput(inputName, input);
       }
     }
-    const injectionInputs = /* @__PURE__ */ new Map();
-    const matchedInjectionInputs = /* @__PURE__ */ new Map();
+    const injectionInputs = new Map;
+    const matchedInjectionInputs = 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);
+        injectionInputs.set(inputKey(input.input), input);
       }
     }
     for (const [inputName, componentInput] of Object.entries(node.component.inputs ?? {})) {
@@ -1206,36 +1296,35 @@ var InputResolver = class extends GraphResolver {
       for (const hubInput of hubInputs) {
         const { resolvedInputs: resolvedInputs2 } = getHubOutput(hubInput);
         for (const input of resolvedInputs2) {
-          allInputs.set(`${input.input.instanceId}:${input.input.output}`, input);
+          allInputs.set(inputKey(input.input), input);
         }
       }
       for (const input of allInputs.values()) {
         if (input.type === componentInput.type) {
           addInstanceInput(inputName, input.input);
-          const key = `${input.input.instanceId}:${input.input.output}`;
+          const key = inputKey(input.input);
           if (injectionInputs.has(key)) {
             matchedInjectionInputs.set(key, input);
           }
         }
       }
     }
-    const resolvedInputs = fromEntries(
-      Array.from(resolvedInputsMap.entries()).map(([inputName, inputs]) => [
-        inputName,
-        Array.from(inputs.values())
-      ])
-    );
+    const resolvedInputs = fromEntries(Array.from(resolvedInputsMap.entries()).map(([inputName, inputs]) => [
+      inputName,
+      Array.from(inputs.values())
+    ]));
     return {
       kind: "instance",
       instance: node.instance,
       component: node.component,
+      entities: node.entities,
       resolvedInputs,
       resolvedOutputs: node.instance.resolvedOutputs,
       resolvedInjectionInputs: Array.from(injectionInputs.values()),
       matchedInjectionInputs: Array.from(matchedInjectionInputs.values())
     };
   }
-};
+}
 function getResolvedHubInputs(outputMap, hubId) {
   const output = outputMap.get(`hub:${hubId}`);
   if (!output) {
@@ -1279,22 +1368,28 @@ function getMatchedInjectionInstanceInputs(outputMap, instanceId) {
 function getResolvedInstanceOutputs(outputMap, instanceId) {
   const output = outputMap.get(`instance:${instanceId}`);
   if (!output) {
-    return void 0;
+    return;
   }
   if (output.kind !== "instance") {
     throw new Error("Expected instance node");
   }
   return output.resolvedOutputs;
 }
+// src/shared/resolvers/input-hash.ts
+import { crc32 } from "@aws-crypto/crc32";
+import { isUnitModel as isUnitModel2 } from "@highstate/contract";
+import { encode } from "@msgpack/msgpack";
+import { Buffer } from "buffer-polyfill";
 
 // src/shared/utils/async-batcher.ts
-function createAsyncBatcher(fn, { waitMs = 100, maxWaitTimeMs = 1e3 } = {}) {
+function createAsyncBatcher(fn, { waitMs = 100, maxWaitTimeMs = 1000 } = {}) {
   let batch = [];
   let activeTimeout = null;
   let maxWaitTimeout = null;
   let firstCallTimestamp = null;
   async function processBatch() {
-    if (batch.length === 0) return;
+    if (batch.length === 0)
+      return;
     const currentBatch = batch;
     batch = [];
     await fn(currentBatch);
@@ -1305,31 +1400,27 @@ function createAsyncBatcher(fn, { waitMs = 100, maxWaitTimeMs = 1e3 } = {}) {
     firstCallTimestamp = null;
   }
   function schedule() {
-    if (activeTimeout) clearTimeout(activeTimeout);
+    if (activeTimeout)
+      clearTimeout(activeTimeout);
     activeTimeout = setTimeout(() => {
       activeTimeout = null;
-      void processBatch();
+      processBatch();
     }, waitMs);
     if (!firstCallTimestamp) {
       firstCallTimestamp = Date.now();
       maxWaitTimeout = setTimeout(() => {
-        if (activeTimeout) clearTimeout(activeTimeout);
+        if (activeTimeout)
+          clearTimeout(activeTimeout);
         activeTimeout = null;
-        void processBatch();
+        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);
@@ -1343,7 +1434,6 @@ function createAsyncBatcher(fn, { waitMs = 100, maxWaitTimeMs = 1e3 } = {}) {
     }
   };
 }
-
 // src/shared/utils/hash.ts
 function int32ToBytes(value) {
   const buffer = new ArrayBuffer(4);
@@ -1351,20 +1441,13 @@ function int32ToBytes(value) {
   view.setInt32(0, value, true);
   return new Uint8Array(buffer);
 }
-
 // src/shared/utils/promise-tracker.ts
-var PromiseTracker = class {
-  trackedPromises = /* @__PURE__ */ new Set();
-  /**
-   * Tracks a promise to ensure its rejection is handled inside the tracker's scope.
-   */
+class PromiseTracker {
+  trackedPromises = new Set;
   track(promise) {
     const wrapped = promise.finally(() => this.trackedPromises.delete(promise));
     this.trackedPromises.add(wrapped);
   }
-  /**
-   * Waits for all tracked promises to resolve or reject.
-   */
   async waitForAll() {
     if (this.trackedPromises.size === 0) {
       return;
@@ -1373,21 +1456,53 @@ var PromiseTracker = class {
     this.trackedPromises.clear();
     await waitAll(toTrack);
   }
-};
+}
 async function waitAll(promises) {
   const results = await Promise.allSettled(promises);
   const rejected = results.filter((p) => p.status === "rejected");
   if (!rejected.length) {
     return;
   }
-  throw new AggregateError(
-    rejected.map((p) => p.reason),
-    "Some promises were rejected"
-  );
+  throw new AggregateError(rejected.map((p) => p.reason), "Some promises were rejected");
+}
+// src/shared/utils/stable-json.ts
+function stableJsonStringify(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableJsonStringify).join(",")}]`;
+  }
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "number": {
+      if (!Number.isFinite(value)) {
+        throw new Error("Snapshot content contains a non-finite number");
+      }
+      return JSON.stringify(value);
+    }
+    case "boolean":
+      return value ? "true" : "false";
+    case "object": {
+      const record = value;
+      const keys = Object.keys(record).sort();
+      const parts = [];
+      for (const key of keys) {
+        const item = record[key];
+        if (item === undefined) {
+          throw new Error("Snapshot content contains undefined");
+        }
+        parts.push(`${JSON.stringify(key)}:${stableJsonStringify(item)}`);
+      }
+      return `{${parts.join(",")}}`;
+    }
+    default:
+      throw new Error(`Snapshot content contains non-JSON value of type "${typeof value}"`);
+  }
 }
-
 // src/shared/resolvers/input-hash.ts
-var InputHashResolver = class extends GraphResolver {
+class InputHashResolver extends GraphResolver {
   getNodeDependencies({ resolvedInputs }) {
     const dependencies = [];
     for (const inputs of Object.values(resolvedInputs ?? {})) {
@@ -1402,41 +1517,35 @@ var InputHashResolver = class extends GraphResolver {
     component,
     resolvedInputs,
     sourceHash,
-    state
+    state: state2
   }) {
     const selfHashSink = [];
     selfHashSink.push(Buffer.from(instance.id));
     selfHashSink.push(int32ToBytes(component.definitionHash));
-    if (state?.inputHashNonce) {
-      selfHashSink.push(int32ToBytes(state.inputHashNonce));
+    if (state2?.inputHashNonce) {
+      selfHashSink.push(int32ToBytes(state2.inputHashNonce));
     }
     if (instance.args) {
       selfHashSink.push(encode(instance.args));
     }
     if (sourceHash) {
       selfHashSink.push(int32ToBytes(sourceHash));
-    } else if (isUnitModel(component)) {
-      this.logger.warn(
-        { instanceId: instance.id },
-        "missing source hash for unit model, this may lead to incorrect input hash"
-      );
+    } else if (isUnitModel2(component)) {
+      this.logger.warn({ instanceId: instance.id }, "missing source hash for unit model, this may lead to incorrect input hash");
     }
     const inputHashSink = [...selfHashSink];
     const sortedInputs = Object.entries(resolvedInputs).sort(([a], [b]) => a.localeCompare(b));
-    const dependencyInstanceIds = /* @__PURE__ */ new Set();
-    for (const [inputKey, inputs] of sortedInputs) {
+    const dependencyInstanceIds = new Set;
+    for (const [inputKey2, inputs] of sortedInputs) {
       if (Object.keys(inputs).length === 0) {
         continue;
       }
-      inputHashSink.push(Buffer.from(inputKey));
+      inputHashSink.push(Buffer.from(inputKey2));
       const instanceIds = inputs.map((input) => input.input.instanceId).sort();
       for (const instanceId of instanceIds) {
         const dependency = this.outputs.get(instanceId);
         if (!dependency) {
-          this.logger.warn(
-            { instanceId, dependentInstanceId: instance.id },
-            "missing dependency when calculating input hash, this may lead to incorrect input hash"
-          );
+          this.logger.warn({ instanceId, dependentInstanceId: instance.id }, "missing dependency when calculating input hash, this may lead to incorrect input hash");
           continue;
         }
         inputHashSink.push(int32ToBytes(dependency.inputHash));
@@ -1449,10 +1558,7 @@ var InputHashResolver = class extends GraphResolver {
     for (const dependencyInstanceId of sortedDependencyInstanceIds) {
       const dependency = this.outputs.get(dependencyInstanceId);
       if (!dependency) {
-        this.logger.warn(
-          { instanceId: dependencyInstanceId, dependentInstanceId: instance.id },
-          "missing dependency when calculating dependency output hash, this may lead to incorrect input hash"
-        );
+        this.logger.warn({ instanceId: dependencyInstanceId, dependentInstanceId: instance.id }, "missing dependency when calculating dependency output hash, this may lead to incorrect input hash");
         continue;
       }
       dependencyOutputHashSink.push(int32ToBytes(dependency.outputHash));
@@ -1461,11 +1567,18 @@ var InputHashResolver = class extends GraphResolver {
       selfHash: crc32(Buffer.concat(selfHashSink)),
       inputHash: crc32(Buffer.concat(inputHashSink)),
       dependencyOutputHash: crc32(Buffer.concat(dependencyOutputHashSink)),
-      outputHash: state?.outputHash ?? 0
+      outputHash: state2?.outputHash ?? 0
     };
   }
-};
-var ValidationResolver = class extends GraphResolver {
+}
+// src/shared/resolvers/validation.ts
+import {
+  isUnitModel as isUnitModel3,
+  parseArgumentValue
+} from "@highstate/contract";
+import { Ajv } from "ajv";
+import styles from "ansi-styles";
+class ValidationResolver extends GraphResolver {
   getNodeDependencies({ resolvedInputs }) {
     const dependencies = [];
     for (const inputs of Object.values(resolvedInputs)) {
@@ -1475,38 +1588,29 @@ var ValidationResolver = class extends GraphResolver {
     }
     return dependencies;
   }
-  processNode({ instance, component, state, resolvedInputs }) {
+  processNode({ instance, component, state: state2, resolvedInputs }) {
     const ajv = new Ajv({ strict: false });
     this.logger.debug({ instanceId: instance.id }, "validating instance");
     const validationErrors = [];
     for (const [name, argument] of Object.entries(component.args)) {
       try {
         const value = parseArgumentValue(instance.args?.[name]);
-        if (!argument.required && value === void 0) {
+        if (!argument.required && value === undefined) {
           continue;
         }
         if (!ajv.validate(argument.schema, value)) {
           this.logger.debug({ instanceId: instance.id, argumentName: name }, "invalid argument");
-          validationErrors.push(
-            `Invalid argument "${styles.blueBright.open}${name}${styles.reset.close}": ` + ajv.errorsText()
-          );
+          validationErrors.push(`Invalid argument ` + `"${styles.blueBright.open}${name}${styles.reset.close}": ` + ajv.errorsText());
         }
       } catch (error) {
-        this.logger.debug(
-          { instanceId: instance.id, argumentName: name, error },
-          "failed to validate argument"
-        );
-        validationErrors.push(
-          `Failed to validate argument "${styles.blueBright.open}${name}${styles.reset.close}": ` + (error instanceof Error ? error.message : String(error))
-        );
+        this.logger.debug({ instanceId: instance.id, argumentName: name, error }, "failed to validate argument");
+        validationErrors.push(`Failed to validate argument ` + `"${styles.blueBright.open}${name}${styles.reset.close}": ` + (error instanceof Error ? error.message : String(error)));
       }
     }
-    if (isUnitModel(component)) {
-      for (const [secret, secretSchema] of Object.entries(component.secrets)) {
-        if (secretSchema.required && !state?.secretNames?.includes(secret)) {
-          validationErrors.push(
-            `Missing required secret "${styles.blueBright.open}${secret}${styles.reset.close}"`
-          );
+    if (isUnitModel3(component)) {
+      for (const [secret2, secretSchema] of Object.entries(component.secrets)) {
+        if (secretSchema.required && !state2?.secretNames?.includes(secret2)) {
+          validationErrors.push(`Missing required secret ` + `"${styles.blueBright.open}${secret2}${styles.reset.close}"`);
         }
       }
     }
@@ -1514,10 +1618,8 @@ var ValidationResolver = class extends GraphResolver {
       for (const input of inputs) {
         const inputInstance = this.outputs.get(input.input.instanceId);
         if (inputInstance?.status !== "ok") {
-          validationErrors.push(
-            `Invalid input "${styles.blueBright.open}${key}${styles.reset.close}":
-"${styles.blueBright.open}${input.input.instanceId}${styles.reset.close}" has validation errors`
-          );
+          validationErrors.push(`Invalid input ` + `"${styles.blueBright.open}${key}${styles.reset.close}":
+` + `"${styles.blueBright.open}${input.input.instanceId}${styles.reset.close}" ` + `has validation errors`);
         }
       }
     }
@@ -1526,9 +1628,7 @@ var ValidationResolver = class extends GraphResolver {
         continue;
       }
       if (!resolvedInputs[name] || !resolvedInputs[name].length) {
-        validationErrors.push(
-          `Missing required input "${styles.blueBright.open}${name}${styles.reset.close}" of type "${styles.greenBright.open}${input.type}${styles.reset.close}"`
-        );
+        validationErrors.push(`Missing required input ` + `"${styles.blueBright.open}${name}${styles.reset.close}" ` + `of type ` + `"${styles.greenBright.open}${input.type}${styles.reset.close}"`);
       }
     }
     if (validationErrors.length === 0) {
@@ -1536,19 +1636,22 @@ var ValidationResolver = class extends GraphResolver {
     }
     const numberPrefixLength = (validationErrors.length + 1).toString().length + 2;
     const formattedError = validationErrors.map((error, index) => {
-      const lines = error.split("\n");
+      const lines = error.split(`
+`);
       const prefix = `${index + 1}. `;
       return lines.map((line, lineIndex) => {
         const linePrefix = lineIndex === 0 ? prefix : " ".repeat(numberPrefixLength);
         return `${linePrefix}${line}`;
-      }).join("\r\n");
-    }).join("\r\n");
+      }).join(`\r
+`);
+    }).join(`\r
+`);
     return {
       status: "error",
       errorText: formattedError
     };
   }
-};
+}
 
 // src/shared/resolvers/registry.ts
 var resolverFactories = {
@@ -1556,7 +1659,4 @@ var resolverFactories = {
   InputHashResolver,
   ValidationResolver
 };
-
-export { AccessError, BackendError, BackendUnlockMethodNotFoundError, CannotDeleteLastBackendUnlockMethodError, CannotDeleteLastUnlockMethodError, GraphResolver, InputHashResolver, InputResolver, InstanceLockLostError, InstanceLockedError, InstanceNotFoundError, InstanceStateNotFoundError, InvalidInstanceKindError, MAX_WORKER_START_ATTEMPTS, OperationNotFoundError, ProjectLockedError, ProjectNotFoundError, PromiseTracker, SystemSecretNames, ValidationResolver, WorkerVersionNotFoundError, apiKeyMetaSchema, apiKeyOutputSchema, apiKeyQuerySchema, applyLibraryUpdate, artifactOutputSchema, artifactQuerySchema, backendUnlockMethodInputSchema, backendUnlockMethodMetaSchema, codebaseLibrary, codebaseProjectModelStorage, collectionQueryResult, collectionQuerySchema, createAsyncBatcher, databaseProjectModelStorage, diffLibraries, extractDigestFromImage, finalInstanceOperationStatuses, finalOperationStatuses, forSchema, getAllDependents, getMatchedInjectionInstanceInputs, getResolvedHubInputs, getResolvedInjectionInstanceInputs, getResolvedInstanceInputs, getResolvedInstanceOutputs, getWorkerIdentity, globalProjectSpace, hasObjectMeta, hostPulumiBackend, instanceCustomStatusInputSchema, instanceLockEventSchema, instanceLockOutputSchema, instanceStateEventSchema, int32ToBytes, isFinalOperationStatus, isInstanceDeployed, isTransientInstanceOperationStatus, isTransientOperationStatus, isVirtualGhostInstance, librarySpecSchema, operationEventSchema, operationLaunchInputSchema, operationMetaSchema, operationOptionsSchema, operationOutputSchema, operationPhaseInstanceSchema, operationPhaseSchema, operationPhaseTypeSchema, operationPlanInputSchema, operationStatusSchema, operationTypeSchema, pageDetailsOutputSchema, pageOutputSchema, pageQuerySchema, projectInputSchema, projectModelEventSchema, projectModelStorageSpecSchema, projectOutputSchema, projectUnlockStateSchema, projectUnlockSuiteSchema, pulumiBackendSpecSchema, resolverFactories, secretOutputSchema, secretQuerySchema, serviceAccountOutputSchema, serviceAccountQuerySchema, stableInstanceInputSchema, terminalDetailsOutputSchema, terminalOutputSchema, terminalQuerySchema, terminalSessionOutputSchema, terminalStatusSchema, toApiKeyOutput, toPageOutput, toSecretOutput, toTerminalDetailsOutput, toTerminalOutput, toTerminalSessionOutput, toWorkerOutput, toWorkerVersionOutput, triggerOutputSchema, triggerQuerySchema, unlockMethodInputSchema, unlockMethodMetaSchema, unlockMethodOutputSchema, unlockMethodType, waitAll, workerOutputSchema, workerQuerySchema, workerUnitRegistrationEventSchema, workerVersionOutputSchema, workerVersionStatusSchema };
-//# sourceMappingURL=chunk-V2NILDHS.js.map
-//# sourceMappingURL=chunk-V2NILDHS.js.map
+export { librarySpecSchema, diffLibraries, applyLibraryUpdate, globalProjectSpace, codebaseLibrary, hostPulumiBackend, codebaseProjectModelStorage, databaseProjectModelStorage, projectModelStorageSpecSchema, projectInputSchema, projectOutputSchema, projectUnlockSuiteSchema, projectUnlockStateSchema, pulumiBackendSpecSchema, backendUnlockMethodMetaSchema, backendUnlockMethodInputSchema, hasObjectMeta, collectionQuerySchema, collectionQueryResult, forSchema, BackendError, AccessError, ProjectLockedError, ProjectNotFoundError, CannotDeleteLastUnlockMethodError, InstanceNotFoundError, InvalidInstanceKindError, OperationNotFoundError, InstanceLockLostError, InstanceStateNotFoundError, InstanceLockedError, WorkerVersionNotFoundError, BackendUnlockMethodNotFoundError, CannotDeleteLastBackendUnlockMethodError, apiKeyMetaSchema, apiKeyOutputSchema, apiKeyQuerySchema, toApiKeyOutput, artifactOutputSchema, artifactQuerySchema, instanceCustomStatusInputSchema, entityOutputSchema, entityQuerySchema, entitySnapshotOutputSchema, entitySnapshotListItemOutputSchema, entitySnapshotDetailsOutputSchema, entityDetailsOutputSchema, entityReferenceOutputSchema, toCommonEntityMeta, instanceLockOutputSchema, instanceLockEventSchema, projectModelEventSchema, operationPhaseTypeSchema, operationPhaseInstanceSchema, operationPhaseSchema, operationOptionsSchema, operationTypeSchema, operationStatusSchema, operationMetaSchema, operationPlanInputSchema, operationLaunchInputSchema, operationEventSchema, operationOutputSchema, finalOperationStatuses, isFinalOperationStatus, isTransientOperationStatus, pageOutputSchema, pageQuerySchema, pageDetailsOutputSchema, toPageOutput, secretOutputSchema, secretQuerySchema, toSecretOutput, SystemSecretNames, serviceAccountOutputSchema, serviceAccountQuerySchema, stableInstanceInputSchema, instanceStateEventSchema, isVirtualGhostInstance, isInstanceDeployed, finalInstanceOperationStatuses, isTransientInstanceOperationStatus, workerUnitRegistrationEventSchema, terminalStatusSchema, terminalSessionOutputSchema, terminalOutputSchema, terminalQuerySchema, toTerminalOutput, toTerminalDetailsOutput, terminalDetailsOutputSchema, toTerminalSessionOutput, triggerOutputSchema, triggerQuerySchema, unlockMethodType, unlockMethodMetaSchema, unlockMethodInputSchema, unlockMethodOutputSchema, MAX_WORKER_START_ATTEMPTS, extractDigestFromImage, getWorkerIdentity, workerVersionStatusSchema, workerVersionStatusEventSchema, workerVersionOutputSchema, workerOutputSchema, workerQuerySchema, toWorkerOutput, toWorkerVersionOutput, resolveEffectiveOutputType, GraphResolver, getAllDependents, InputResolver, getResolvedHubInputs, getResolvedInstanceInputs, getResolvedInjectionInstanceInputs, getMatchedInjectionInstanceInputs, getResolvedInstanceOutputs, createAsyncBatcher, int32ToBytes, PromiseTracker, waitAll, stableJsonStringify, InputHashResolver, ValidationResolver, resolverFactories };