@highstate/contract 0.19.1 → 0.21.1

package/dist/index.js

@@ -1,12 +1,43 @@
-import { z } from 'zod';
-export { z } from 'zod';
-import { mapValues, pickBy, isNonNullish, uniqueBy } from 'remeda';
-import { parse } from 'yaml';
-
+// @bun
 // src/entity.ts
+import { z as z2 } from "zod";
+
+// src/cuidv2d.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+var cuidv2DefaultLength = 24;
+function bufToBigInt(buf) {
+  const bits = 8n;
+  let value = 0n;
+  for (const byte of buf.values()) {
+    value = (value << bits) + BigInt(byte);
+  }
+  return value;
+}
+function hashCuid2(input) {
+  const bytes = new TextEncoder().encode(input);
+  const digest = sha256(bytes);
+  return bufToBigInt(digest).toString(36).slice(1);
+}
+function normalizeCuid2Prefix(prefix) {
+  if (prefix >= "a" && prefix <= "z") {
+    return prefix;
+  }
+  if (prefix >= "0" && prefix <= "9") {
+    const digit = prefix.charCodeAt(0) - 48;
+    return String.fromCharCode(97 + digit);
+  }
+  throw new Error(`Invalid CUID prefix character: ${prefix}`);
+}
+function cuidv2d(namespace, identity) {
+  const hashInput = `${namespace}:${identity}`;
+  const hashed = hashCuid2(hashInput);
+  const raw = hashed.slice(0, cuidv2DefaultLength);
+  const prefix = normalizeCuid2Prefix(raw[0]);
+  return `${prefix}${raw.slice(1)}`;
+}
 
 // src/i18n.ts
-var knownAbbreviationsMap = /* @__PURE__ */ new Map();
+var knownAbbreviationsMap = new Map;
 function registerKnownAbbreviations(abbreviations) {
   for (const abbr of abbreviations) {
     const lower = abbr.toLowerCase();
@@ -18,8 +49,8 @@ function registerKnownAbbreviations(abbreviations) {
 function clearKnownAbbreviations() {
   knownAbbreviationsMap.clear();
 }
-function camelCaseToHumanReadable(text2) {
-  const words = text2.split(/(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|_|-|\./).filter((word) => word.length > 0);
+function camelCaseToHumanReadable(text) {
+  const words = text.split(/(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|_|-|\./).filter((word) => word.length > 0);
   return words.map((word) => {
     const lower = word.toLowerCase();
     if (knownAbbreviationsMap.has(lower)) {
@@ -28,58 +59,106 @@ function camelCaseToHumanReadable(text2) {
     return word.charAt(0).toUpperCase() + word.slice(1);
   }).join(" ");
 }
+
+// src/json-schema.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fixJsonSchema(schema) {
+  if (!isRecord(schema)) {
+    return schema;
+  }
+  const allOf = schema.allOf;
+  if (Array.isArray(allOf) && allOf.length > 0) {
+    const objectSchemas = [];
+    const otherSchemas = [];
+    for (const item of allOf) {
+      if (isRecord(item) && item.type === "object") {
+        objectSchemas.push(item);
+        continue;
+      }
+      otherSchemas.push(item);
+    }
+    if (objectSchemas.length > 1) {
+      const required = new Set;
+      const properties = {};
+      let additionalProperties;
+      for (const objectSchema of objectSchemas) {
+        const objectRequired = objectSchema.required;
+        if (Array.isArray(objectRequired)) {
+          for (const key of objectRequired) {
+            if (typeof key === "string") {
+              required.add(key);
+            }
+          }
+        }
+        const objectProperties = objectSchema.properties;
+        if (isRecord(objectProperties)) {
+          for (const [key, value] of Object.entries(objectProperties)) {
+            const existing = properties[key];
+            if (existing === undefined) {
+              properties[key] = value;
+              continue;
+            }
+            properties[key] = { allOf: [existing, value] };
+          }
+        }
+        if ("additionalProperties" in objectSchema) {
+          if (additionalProperties === undefined) {
+            additionalProperties = objectSchema.additionalProperties;
+          } else if (additionalProperties !== objectSchema.additionalProperties) {
+            additionalProperties = false;
+          }
+        }
+      }
+      const mergedObjectSchema = {
+        type: "object",
+        properties,
+        ...required.size > 0 ? { required: Array.from(required) } : {},
+        ...additionalProperties !== undefined ? { additionalProperties } : { additionalProperties: false }
+      };
+      const merged = otherSchemas.length === 0 ? mergedObjectSchema : {
+        ...schema,
+        allOf: [mergedObjectSchema, ...otherSchemas]
+      };
+      return fixJsonSchema(merged);
+    }
+  }
+  const next = { ...schema };
+  if (Array.isArray(next.allOf)) {
+    next.allOf = next.allOf.map(fixJsonSchema);
+  }
+  if (Array.isArray(next.anyOf)) {
+    next.anyOf = next.anyOf.map(fixJsonSchema);
+  }
+  if (Array.isArray(next.oneOf)) {
+    next.oneOf = next.oneOf.map(fixJsonSchema);
+  }
+  if (isRecord(next.properties)) {
+    next.properties = Object.fromEntries(Object.entries(next.properties).map(([key, value]) => [key, fixJsonSchema(value)]));
+  }
+  if (isRecord(next.items)) {
+    next.items = fixJsonSchema(next.items);
+  } else if (Array.isArray(next.items)) {
+    next.items = next.items.map(fixJsonSchema);
+  }
+  if (isRecord(next.additionalProperties)) {
+    next.additionalProperties = fixJsonSchema(next.additionalProperties);
+  }
+  return next;
+}
+
+// src/meta.ts
+import { z } from "zod";
 var objectMetaSchema = z.object({
-  /**
-   * Human-readable name of the object.
-   *
-   * Used in UI components for better user experience.
-   */
   title: z.string().optional(),
-  /**
-   * The title used globally for the object.
-   *
-   * For example, the title of an instance secret is "Password" which is okay
-   * to display in the instance secret list, but when the secret is displayed in a
-   * global secret list the name should be more descriptive, like "Proxmox Password".
-   */
   globalTitle: z.string().optional(),
-  /**
-   * Description of the object.
-   *
-   * Provides additional context for users and developers.
-   */
   description: z.string().optional(),
-  /**
-   * The color of the object.
-   *
-   * Used in UI components to visually distinguish objects.
-   */
   color: z.string().optional(),
-  /**
-   * Primary icon identifier.
-   *
-   * Should reference a iconify icon name, like "mdi:server" or "gg:remote".
-   */
   icon: z.string().optional(),
-  /**
-   * The color of the primary icon.
-   */
   iconColor: z.string().optional(),
-  /**
-   * The URL of the custom image that should be used as the icon or avatar.
-   */
   avatarUrl: z.string().optional(),
-  /**
-   * The secondary icon identifier.
-   *
-   * Used to provide additional context or actions related to the object.
-   *
-   * Should reference a iconify icon name, like "mdi:edit" or "mdi:delete".
-   */
   secondaryIcon: z.string().optional(),
-  /**
-   * The color of the secondary icon.
-   */
   secondaryIconColor: z.string().optional()
 });
 var commonObjectMetaSchema = objectMetaSchema.pick({
@@ -107,24 +186,12 @@ var serviceAccountMetaSchema = objectMetaSchema.pick({
   iconColor: true
 }).required({ title: true });
 var timestampsSchema = z.object({
-  /**
-   * The timestamp when the object was created.
-   */
   createdAt: z.date(),
-  /**
-   * The timestamp when the object was last updated.
-   */
   updatedAt: z.date()
 });
-var genericNameSchema = z.string().regex(
-  /^[a-z][a-z0-9-.]+$/,
-  "Name must start with a letter and can only contain lowercase letters, numbers, dashes (-) and dots (.)"
-).min(2).max(64);
+var genericNameSchema = z.string().regex(/^[a-z][a-z0-9-.]+$/, "Name must start with a letter and can only contain lowercase letters, numbers, dashes (-) and dots (.)").min(2).max(64);
 var versionedNameSchema = z.union([
   z.templateLiteral([genericNameSchema, z.literal("."), z.literal("v"), z.number().int().min(1)]),
-  // to prevent TypeScript matching "proxmox.virtual-machine.v2" as
-  // 1. "proxmox.v"
-  // 2. "irtual-machine.v2" and thinking it should be a number
   z.templateLiteral([
     genericNameSchema,
     z.literal("."),
@@ -160,53 +227,19 @@ function parseVersionedName(name) {
 var fieldNameSchema = z.string().regex(/^[a-z][a-zA-Z0-9]+$/, "Field name must start with a letter and be in camelCase format").min(2).max(64);
 
 // src/entity.ts
-var entityInclusionSchema = z.object({
-  /**
-   * The static type of the included entity.
-   */
+var entityInclusionSchema = z2.object({
   type: versionedNameSchema,
-  /**
-   * Whether the included entity is required.
-   * If false, the entity may be omitted.
-   */
-  required: z.boolean(),
-  /**
-   * Whether the included entity is multiple.
-   */
-  multiple: z.boolean(),
-  /**
-   * The name of the field where the included entity is embedded.
-   */
-  field: z.string()
+  required: z2.boolean(),
+  multiple: z2.boolean(),
+  field: z2.string()
 });
-var entityModelSchema = z.object({
-  /**
-   * The static type of the entity.
-   */
+var entityModelSchema = z2.object({
   type: versionedNameSchema,
-  /**
-   * The list of all extended entity types (direct and indirect).
-   */
-  extensions: z.string().array().optional(),
-  /**
-   * The list of directly extended entity types.
-   */
-  directExtensions: z.string().array().optional(),
-  /**
-   * The list of all included entities (directly or inherited from extensions).
-   */
+  extensions: z2.string().array().optional(),
+  directExtensions: z2.string().array().optional(),
   inclusions: entityInclusionSchema.array().optional(),
-  /**
-   * The list of directly included entities.
-   */
   directInclusions: entityInclusionSchema.array().optional(),
-  /**
-   * The JSON schema of the entity value.
-   */
-  schema: z.custom(),
-  /**
-   * The extra metadata of the entity.
-   */
+  schema: z2.custom(),
   meta: objectMetaSchema.required({ title: true }).pick({
     title: true,
     description: true,
@@ -214,13 +247,14 @@ var entityModelSchema = z.object({
     icon: true,
     iconColor: true
   }),
-  /**
-   * The CRC32 of the entity definition.
-   */
-  definitionHash: z.number()
+  definitionHash: z2.number()
 });
 function isEntityIncludeRef(value) {
-  return typeof value === "object" && value !== null && "entity" in value;
+  if (typeof value !== "object" || value === null || !("entity" in value)) {
+    return false;
+  }
+  const entity = value.entity;
+  return typeof entity === "function" || isEntity(entity);
 }
 function defineEntity(options) {
   try {
@@ -231,57 +265,54 @@ function defineEntity(options) {
   if (!options.schema) {
     throw new Error("Entity schema is required");
   }
-  const includedEntities = Object.entries(options.includes ?? {}).map(([field, entityRef]) => {
+  const includeRefs = Object.entries(options.includes ?? {}).map(([field, entityRef]) => {
     if (isEntityIncludeRef(entityRef)) {
-      return {
-        entity: entityRef.entity,
-        inclusion: {
-          type: entityRef.entity.type,
-          required: entityRef.required ?? true,
-          multiple: entityRef.multiple ?? false,
-          field
-        }
-      };
-    }
-    return {
-      entity: entityRef,
-      inclusion: {
-        type: entityRef.type,
-        required: true,
-        multiple: false,
-        field
-      }
-    };
-  });
-  const inclusionShape = includedEntities.reduce(
-    (shape, { entity, inclusion }) => {
-      if (inclusion.multiple) {
-        shape[inclusion.field] = inclusion.required ? entity.schema.array() : entity.schema.array().optional();
+      const required = entityRef.required ?? true;
+      const multiple = entityRef.multiple ?? false;
+      let getEntity2;
+      if (typeof entityRef.entity === "function") {
+        const entity = entityRef.entity;
+        getEntity2 = entity;
       } else {
-        shape[inclusion.field] = inclusion.required ? entity.schema : entity.schema.optional();
+        const entity = entityRef.entity;
+        getEntity2 = () => entity;
       }
-      return shape;
-    },
-    {}
-  );
-  let finalSchema = Object.values(options.extends ?? {}).reduce(
-    (schema, entity) => z.intersection(schema, entity.schema),
-    options.schema
-  );
-  if (includedEntities.length > 0) {
-    finalSchema = z.intersection(finalSchema, z.object(inclusionShape));
+      return { field, required, multiple, getEntity: getEntity2 };
+    }
+    const getEntity = () => entityRef;
+    return { field, required: true, multiple: false, getEntity };
+  });
+  const inclusionShape = includeRefs.reduce((shape, includeRef) => {
+    let schema = z2.lazy(() => includeRef.getEntity().schema);
+    if (includeRef.multiple) {
+      schema = includeRef.required ? schema.array().min(1) : schema.array().default([]);
+    } else {
+      schema = includeRef.required ? schema : schema.optional();
+    }
+    shape[includeRef.field] = schema;
+    return shape;
+  }, {});
+  let finalSchema = Object.values(options.extends ?? {}).reduce((schema, entity) => z2.intersection(schema, entity.schema), options.schema);
+  if (includeRefs.length > 0) {
+    finalSchema = z2.intersection(finalSchema, z2.object(inclusionShape));
   }
-  const directInclusions = includedEntities.map(({ inclusion }) => inclusion);
+  finalSchema = z2.intersection(finalSchema, entityWithMetaSchema);
+  const directInclusions = () => includeRefs.map((includeRef) => ({
+    type: includeRef.getEntity().type,
+    required: includeRef.required,
+    multiple: includeRef.multiple,
+    field: includeRef.field
+  }));
   const directExtensions = Object.values(options.extends ?? {}).map((entity) => entity.type);
-  const inclusions = Object.values(options.extends ?? {}).reduce(
-    (incs, entity) => {
+  const getInclusions = () => {
+    const incs = [...directInclusions()];
+    for (const entity of Object.values(options.extends ?? {})) {
       if (entity.model.inclusions) {
         incs.push(...entity.model.inclusions);
       }
-      return incs;
-    },
-    [...directInclusions]
-  );
+    }
+    return incs;
+  };
   const extensions = Object.values(options.extends ?? {}).reduce((exts, entity) => {
     exts.push(...entity.model.extensions ?? [], entity.type);
     return exts;
@@ -293,13 +324,23 @@ function defineEntity(options) {
       schema: finalSchema,
       model: {
         type: options.type,
-        extensions: extensions.length > 0 ? extensions : void 0,
-        directExtensions: directExtensions.length > 0 ? directExtensions : void 0,
-        inclusions: inclusions.length > 0 ? inclusions : void 0,
-        directInclusions: directInclusions.length > 0 ? directInclusions : void 0,
+        extensions: extensions.length > 0 ? extensions : undefined,
+        directExtensions: directExtensions.length > 0 ? directExtensions : undefined,
+        get inclusions() {
+          const incs = getInclusions();
+          return incs.length > 0 ? incs : undefined;
+        },
+        get directInclusions() {
+          const incs = directInclusions();
+          return incs.length > 0 ? incs : undefined;
+        },
         get schema() {
           if (!_schema) {
-            _schema = z.toJSONSchema(finalSchema, { target: "draft-7", unrepresentable: "any" });
+            const rawSchema = z2.toJSONSchema(finalSchema, {
+              target: "draft-7",
+              unrepresentable: "any"
+            });
+            _schema = fixJsonSchema(rawSchema);
           }
           return _schema;
         },
@@ -307,10 +348,8 @@ function defineEntity(options) {
           ...options.meta,
           title: options.meta?.title || camelCaseToHumanReadable(parseVersionedName(options.type)[0])
         },
-        // will be calculated by the library loader
         definitionHash: null
       }
-      // biome-ignore lint/suspicious/noExplicitAny: we already typed return type
     };
   } catch (error) {
     throw new Error(`Failed to define entity "${options.type}"`, { cause: error });
@@ -328,8 +367,315 @@ function isAssignableTo(entity, target) {
   }
   return entity.inclusions?.some((implementation) => implementation.type === target) ?? false;
 }
+var entityMetaSchema = z2.object({
+  type: versionedNameSchema,
+  identity: z2.string(),
+  references: z2.record(z2.string(), z2.string().array()).optional(),
+  ...objectMetaSchema.pick({
+    title: true,
+    description: true,
+    icon: true,
+    iconColor: true
+  }).shape
+});
+var entityWithMetaSchema = z2.object({
+  $meta: entityMetaSchema
+});
+var entityIdCache = new WeakMap;
+var entityIdNamespace = "3cd37048-7c50-43a9-a2b9-ff7ff2b5ee79";
+function getEntityId(entity) {
+  if (!entity.$meta) {
+    throw new Error("Entity $meta is required to generate an entity id");
+  }
+  const existingId = entityIdCache.get(entity);
+  if (existingId) {
+    return existingId;
+  }
+  const { type, identity } = entity.$meta;
+  const id = cuidv2d(entityIdNamespace, `${type}:${identity}`);
+  entityIdCache.set(entity, id);
+  return id;
+}
+// src/instance.ts
+import { z as z4 } from "zod";
+
+// src/shared.ts
+import { z as z3 } from "zod";
+var componentKindSchema = z3.enum(["composite", "unit"]);
+var runtimeSchema = Symbol("runtimeSchema");
+var kind = Symbol("kind");
 var boundaryInput = Symbol("boundaryInput");
-var boundaryInputs = Symbol("boundaryInputs");
+function inputKey(input) {
+  return input.path ? `${input.instanceId}:${input.output}:${input.path}` : `${input.instanceId}:${input.output}`;
+}
+
+// src/instance-input.ts
+function appendInputPath(currentPath, segment) {
+  return currentPath ? `${currentPath}.${segment}` : segment;
+}
+function createRuntimeInputAccessor(input, boundary) {
+  const accessorCache = input.provided ? undefined : new Map;
+  let currentBoundary = boundary;
+  return new Proxy(input, {
+    get(target, property, receiver) {
+      const runtimeTarget = target;
+      if (property === boundaryInput) {
+        return currentBoundary;
+      }
+      if (typeof property !== "string") {
+        return Reflect.get(target, property, receiver);
+      }
+      if (property in target) {
+        return Reflect.get(target, property, receiver);
+      }
+      if (property === "instanceId" || property === "output" || property === "path") {
+        return Reflect.get(target, property, receiver);
+      }
+      if (runtimeTarget.provided) {
+        return Reflect.get(runtimeTarget, property, receiver);
+      }
+      const cached = accessorCache?.get(property);
+      if (cached) {
+        return cached;
+      }
+      const nested = createNonProvidedInput(boundary, appendInputPath(runtimeTarget.path, property));
+      accessorCache?.set(property, nested);
+      return nested;
+    },
+    set(target, property, value, receiver) {
+      if (property === boundaryInput) {
+        currentBoundary = value;
+        return true;
+      }
+      return Reflect.set(target, property, value, receiver);
+    }
+  });
+}
+function createInput(input, options = {}) {
+  if (!("provided" in input)) {
+    const boundary2 = options.boundary ?? input;
+    const normalizedInput = {
+      provided: true,
+      instanceId: input.instanceId,
+      output: input.output,
+      ...input.path ? { path: input.path } : {},
+      [boundaryInput]: boundary2
+    };
+    return createRuntimeInputAccessor(normalizedInput, boundary2);
+  }
+  if (!input.provided) {
+    const boundary2 = options.boundary ?? input[boundaryInput];
+    if (!boundary2) {
+      throw new Error("Cannot create non-provided input without boundary metadata");
+    }
+    return createNonProvidedInput(boundary2, input.path);
+  }
+  const boundary = options.boundary ?? input[boundaryInput];
+  if (!boundary) {
+    throw new Error("Cannot create provided input without boundary metadata");
+  }
+  return createRuntimeInputAccessor(input, boundary);
+}
+function createNonProvidedInput(boundary, path) {
+  const target = {
+    provided: false,
+    ...path ? { path } : {},
+    [boundaryInput]: boundary
+  };
+  return createRuntimeInputAccessor(target, boundary);
+}
+function createMultipleInputAccessor(inputs, boundary) {
+  const arrayInputs = [...inputs];
+  arrayInputs[boundaryInput] = boundary;
+  return new Proxy(arrayInputs, {
+    get(target, property, receiver) {
+      if (typeof property !== "string") {
+        return Reflect.get(target, property, receiver);
+      }
+      if (property === "length" || property === "map" || property === "filter" || property === "path" || property in target) {
+        return Reflect.get(target, property, receiver);
+      }
+      const unfolded = target.flatMap((input) => {
+        if (!input.provided) {
+          return [];
+        }
+        const selected = input[property];
+        if (selected === undefined || selected === null) {
+          return [];
+        }
+        if (Array.isArray(selected)) {
+          return selected;
+        }
+        return [selected];
+      });
+      return createMultipleInputAccessor(unfolded, boundary);
+    }
+  });
+}
+function createDeepOutputAccessor(output) {
+  const normalizedOutput = createInput(output);
+  if (!normalizedOutput.provided) {
+    return normalizedOutput;
+  }
+  const accessorCache = new Map;
+  return new Proxy(normalizedOutput, {
+    get(target, property, receiver) {
+      if (typeof property !== "string") {
+        return Reflect.get(target, property, receiver);
+      }
+      if (property === "provided" || property === "instanceId" || property === "output" || property === "path") {
+        return Reflect.get(target, property, receiver);
+      }
+      if (property in target) {
+        return Reflect.get(target, property, receiver);
+      }
+      const cached = accessorCache.get(property);
+      if (cached !== undefined) {
+        return cached;
+      }
+      const providedTarget = target;
+      const nextInput = createInput({
+        ...providedTarget,
+        path: appendInputPath(providedTarget.path, property)
+      }, { boundary: providedTarget[boundaryInput] });
+      const resolved = createDeepOutputAccessor(nextInput);
+      accessorCache.set(property, resolved);
+      return resolved;
+    }
+  });
+}
+
+// src/instance.ts
+var positionSchema = z4.object({
+  x: z4.number(),
+  y: z4.number()
+});
+var instanceIdSchema = z4.templateLiteral([versionedNameSchema, ":", genericNameSchema]);
+var instanceInputSchema = z4.object({
+  instanceId: instanceIdSchema,
+  output: z4.string(),
+  path: z4.string().optional()
+});
+var hubInputSchema = z4.object({
+  hubId: z4.string()
+});
+var instanceModelPatchSchema = z4.object({
+  args: z4.record(z4.string(), z4.unknown()).optional(),
+  inputs: z4.record(z4.string(), z4.array(instanceInputSchema)).optional(),
+  hubInputs: z4.record(z4.string(), z4.array(hubInputSchema)).optional(),
+  injectionInputs: z4.array(hubInputSchema).optional(),
+  position: positionSchema.optional()
+});
+var instanceModelSchema = z4.object({
+  id: instanceIdSchema,
+  kind: componentKindSchema,
+  type: versionedNameSchema,
+  name: genericNameSchema,
+  ...instanceModelPatchSchema.shape,
+  resolvedInputs: z4.record(z4.string(), z4.array(instanceInputSchema)).optional(),
+  parentId: instanceIdSchema.optional(),
+  outputs: z4.record(z4.string(), z4.array(instanceInputSchema)).optional(),
+  resolvedOutputs: z4.record(z4.string(), z4.array(instanceInputSchema)).optional()
+});
+var hubModelPatchSchema = z4.object({
+  position: positionSchema.optional(),
+  inputs: z4.array(instanceInputSchema).optional(),
+  injectionInputs: z4.array(hubInputSchema).optional()
+});
+var hubModelSchema = z4.object({
+  id: z4.cuid2(),
+  ...hubModelPatchSchema.shape
+});
+function parseInstanceId(instanceId) {
+  const parts = instanceId.split(":");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid instance ID: ${instanceId}`);
+  }
+  return parts;
+}
+function selectInput(inputs, name) {
+  const groupBoundary = inputs[boundaryInput] ?? inputs[0]?.[boundaryInput];
+  if (inputs.length === 0 && !groupBoundary) {
+    throw new Error(`Cannot select input "${name}": empty input group has no boundary metadata to build a missing input reference.`);
+  }
+  const input = inputs.find((input2) => input2.provided && (input2.instanceId === name || parseInstanceId(input2.instanceId)[1] === name));
+  if (!input || !input.provided) {
+    const fallbackBoundary = groupBoundary ?? inputs.find((input2) => Boolean(input2[boundaryInput]))?.[boundaryInput] ?? inputs[0]?.[boundaryInput];
+    if (!fallbackBoundary) {
+      throw new Error(`Cannot select input "${name}": input group has no boundary metadata to build a missing input reference.`);
+    }
+    return createNonProvidedInput(fallbackBoundary);
+  }
+  const boundary = groupBoundary ?? input[boundaryInput];
+  return createInput(input, { boundary });
+}
+var HighstateSignature;
+((HighstateSignature2) => {
+  HighstateSignature2["Artifact"] = "d55c63ac-3174-4756-808f-f778e99af0d1";
+  HighstateSignature2["Yaml"] = "c857cac5-caa6-4421-b82c-e561fbce6367";
+  HighstateSignature2["Secret"] = "240e5789-6ae4-4b22-b9d8-87169e8b4bab";
+})(HighstateSignature ||= {});
+var yamlValueSchema = z4.object({
+  ["c857cac5-caa6-4421-b82c-e561fbce6367" /* Yaml */]: z4.literal(true),
+  value: z4.string()
+});
+var fileMetaSchema = z4.object({
+  name: z4.string(),
+  contentType: z4.string().optional(),
+  size: z4.number().optional(),
+  mode: z4.number().optional()
+});
+var WellKnownInstanceCustomStatus;
+((WellKnownInstanceCustomStatus2) => {
+  WellKnownInstanceCustomStatus2["Healthy"] = "healthy";
+  WellKnownInstanceCustomStatus2["Degraded"] = "degraded";
+  WellKnownInstanceCustomStatus2["Down"] = "down";
+  WellKnownInstanceCustomStatus2["Warning"] = "warning";
+  WellKnownInstanceCustomStatus2["Progressing"] = "progressing";
+  WellKnownInstanceCustomStatus2["Error"] = "error";
+})(WellKnownInstanceCustomStatus ||= {});
+var instanceStatusFieldValueSchema = z4.union([
+  z4.string(),
+  z4.number(),
+  z4.boolean(),
+  z4.string().array()
+]);
+var instanceStatusFieldSchema = z4.object({
+  name: z4.string(),
+  meta: objectMetaSchema.pick({
+    title: true,
+    icon: true,
+    iconColor: true
+  }).required({ title: true }),
+  complementaryTo: z4.string().optional(),
+  value: instanceStatusFieldValueSchema.optional()
+});
+function secretSchema(schema) {
+  const secretType = z4.object({
+    ["240e5789-6ae4-4b22-b9d8-87169e8b4bab" /* Secret */]: z4.literal(true),
+    value: schema
+  });
+  return z4.codec(z4.union([secretType, schema]), secretType, {
+    decode: (value) => typeof value === "object" && value !== null && ("240e5789-6ae4-4b22-b9d8-87169e8b4bab" /* Secret */ in value) ? value : { ["240e5789-6ae4-4b22-b9d8-87169e8b4bab" /* Secret */]: true, value },
+    encode: (value) => value
+  });
+}
+function isSecret(value) {
+  return typeof value === "object" && value !== null && "240e5789-6ae4-4b22-b9d8-87169e8b4bab" /* Secret */ in value;
+}
+// src/unit.ts
+import { mapValues as mapValues3 } from "remeda";
+import { z as z6 } from "zod";
+
+// src/component.ts
+import { isNonNullish, mapValues as mapValues2, pickBy, uniqueBy } from "remeda";
+import { z as z5 } from "zod";
+
+// src/evaluation.ts
+import { mapValues } from "remeda";
+function isStableInstanceInput(value) {
+  return typeof value === "object" && value !== null && "instanceId" in value && "output" in value && typeof value.instanceId === "string" && typeof value.output === "string";
+}
 function formatInstancePath(instance) {
   let result = instance.id;
   while (instance.parentId) {
@@ -342,21 +688,23 @@ function formatInstancePath(instance) {
   }
   return result;
 }
-var InstanceNameConflictError = class extends Error {
+
+class InstanceNameConflictError extends Error {
+  instanceId;
+  firstPath;
+  secondPath;
   constructor(instanceId, firstPath, secondPath) {
-    super(
-      `Multiple instances produced with the same instance ID "${instanceId}":
-1. ${firstPath}
-2. ${secondPath}`
-    );
+    super(`Multiple instances produced with the same instance ID "${instanceId}":
+` + `1. ${firstPath}
+` + `2. ${secondPath}`);
     this.instanceId = instanceId;
     this.firstPath = firstPath;
     this.secondPath = secondPath;
     this.name = "InstanceNameConflictError";
   }
-};
+}
 var currentInstance = null;
-var runtimeInstances = /* @__PURE__ */ new Map();
+var runtimeInstances = new Map;
 function resetEvaluation() {
   runtimeInstances.clear();
   currentInstance = null;
@@ -367,11 +715,7 @@ function getRuntimeInstances() {
 function registerInstance(component, instance, fn) {
   const conflicting = runtimeInstances.get(instance.id);
   if (conflicting) {
-    throw new InstanceNameConflictError(
-      instance.id,
-      formatInstancePath(conflicting.instance),
-      formatInstancePath(instance)
-    );
+    throw new InstanceNameConflictError(instance.id, formatInstancePath(conflicting.instance), formatInstancePath(instance));
   }
   runtimeInstances.set(instance.id, { instance, component });
   let previousParentInstance = null;
@@ -383,19 +727,38 @@ function registerInstance(component, instance, fn) {
     currentInstance = instance;
   }
   try {
-    const outputs = fn();
-    instance.resolvedOutputs = outputs;
-    instance.outputs = mapValues(
-      outputs ?? {},
-      (outputs2) => outputs2.map((output) => output[boundaryInput] ?? output)
-    );
-    return mapValues(
-      outputs,
-      (outputs2, outputKey) => outputs2.map((output) => ({
-        ...output,
-        [boundaryInput]: { instanceId: instance.id, output: outputKey }
-      }))
-    );
+    const rawOutputs = fn();
+    const outputs = mapValues(rawOutputs ?? {}, (outputGroup) => {
+      return [outputGroup].flat(2).filter(Boolean);
+    });
+    const toStableInputs = (outputGroup, useBoundaryFallback) => {
+      return outputGroup.map((output) => useBoundaryFallback ? output[boundaryInput] : output).filter(isStableInstanceInput).map((output) => {
+        return output.path ? {
+          instanceId: output.instanceId,
+          output: output.output,
+          path: output.path
+        } : {
+          instanceId: output.instanceId,
+          output: output.output
+        };
+      });
+    };
+    instance.resolvedOutputs = mapValues(outputs ?? {}, (outputGroup) => toStableInputs(outputGroup, false));
+    instance.outputs = mapValues(outputs ?? {}, (outputGroup) => toStableInputs(outputGroup, true));
+    return mapValues(rawOutputs, (rawOutputGroup, outputKey) => {
+      const outputRefs = (outputs[outputKey] ?? []).map((output) => {
+        if (output.provided) {
+          output[boundaryInput] = { instanceId: instance.id, output: outputKey };
+        }
+        return output;
+      });
+      if (component.model.outputs[outputKey]?.multiple) {
+        const multipleOutput = Array.isArray(rawOutputGroup) ? rawOutputGroup : outputRefs;
+        multipleOutput[boundaryInput] ??= { instanceId: instance.id, output: outputKey };
+        return multipleOutput;
+      }
+      return rawOutputGroup ?? outputRefs[0];
+    });
   } finally {
     if (previousParentInstance) {
       currentInstance = previousParentInstance;
@@ -404,30 +767,14 @@ function registerInstance(component, instance, fn) {
 }
 
 // src/component.ts
-var runtimeSchema = Symbol("runtimeSchema");
 var validationEnabled = true;
 function setValidationEnabled(enabled) {
   validationEnabled = enabled;
 }
-var componentKindSchema = z.enum(["composite", "unit"]);
-var componentArgumentSchema = z.object({
-  /**
-   * The JSON schema of the argument value.
-   */
-  schema: z.custom(),
-  /**
-   * The original Zod schema of the argument.
-   *
-   * Only available at runtime.
-   */
-  [runtimeSchema]: z.instanceof(z.ZodType).optional(),
-  /**
-   * Whether the argument is required.
-   */
-  required: z.boolean(),
-  /**
-   * The extra metadata of the argument.
-   */
+var componentArgumentSchema = z5.object({
+  schema: z5.custom(),
+  [runtimeSchema]: z5.instanceof(z5.ZodType).optional(),
+  required: z5.boolean(),
   meta: objectMetaSchema.required({ title: true }).pick({
     title: true,
     globalTitle: true,
@@ -437,51 +784,22 @@ var componentArgumentSchema = z.object({
     iconColor: true
   })
 });
-var componentInputSchema = z.object({
-  /**
-   * The type of the entity passed through the input.
-   */
+var componentInputSchema = z5.object({
   type: versionedNameSchema,
-  /**
-   * Whether the input is required.
-   */
-  required: z.boolean(),
-  /**
-   * Whether the input can have multiple values.
-   */
-  multiple: z.boolean(),
-  /**
-   * The extra metadata of the input.
-   */
+  fromInput: fieldNameSchema.optional(),
+  required: z5.boolean(),
+  multiple: z5.boolean(),
   meta: objectMetaSchema.required({ title: true }).pick({
     title: true,
     description: true
   })
 });
-var componentModelSchema = z.object({
-  /**
-   * The type of the component.
-   */
+var componentModelSchema = z5.object({
   type: genericNameSchema,
-  /**
-   * The kind of the component.
-   */
   kind: componentKindSchema,
-  /**
-   * The record of the argument schemas.
-   */
-  args: z.record(fieldNameSchema, componentArgumentSchema),
-  /**
-   * The record of the input schemas.
-   */
-  inputs: z.record(fieldNameSchema, componentInputSchema),
-  /**
-   * The record of the output schemas.
-   */
-  outputs: z.record(fieldNameSchema, componentInputSchema),
-  /**
-   * The extra metadata of the component.
-   */
+  args: z5.record(fieldNameSchema, componentArgumentSchema),
+  inputs: z5.record(fieldNameSchema, componentInputSchema),
+  outputs: z5.record(fieldNameSchema, componentInputSchema),
   meta: objectMetaSchema.required({ title: true }).pick({
     title: true,
     description: true,
@@ -491,26 +809,12 @@ var componentModelSchema = z.object({
     secondaryIcon: true,
     secondaryIconColor: true
   }).extend({
-    /**
-     * The category of the component.
-     *
-     * Used to group components in the UI.
-     */
-    category: z.string().optional(),
-    /**
-     * The default name prefix for the component instances.
-     *
-     * Used to generate default names for the instances.
-     */
-    defaultNamePrefix: z.string()
+    category: z5.string().optional(),
+    defaultNamePrefix: z5.string()
   }),
-  /**
-   * The CRC32 of the component definition.
-   */
-  definitionHash: z.number()
+  definitionHash: z5.number()
 });
 var originalCreate = Symbol("originalCreate");
-var kind = Symbol("kind");
 function defineComponent(options) {
   try {
     componentModelSchema.shape.type.parse(options.type);
@@ -520,20 +824,20 @@ function defineComponent(options) {
   if (!options.create) {
     throw new Error("Component create function is required");
   }
-  const entities = /* @__PURE__ */ new Map();
+  const entities = new Map;
   const mapInput = createInputMapper(entities);
+  const mapOutput = createOutputMapper(options.inputs, entities);
   const model = {
     type: options.type,
     kind: options[kind] ?? "composite",
-    args: mapValues(options.args ?? {}, mapArgument),
-    inputs: mapValues(options.inputs ?? {}, mapInput),
-    outputs: mapValues(options.outputs ?? {}, mapInput),
+    args: mapValues2(options.args ?? {}, mapArgument),
+    inputs: mapValues2(options.inputs ?? {}, mapInput),
+    outputs: mapValues2(options.outputs ?? {}, mapOutput),
     meta: {
       ...options.meta,
       title: options.meta?.title || camelCaseToHumanReadable(parseVersionedName(options.type)[0]),
       defaultNamePrefix: options.meta?.defaultNamePrefix || parseVersionedName(options.type)[0].split(".").slice(-1)[0]
     },
-    // will be calculated by library loader
     definitionHash: null
   };
   function create(params) {
@@ -541,64 +845,110 @@ function defineComponent(options) {
     const instanceId = getInstanceId(options.type, name);
     const flatInputs = {};
     const tracedInputs = {};
+    const runtimeInputKey = (input) => {
+      if (input.provided) {
+        return inputKey(input);
+      }
+      return `missing:${input[boundaryInput].instanceId}:${input[boundaryInput].output}`;
+    };
     for (const [key, inputGroup] of Object.entries(inputs ?? {})) {
+      if (!(key in model.inputs)) {
+        continue;
+      }
       if (!inputGroup) {
         continue;
       }
       if (!Array.isArray(inputGroup)) {
-        if (inputGroup[boundaryInput]) {
-          tracedInputs[key] = [inputGroup[boundaryInput]];
-        }
-        flatInputs[key] = [inputGroup];
+        const normalizedInput = normalizeIncomingInput(inputGroup, key);
+        tracedInputs[key] = [normalizedInput[boundaryInput]];
+        flatInputs[key] = [normalizedInput];
         continue;
       }
-      const group = [...inputGroup[boundaryInputs] ?? []];
-      const inputs2 = [];
-      for (const item of inputGroup.flat(1)) {
-        if (item[boundaryInput]) {
-          group.push(item[boundaryInput]);
-        }
-        inputs2.push(item);
-      }
+      const { group, inputs: inputs2 } = normalizeIncomingInputGroup(inputGroup, key);
       tracedInputs[key] = uniqueBy(group, inputKey);
-      flatInputs[key] = uniqueBy(inputs2, inputKey);
+      flatInputs[key] = uniqueBy(inputs2, runtimeInputKey);
     }
-    return registerInstance(
-      create,
-      {
+    return registerInstance(create, {
+      id: instanceId,
+      type: options.type,
+      kind: options[kind] ?? "composite",
+      name,
+      args,
+      inputs: tracedInputs,
+      resolvedInputs: mapValues2(flatInputs, (inputs2) => {
+        return inputs2.filter((input) => input.provided).map((input) => ({
+          instanceId: input.instanceId,
+          output: input.output,
+          ...input.path ? { path: input.path } : {}
+        }));
+      })
+    }, () => {
+      const markedInputs = mapValues2(model.inputs, (componentInput, key) => {
+        if (!componentInput.multiple) {
+          const input = flatInputs[key]?.[0];
+          if (input?.provided) {
+            return createDeepOutputAccessor({
+              ...input,
+              [boundaryInput]: { instanceId, output: key }
+            });
+          }
+          return createNonProvidedInput({ instanceId, output: key });
+        }
+        const inputs2 = (flatInputs[key] ?? []).filter(isProvidedRuntimeInput).map((input) => createDeepOutputAccessor({
+          ...input,
+          [boundaryInput]: { instanceId, output: key }
+        }));
+        const multipleBoundary = { instanceId, output: key };
+        return createMultipleInputAccessor(inputs2, multipleBoundary);
+      });
+      const outputs = options.create({
         id: instanceId,
-        type: options.type,
-        kind: options[kind] ?? "composite",
         name,
-        args,
-        inputs: tracedInputs,
-        resolvedInputs: mapValues(
-          flatInputs,
-          (inputs2) => inputs2.filter((input) => !("provided" in input && input.provided === false))
-        )
-      },
-      () => {
-        const markedInputs = mapValues(model.inputs, (componentInput, key) => {
-          if (!componentInput.multiple) {
-            const input = flatInputs[key]?.[0];
-            if (input) {
-              return { ...input, [boundaryInput]: { instanceId, output: key } };
+        args: processArgs(instanceId, create.model, args),
+        inputs: markedInputs
+      }) ?? {};
+      const normalizedOutputs = normalizeCreateOutputs(outputs, model, instanceId);
+      return withDeepOutputAccessors(normalizedOutputs, model, instanceId);
+    });
+    function normalizeIncomingInput(input, inputName) {
+      if (isStableInstanceInput2(input)) {
+        return createInput(input);
+      }
+      const runtimeInput = input;
+      if (runtimeInput.provided) {
+        const inputBoundary = runtimeInput[boundaryInput] ?? {
+          instanceId: runtimeInput.instanceId,
+          output: runtimeInput.output,
+          ...runtimeInput.path ? { path: runtimeInput.path } : {}
+        };
+        return createInput(runtimeInput, { boundary: inputBoundary });
+      }
+      return createNonProvidedInput(runtimeInput[boundaryInput] ?? { instanceId, output: inputName });
+    }
+    function normalizeIncomingInputGroup(inputGroup, inputName) {
+      const group = [];
+      const inputs2 = [];
+      const visit = (value) => {
+        if (Array.isArray(value)) {
+          const arrayBoundary = value[boundaryInput];
+          if (arrayBoundary) {
+            group.push(arrayBoundary);
+          }
+          for (const item of value) {
+            if (!item) {
+              continue;
             }
-            return { provided: false, [boundaryInput]: { instanceId, output: key } };
+            visit(item);
           }
-          const inputs2 = flatInputs[key] ?? [];
-          inputs2[boundaryInputs] = [{ instanceId, output: key }];
-          return inputs2;
-        });
-        const outputs = options.create({
-          id: instanceId,
-          name,
-          args: processArgs(instanceId, create.model, args),
-          inputs: markedInputs
-        }) ?? {};
-        return mapValues(pickBy(outputs, isNonNullish), (outputs2) => [outputs2].flat(2));
-      }
-    );
+          return;
+        }
+        const normalizedInput = normalizeIncomingInput(value, inputName);
+        group.push(normalizedInput[boundaryInput]);
+        inputs2.push(normalizedInput);
+      };
+      visit(inputGroup);
+      return { group, inputs: inputs2 };
+    }
   }
   try {
     create.entities = entities;
@@ -618,9 +968,7 @@ function processArgs(instanceId, model, args) {
     if (arg.schema) {
       const result = arg[runtimeSchema].safeParse(args[key]);
       if (!result.success) {
-        throw new Error(
-          `Invalid argument "${key}" in instance "${instanceId}": ${result.error.message}`
-        );
+        throw new Error(`Invalid argument "${key}" in instance "${instanceId}": ${result.error.message}`);
       }
       validatedArgs[key] = result.data;
     } else {
@@ -629,16 +977,92 @@ function processArgs(instanceId, model, args) {
   }
   return validatedArgs;
 }
+function withDeepOutputAccessors(outputs, model, instanceId) {
+  return mapValues2(outputs, (outputGroup, outputName) => {
+    const outputSpec = model.outputs[outputName];
+    if (!outputSpec) {
+      return outputGroup[0];
+    }
+    const normalizedOutputs = outputGroup.map((output) => createDeepOutputAccessor(output));
+    if (outputSpec.multiple) {
+      return createMultipleInputAccessor(normalizedOutputs, {
+        instanceId,
+        output: outputName
+      });
+    }
+    return normalizedOutputs[0];
+  });
+}
+function isProvidedRuntimeInput(input) {
+  return input.provided;
+}
+function normalizeCreateOutputGroup(outputGroup, instanceId, outputName) {
+  return [outputGroup].flat(2).filter(isNonNullish).map((output) => {
+    if (isStableInstanceInput2(output)) {
+      return createInput(output);
+    }
+    const runtimeOutput = output;
+    if (runtimeOutput.provided) {
+      const stableBoundary = runtimeOutput[boundaryInput] ?? {
+        instanceId: runtimeOutput.instanceId,
+        output: runtimeOutput.output,
+        ...runtimeOutput.path ? { path: runtimeOutput.path } : {}
+      };
+      return createInput(runtimeOutput, { boundary: stableBoundary });
+    }
+    return createNonProvidedInput(runtimeOutput[boundaryInput] ?? { instanceId, output: outputName });
+  });
+}
+function normalizeCreateOutputs(outputs, model, instanceId) {
+  const normalizedOutputs = {};
+  for (const [outputName, outputSpec] of Object.entries(model.outputs)) {
+    const outputGroup = outputs[outputName];
+    if (!isNonNullish(outputGroup)) {
+      if (model.kind === "unit") {
+        throw new Error(`Unit output "${outputName}" in instance "${instanceId}" must be provided`);
+      }
+      normalizedOutputs[outputName] = outputSpec.multiple ? [] : [createNonProvidedInput({ instanceId, output: outputName })];
+      continue;
+    }
+    const normalizedGroup = normalizeCreateOutputGroup(outputGroup, instanceId, outputName);
+    if (outputSpec.multiple && normalizedGroup.some((output) => !output.provided)) {
+      throw new Error(`Multiple output "${outputName}" in instance "${instanceId}" cannot contain non-provided items`);
+    }
+    if (model.kind === "unit") {
+      if (normalizedGroup.length === 0 || normalizedGroup.some((output) => !output.provided)) {
+        throw new Error(`Unit output "${outputName}" in instance "${instanceId}" must be provided`);
+      }
+    }
+    normalizedOutputs[outputName] = outputSpec.multiple || normalizedGroup.length > 0 ? normalizedGroup : [createNonProvidedInput({ instanceId, output: outputName })];
+  }
+  for (const [outputName, outputGroup] of Object.entries(pickBy(outputs, isNonNullish))) {
+    if (!(outputName in model.outputs) || outputName in normalizedOutputs) {
+      continue;
+    }
+    normalizedOutputs[outputName] = normalizeCreateOutputGroup(outputGroup, instanceId, outputName);
+  }
+  return normalizedOutputs;
+}
+function isStableInstanceInput2(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if ("provided" in value) {
+    return false;
+  }
+  const input = value;
+  return typeof input.instanceId === "string" && typeof input.output === "string";
+}
 function isComponent(value) {
   return typeof value === "function" && "model" in value;
 }
 function isSchemaOptional(schema) {
-  return schema.safeParse(void 0).success;
+  return schema.safeParse(undefined).success;
 }
 function mapArgument(value, key) {
   if ("schema" in value) {
     return {
-      schema: z.toJSONSchema(value.schema, {
+      schema: z5.toJSONSchema(value.schema, {
         target: "draft-7",
         io: "input",
         unrepresentable: "any"
@@ -652,7 +1076,7 @@ function mapArgument(value, key) {
     };
   }
   return {
-    schema: z.toJSONSchema(value, { target: "draft-7", io: "input", unrepresentable: "any" }),
+    schema: z5.toJSONSchema(value, { target: "draft-7", io: "input", unrepresentable: "any" }),
     [runtimeSchema]: value,
     required: !isSchemaOptional(value),
     meta: {
@@ -688,14 +1112,50 @@ function createInputMapper(entities) {
     };
   };
 }
+function isFromInputOutputOptions(value) {
+  return typeof value === "object" && value !== null && "fromInput" in value;
+}
+function createOutputMapper(inputs, entities) {
+  const mapInput = createInputMapper(entities);
+  return (value, key) => {
+    if (!isFromInputOutputOptions(value)) {
+      return mapInput(value, key);
+    }
+    const sourceInput = inputs?.[value.fromInput];
+    if (!sourceInput) {
+      throw new Error(`Output "${key}" references missing input "${value.fromInput}" via fromInput.`);
+    }
+    const mappedInput = mapInput(sourceInput, value.fromInput);
+    return {
+      ...mappedInput,
+      fromInput: value.fromInput,
+      meta: {
+        ...mappedInput.meta,
+        ...value.meta,
+        title: value.meta?.title || camelCaseToHumanReadable(key)
+      }
+    };
+  };
+}
 function getInstanceId(instanceType, instanceName) {
   return `${instanceType}:${instanceName}`;
 }
 function toFullComponentArgumentOptions(args) {
-  return mapValues(args, (arg) => "schema" in arg ? arg : { schema: arg });
+  return mapValues2(args, (arg) => ("schema" in arg) ? arg : { schema: arg });
 }
 function toFullComponentInputOptions(inputs) {
-  return mapValues(inputs, (input) => "entity" in input ? input : { entity: input });
+  return mapValues2(inputs, (input) => ("entity" in input) ? input : { entity: input });
+}
+function toFullComponentOutputOptions(outputs) {
+  return mapValues2(outputs, (output) => {
+    if (typeof output !== "object" || output === null) {
+      return { entity: output };
+    }
+    if ("entity" in output || "fromInput" in output) {
+      return output;
+    }
+    return { entity: output };
+  });
 }
 function $args(args) {
   return toFullComponentArgumentOptions(args);
@@ -704,7 +1164,7 @@ function $inputs(inputs) {
   return toFullComponentInputOptions(inputs);
 }
 function $outputs(outputs) {
-  return toFullComponentInputOptions(outputs);
+  return toFullComponentOutputOptions(outputs);
 }
 function $addArgumentDescription(argument, description) {
   if ("schema" in argument) {
@@ -741,245 +1201,19 @@ function $addInputDescription(input, description) {
   };
 }
 
-// src/instance.ts
-function inputKey(input) {
-  return `${input.instanceId}:${input.output}`;
-}
-var positionSchema = z.object({
-  x: z.number(),
-  y: z.number()
-});
-var instanceIdSchema = z.templateLiteral([versionedNameSchema, ":", genericNameSchema]);
-var instanceInputSchema = z.object({
-  instanceId: instanceIdSchema,
-  output: z.string()
-});
-var hubInputSchema = z.object({
-  hubId: z.string()
-});
-var instanceModelPatchSchema = z.object({
-  /**
-   * The static arguments passed to the instance.
-   */
-  args: z.record(z.string(), z.unknown()).optional(),
-  /**
-   * The direct instances passed as inputs to the instance.
-   */
-  inputs: z.record(z.string(), z.array(instanceInputSchema)).optional(),
-  /**
-   * The resolved unit inputs for the instance.
-   *
-   * Only for computed composite instances.
-   */
-  hubInputs: z.record(z.string(), z.array(hubInputSchema)).optional(),
-  /**
-   * The inputs injected to the instance from the hubs.
-   *
-   * While `hubInputs` allows to pass hubs to distinct inputs,
-   * `injectionInputs` allows to pass hubs to the instance as a whole filling all inputs with matching types.
-   *
-   * Only for designer-first instances.
-   */
-  injectionInputs: z.array(hubInputSchema).optional(),
-  /**
-   * The position of the instance on the canvas.
-   *
-   * Only for designer-first instances.
-   */
-  position: positionSchema.optional()
-});
-var instanceModelSchema = z.object({
-  /**
-   * The id of the instance unique within the project.
-   *
-   * The format is `${instanceType}:${instanceName}`.
-   */
-  id: instanceIdSchema,
-  /**
-   * The kind of the instance.
-   *
-   * Can be either "unit" or "composite".
-   */
-  kind: componentKindSchema,
-  /**
-   * The type of the instance.
-   */
-  type: versionedNameSchema,
-  /**
-   * The name of the instance.
-   *
-   * Must be unique within instances of the same type in the project.
-   */
-  name: genericNameSchema,
-  ...instanceModelPatchSchema.shape,
-  /**
-   * The id of the top level parent instance.
-   *
-   * Only for child instances of the composite instances.
-   */
-  resolvedInputs: z.record(z.string(), z.array(instanceInputSchema)).optional(),
-  /**
-   * The ID of the parent instance.
-   *
-   * Only for child instances of the composite instances.
-   */
-  parentId: instanceIdSchema.optional(),
-  /**
-   * The direct instance outputs returned by the instance as outputs.
-   *
-   * Only for computed composite instances.
-   */
-  outputs: z.record(z.string(), z.array(instanceInputSchema)).optional(),
-  /**
-   * The resolved unit outputs for the instance.
-   *
-   * Only for computed composite instances.
-   */
-  resolvedOutputs: z.record(z.string(), z.array(instanceInputSchema)).optional()
-});
-var hubModelPatchSchema = z.object({
-  /**
-   * The position of the hub on the canvas.
-   */
-  position: positionSchema.optional(),
-  /**
-   * The inputs of the hub.
-   */
-  inputs: z.array(instanceInputSchema).optional(),
-  /**
-   * The inputs injected to the hub from the hubs.
-   *
-   * While `inputs` allows to pass hubs to distinct inputs,
-   * `injectionInputs` allows to pass hubs to the hub as a whole filling all inputs with matching types.
-   */
-  injectionInputs: z.array(hubInputSchema).optional()
-});
-var hubModelSchema = z.object({
-  /**
-   * The id of the hub unique within the project.
-   */
-  id: z.cuid2(),
-  ...hubModelPatchSchema.shape
-});
-function parseInstanceId(instanceId) {
-  const parts = instanceId.split(":");
-  if (parts.length !== 2) {
-    throw new Error(`Invalid instance ID: ${instanceId}`);
-  }
-  return parts;
-}
-function findInput(inputs, name) {
-  const matchedInputs = inputs.filter(
-    (input) => parseInstanceId(input.instanceId)[1] === name || input.instanceId === name
-  );
-  if (matchedInputs.length === 0) {
-    return null;
-  }
-  if (matchedInputs.length > 1) {
-    throw new Error(
-      `Multiple inputs found for "${name}": ${matchedInputs.map((input) => input.instanceId).join(", ")}. Specify the full instance id to disambiguate.`
-    );
-  }
-  return matchedInputs[0];
-}
-function findRequiredInput(inputs, name) {
-  const input = findInput(inputs, name);
-  if (input === null) {
-    throw new Error(`Required input "${name}" not found.`);
-  }
-  return input;
-}
-function findInputs(inputs, names) {
-  return names.map((name) => findInput(inputs, name)).filter(Boolean);
-}
-function findRequiredInputs(inputs, names) {
-  return names.map((name) => findRequiredInput(inputs, name));
-}
-var HighstateSignature = /* @__PURE__ */ ((HighstateSignature2) => {
-  HighstateSignature2["Artifact"] = "d55c63ac-3174-4756-808f-f778e99af0d1";
-  HighstateSignature2["Yaml"] = "c857cac5-caa6-4421-b82c-e561fbce6367";
-  HighstateSignature2["Id"] = "348d020e-0d9e-4ae7-9415-b91af99f5339";
-  HighstateSignature2["Ref"] = "6d7f9da0-9cb6-496d-b72e-cf85ee4d9cf8";
-  return HighstateSignature2;
-})(HighstateSignature || {});
-var yamlValueSchema = z.object({
-  ["c857cac5-caa6-4421-b82c-e561fbce6367" /* Yaml */]: z.literal(true),
-  value: z.string()
-});
-var objectWithIdSchema = z.object({
-  ["348d020e-0d9e-4ae7-9415-b91af99f5339" /* Id */]: z.literal(true),
-  id: z.number(),
-  value: z.unknown()
-});
-var objectRefSchema = z.object({
-  ["6d7f9da0-9cb6-496d-b72e-cf85ee4d9cf8" /* Ref */]: z.literal(true),
-  id: z.number()
-});
-var fileMetaSchema = z.object({
-  name: z.string(),
-  contentType: z.string().optional(),
-  size: z.number().optional(),
-  mode: z.number().optional()
-});
-var WellKnownInstanceCustomStatus = /* @__PURE__ */ ((WellKnownInstanceCustomStatus2) => {
-  WellKnownInstanceCustomStatus2["Healthy"] = "healthy";
-  WellKnownInstanceCustomStatus2["Degraded"] = "degraded";
-  WellKnownInstanceCustomStatus2["Down"] = "down";
-  WellKnownInstanceCustomStatus2["Warning"] = "warning";
-  WellKnownInstanceCustomStatus2["Progressing"] = "progressing";
-  WellKnownInstanceCustomStatus2["Error"] = "error";
-  return WellKnownInstanceCustomStatus2;
-})(WellKnownInstanceCustomStatus || {});
-var instanceStatusFieldValueSchema = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.string().array()
-]);
-var instanceStatusFieldSchema = z.object({
-  name: z.string(),
-  meta: objectMetaSchema.pick({
-    title: true,
-    icon: true,
-    iconColor: true
-  }).required({ title: true }),
-  complementaryTo: z.string().optional(),
-  value: instanceStatusFieldValueSchema.optional()
-});
+// src/unit.ts
 var componentSecretSchema = componentArgumentSchema.extend({
-  /**
-   * The secret cannot be modified by the user, but can be modified by the unit.
-   */
-  readonly: z.boolean(),
-  /**
-   * The secret value is computed by the unit and should not be passed to it when invoked.
-   */
-  computed: z.boolean()
+  readonly: z6.boolean(),
+  computed: z6.boolean()
 });
-var unitSourceSchema = z.object({
-  /**
-   * The package where the unit implementation is located.
-   *
-   * May be both: local monorepo package or a remote NPM package.
-   */
-  package: z.string(),
-  /**
-   * The path to the unit implementation within the package.
-   *
-   * If not provided, the root of the package is assumed.
-   */
-  path: z.string().optional()
+var unitSourceSchema = z6.object({
+  package: z6.string(),
+  path: z6.string().optional()
 });
-var unitModelSchema = z.object({
+var unitModelSchema = z6.object({
   ...componentModelSchema.shape,
-  /**
-   * The source of the unit.
-   */
   source: unitSourceSchema,
-  /**
-   * The record of the secret specs.
-   */
-  secrets: z.record(z.string(), componentSecretSchema)
+  secrets: z6.record(z6.string(), componentSecretSchema)
 });
 function defineUnit(options) {
   if (!options.source) {
@@ -991,19 +1225,22 @@ function defineUnit(options) {
     create({ id }) {
       const outputs = {};
       for (const key in options.outputs ?? {}) {
-        outputs[key] = [
-          {
+        outputs[key] = {
+          provided: true,
+          instanceId: id,
+          output: key,
+          [boundaryInput]: {
             instanceId: id,
             output: key
           }
-        ];
+        };
       }
       return outputs;
     }
   });
   try {
     component.model.source = options.source ?? {};
-    component.model.secrets = mapValues(options.secrets ?? {}, mapSecret);
+    component.model.secrets = mapValues3(options.secrets ?? {}, mapSecret);
   } catch (error) {
     throw new Error(`Failed to map secrets for unit "${options.type}"`, { cause: error });
   }
@@ -1029,13 +1266,22 @@ function mapSecret(value, key) {
 function isUnitModel(model) {
   return "source" in model;
 }
-var triggerSpecSchema = z.union([
-  z.object({
-    type: z.literal("before-destroy")
+// src/terminal.ts
+import { z as z9 } from "zod";
+
+// src/pulumi.ts
+import { parse } from "yaml";
+import { z as z8 } from "zod";
+
+// src/trigger.ts
+import { z as z7 } from "zod";
+var triggerSpecSchema = z7.union([
+  z7.object({
+    type: z7.literal("before-destroy")
   })
 ]);
-var unitTriggerSchema = z.object({
-  name: z.string(),
+var unitTriggerSchema = z7.object({
+  name: z7.string(),
   meta: objectMetaSchema.pick({
     title: true,
     globalTitle: true,
@@ -1043,140 +1289,85 @@ var unitTriggerSchema = z.object({
     icon: true,
     iconColor: true
   }).required({ title: true }),
-  /**
-   * The specification of the trigger.
-   *
-   * Defines the type of trigger and its behavior.
-   */
   spec: triggerSpecSchema
 });
-var triggerInvocationSchema = z.object({
-  /**
-   * The name of the trigger being invoked.
-   */
-  name: z.string()
+var triggerInvocationSchema = z7.object({
+  name: z7.string()
 });
 
 // src/pulumi.ts
-var unitInputReference = z.object({
-  ...instanceInputSchema.shape,
-  /**
-   * The resolved inclusion needed to extract the input value.
-   */
-  inclusion: entityInclusionSchema.optional()
+var unitInputSourceSchema = z8.object({
+  ...instanceInputSchema.shape
+});
+var unitInputValueSchema = z8.object({
+  value: z8.unknown(),
+  source: unitInputSourceSchema.optional()
 });
-var unitConfigSchema = z.object({
-  /**
-   * The ID of the instance.
-   */
-  instanceId: z.string(),
-  /**
-   * The record of argument values for the unit.
-   */
-  args: z.record(z.string(), z.unknown()),
-  /**
-   * The record of input references for the unit.
-   */
-  inputs: z.record(z.string(), unitInputReference.array()),
-  /**
-   * The list of triggers that have been invoked for this unit.
-   */
+var unitConfigSchema = z8.object({
+  instanceId: z8.string(),
+  stateId: z8.string(),
+  args: z8.record(z8.string(), z8.unknown()),
+  inputs: z8.record(z8.string(), unitInputValueSchema.array()),
   invokedTriggers: triggerInvocationSchema.array(),
-  /**
-   * The list of secret names that exists and provided to the unit.
-   */
-  secretNames: z.string().array(),
-  /**
-   * The map of instance ID to state ID in order to resolve instance references.
-   */
-  stateIdMap: z.record(instanceIdSchema, z.string()),
-  /**
-   * The base path for imports.
-   * Used to resolve dynamic dependencies in strict environments (like in pnpm node_modules isolation).
-   */
-  importBasePath: z.string()
+  secretValues: z8.record(z8.string(), z8.unknown()),
+  importBasePath: z8.string()
 });
-var yamlResultCache = /* @__PURE__ */ new WeakMap();
+var yamlResultCache = new WeakMap;
 function parseArgumentValue(value) {
   const yamlResult = yamlValueSchema.safeParse(value);
   if (!yamlResult.success) {
     return value;
   }
   const existingResult = yamlResultCache.get(value);
-  if (existingResult !== void 0) {
+  if (existingResult !== undefined) {
     return existingResult;
   }
   const result = parse(yamlResult.data.value);
   yamlResultCache.set(value, result);
   return result;
 }
-var HighstateConfigKey = /* @__PURE__ */ ((HighstateConfigKey2) => {
+var HighstateConfigKey;
+((HighstateConfigKey2) => {
   HighstateConfigKey2["Config"] = "highstate";
-  HighstateConfigKey2["Secrets"] = "highstate.secrets";
-  return HighstateConfigKey2;
-})(HighstateConfigKey || {});
+})(HighstateConfigKey ||= {});
 var unitArtifactId = Symbol("unitArtifactId");
-var unitArtifactSchema = z.object({
-  ["d55c63ac-3174-4756-808f-f778e99af0d1" /* Artifact */]: z.literal(true),
-  // only for internal use
-  [unitArtifactId]: z.string().optional(),
-  hash: z.string(),
+var unitArtifactSchema = z8.object({
+  ["d55c63ac-3174-4756-808f-f778e99af0d1" /* Artifact */]: z8.literal(true),
+  [unitArtifactId]: z8.string().optional(),
+  hash: z8.string(),
   meta: commonObjectMetaSchema.optional()
 });
-var fileContentSchema = z.union([
-  z.object({
-    type: z.literal("embedded"),
-    /**
-     * Whether the content is binary or not.
-     *
-     * If true, the `value` will be a base64 encoded string.
-     */
-    isBinary: z.boolean().optional(),
-    /**
-     * The content of the file.
-     *
-     * If `isBinary` is true, this will be a base64 encoded string.
-     */
-    value: z.string()
+var fileContentSchema = z8.union([
+  z8.object({
+    type: z8.literal("embedded"),
+    isBinary: z8.boolean().optional(),
+    value: z8.string()
+  }),
+  z8.object({
+    type: z8.literal("embedded-secret"),
+    isBinary: z8.boolean().optional(),
+    value: secretSchema(z8.string())
   }),
-  z.object({
-    type: z.literal("artifact"),
+  z8.object({
+    type: z8.literal("artifact"),
     ...unitArtifactSchema.shape
   })
 ]);
-var fileSchema = z.object({
+var fileSchema = z8.object({
   meta: fileMetaSchema,
   content: fileContentSchema
 });
 
 // src/terminal.ts
-var terminalSpecSchema = z.object({
-  /**
-   * The Docker image to run the terminal.
-   */
-  image: z.string(),
-  /**
-   * The command to run in the terminal.
-   */
-  command: z.string().array(),
-  /**
-   * The working directory to run the command in.
-   */
-  cwd: z.string().optional(),
-  /**
-   * The environment variables to set in the terminal.
-   */
-  env: z.record(z.string(), z.string()).optional(),
-  /**
-   * The files to mount in the terminal.
-   *
-   * The key is the path where the file will be mounted,
-   * and the value is the file content or a reference to an artifact.
-   */
-  files: z.record(z.string(), fileSchema).optional()
+var terminalSpecSchema = z9.object({
+  image: z9.string(),
+  command: z9.string().array(),
+  cwd: z9.string().optional(),
+  env: z9.record(z9.string(), z9.string()).optional(),
+  files: z9.record(z9.string(), fileSchema).optional()
 });
-var unitTerminalSchema = z.object({
-  name: z.string(),
+var unitTerminalSchema = z9.object({
+  name: z9.string(),
   meta: objectMetaSchema.pick({
     title: true,
     globalTitle: true,
@@ -1186,24 +1377,26 @@ var unitTerminalSchema = z.object({
   }).required({ title: true }),
   spec: terminalSpecSchema
 });
-var pageBlockSchema = z.union([
-  z.object({
-    type: z.literal("markdown"),
-    content: z.string()
+// src/page.ts
+import { z as z10 } from "zod";
+var pageBlockSchema = z10.union([
+  z10.object({
+    type: z10.literal("markdown"),
+    content: z10.string()
   }),
-  z.object({
-    type: z.literal("qr"),
-    content: z.string(),
-    showContent: z.coerce.boolean(),
-    language: z.string().optional()
+  z10.object({
+    type: z10.literal("qr"),
+    content: z10.string(),
+    showContent: z10.coerce.boolean(),
+    language: z10.string().optional()
   }),
-  z.object({
-    type: z.literal("file"),
+  z10.object({
+    type: z10.literal("file"),
     file: fileSchema
   })
 ]);
-var unitPageSchema = z.object({
-  name: z.string(),
+var unitPageSchema = z10.object({
+  name: z10.string(),
   meta: objectMetaSchema.pick({
     title: true,
     globalTitle: true,
@@ -1213,347 +1406,49 @@ var unitPageSchema = z.object({
   }).required({ title: true }),
   content: pageBlockSchema.array()
 });
-var unitWorkerSchema = z.object({
-  name: z.string(),
-  image: z.string(),
-  params: z.record(z.string(), z.unknown())
+// src/worker.ts
+import { z as z11 } from "zod";
+var unitWorkerSchema = z11.object({
+  name: z11.string(),
+  image: z11.string(),
+  params: z11.record(z11.string(), z11.unknown())
 });
-var workerRunOptionsSchema = z.object({
-  /**
-   * The ID of the project for which the worker is running.
-   */
-  projectId: z.cuid2(),
-  /**
-   * The ID of the worker version.
-   */
-  workerVersionId: z.cuid2(),
-  /**
-   * The URL of the backend API to connect to.
-   */
-  apiUrl: z.url(),
-  /**
-   * The API key used to authenticate the worker with the backend.
-   */
-  apiKey: z.string()
+var workerRunOptionsSchema = z11.object({
+  projectId: z11.cuid2(),
+  workerVersionId: z11.cuid2(),
+  apiUrl: z11.url(),
+  apiKey: z11.string()
 });
-function compact(value) {
-  const counts = /* @__PURE__ */ new WeakMap();
-  const cyclic = /* @__PURE__ */ new WeakSet();
-  const expanded = /* @__PURE__ */ new WeakSet();
-  const inStack = /* @__PURE__ */ new WeakSet();
-  const stack = [];
-  function countIdentities(current) {
-    if (current === null || typeof current !== "object") {
-      return;
-    }
-    counts.set(current, (counts.get(current) ?? 0) + 1);
-    if (inStack.has(current)) {
-      cyclic.add(current);
-      for (const entry of stack) {
-        cyclic.add(entry);
-      }
-      return;
-    }
-    if (expanded.has(current)) {
-      return;
-    }
-    expanded.add(current);
-    inStack.add(current);
-    stack.push(current);
-    if (Array.isArray(current)) {
-      try {
-        for (const item of current) {
-          countIdentities(item);
-        }
-        return;
-      } finally {
-        stack.pop();
-        inStack.delete(current);
-      }
-    }
-    try {
-      for (const entryValue of Object.values(current)) {
-        countIdentities(entryValue);
-      }
-    } finally {
-      stack.pop();
-      inStack.delete(current);
-    }
-  }
-  countIdentities(value);
-  const ids = /* @__PURE__ */ new WeakMap();
-  const definitionSites = /* @__PURE__ */ new WeakMap();
-  let nextId = 1;
-  function ensureId(current) {
-    const existing = ids.get(current);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const allocated = nextId;
-    nextId += 1;
-    ids.set(current, allocated);
-    return allocated;
-  }
-  function assignDefinitionSitesBfs(root) {
-    if (root === null || typeof root !== "object") {
-      return;
-    }
-    const queue = [];
-    const expandedQueue = /* @__PURE__ */ new WeakSet();
-    if (Array.isArray(root)) {
-      for (let index = 0; index < root.length; index += 1) {
-        queue.push({ parent: root, key: index, value: root[index] });
-      }
-    } else {
-      for (const [key, entryValue] of Object.entries(root)) {
-        queue.push({ parent: root, key, value: entryValue });
-      }
-    }
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (current === void 0) {
-        continue;
-      }
-      if (current.value === null || typeof current.value !== "object") {
-        continue;
-      }
-      const occurrences = counts.get(current.value) ?? 0;
-      if (occurrences > 1 && definitionSites.get(current.value) === void 0) {
-        definitionSites.set(current.value, { parent: current.parent, key: current.key });
-        ensureId(current.value);
-      }
-      if (expandedQueue.has(current.value)) {
-        continue;
-      }
-      expandedQueue.add(current.value);
-      if (Array.isArray(current.value)) {
-        for (let index = 0; index < current.value.length; index += 1) {
-          queue.push({ parent: current.value, key: index, value: current.value[index] });
-        }
-        continue;
-      }
-      for (const [key, entryValue] of Object.entries(current.value)) {
-        queue.push({ parent: current.value, key, value: entryValue });
-      }
-    }
-  }
-  assignDefinitionSitesBfs(value);
-  const emitted = /* @__PURE__ */ new WeakSet();
-  function buildTreeChildren(current, rootOfIdValue) {
-    if (Array.isArray(current)) {
-      return current.map((item) => buildTree(item, rootOfIdValue));
-    }
-    return mapValues(current, (entryValue) => buildTree(entryValue, rootOfIdValue));
-  }
-  function buildTree(current, rootOfIdValue) {
-    if (current === null || typeof current !== "object") {
-      return current;
-    }
-    if (rootOfIdValue !== void 0 && emitted.has(current)) {
-      const id = ids.get(current);
-      if (id === void 0) {
-        throw new Error("Compaction invariant violation: missing id for repeated object");
-      }
-      return {
-        ["6d7f9da0-9cb6-496d-b72e-cf85ee4d9cf8" /* Ref */]: true,
-        id
-      };
-    }
-    if (rootOfIdValue !== void 0 && cyclic.has(current) && !emitted.has(current)) {
-      const id = ensureId(current);
-      emitted.add(current);
-      return {
-        ["348d020e-0d9e-4ae7-9415-b91af99f5339" /* Id */]: true,
-        id,
-        value: buildTreeChildren(current, current)
-      };
-    }
-    return buildTreeChildren(current, rootOfIdValue);
-  }
-  function buildAt(parent, key, current) {
-    if (current === null || typeof current !== "object") {
-      return current;
-    }
-    const occurrences = counts.get(current) ?? 0;
-    if (occurrences <= 1) {
-      if (Array.isArray(current)) {
-        return current.map((item, index) => buildAt(current, index, item));
-      }
-      return mapValues(current, (entryValue, entryKey) => buildAt(current, entryKey, entryValue));
-    }
-    const site = definitionSites.get(current);
-    const shouldDefineHere = site?.parent === parent && site.key === key;
-    const id = ids.get(current);
-    if (id === void 0) {
-      throw new Error("Compaction invariant violation: missing id for repeated object");
-    }
-    if (!shouldDefineHere || emitted.has(current)) {
-      return {
-        ["6d7f9da0-9cb6-496d-b72e-cf85ee4d9cf8" /* Ref */]: true,
-        id
-      };
-    }
-    emitted.add(current);
-    return {
-      ["348d020e-0d9e-4ae7-9415-b91af99f5339" /* Id */]: true,
-      id,
-      value: buildTreeChildren(current, current)
-    };
-  }
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  const topLevelOccurrences = counts.get(value) ?? 0;
-  if (topLevelOccurrences > 1) {
-    const id = ensureId(value);
-    emitted.add(value);
-    return {
-      ["348d020e-0d9e-4ae7-9415-b91af99f5339" /* Id */]: true,
-      id,
-      value: buildTreeChildren(value, value)
-    };
-  }
-  if (Array.isArray(value)) {
-    return value.map((item, index) => buildAt(value, index, item));
-  }
-  return mapValues(
-    value,
-    (entryValue, entryKey) => buildAt(value, entryKey, entryValue)
-  );
-}
-function decompact(value) {
-  const rawValuesById = /* @__PURE__ */ new Map();
-  const placeholdersById = /* @__PURE__ */ new Map();
-  function collect(current, visited) {
-    const result = objectWithIdSchema.safeParse(current);
-    if (result.success) {
-      const { id } = result.data;
-      if (rawValuesById.has(id)) {
-        throw new Error(`Duplicate compacted id ${id}`);
-      }
-      rawValuesById.set(id, result.data.value);
-      collect(result.data.value, visited);
-      return;
-    }
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return;
-    }
-    if (visited.has(current)) {
-      return;
-    }
-    visited.add(current);
-    if (Array.isArray(current)) {
-      for (const item of current) {
-        collect(item, visited);
-      }
-      return;
-    }
-    for (const entryValue of Object.values(current)) {
-      collect(entryValue, visited);
-    }
-  }
-  function ensurePlaceholder(id) {
-    const existing = placeholdersById.get(id);
-    if (existing !== void 0) {
-      return existing;
-    }
-    const raw = rawValuesById.get(id);
-    if (raw === void 0) {
-      throw new Error(`Unresolved compacted ref id ${id}`);
-    }
-    let placeholder;
-    if (raw !== null && typeof raw === "object") {
-      placeholder = Array.isArray(raw) ? [] : {};
-    } else {
-      placeholder = raw;
-    }
-    placeholdersById.set(id, placeholder);
-    return placeholder;
-  }
-  function resolve(current) {
-    const refResult = objectRefSchema.safeParse(current);
-    if (refResult.success) {
-      return ensurePlaceholder(refResult.data.id);
-    }
-    const withIdResult = objectWithIdSchema.safeParse(current);
-    if (withIdResult.success) {
-      return ensurePlaceholder(withIdResult.data.id);
-    }
-    if (current === null || current === void 0 || typeof current !== "object") {
-      return current;
-    }
-    if (Array.isArray(current)) {
-      return current.map((item) => resolve(item));
-    }
-    return mapValues(current, (entryValue) => resolve(entryValue));
-  }
-  function fillPlaceholder(id, visitedIds2) {
-    if (visitedIds2.has(id)) {
-      return;
-    }
-    visitedIds2.add(id);
-    const raw = rawValuesById.get(id);
-    if (raw === void 0) {
-      throw new Error(`Unresolved compacted ref id ${id}`);
-    }
-    const placeholder = ensurePlaceholder(id);
-    if (placeholder === null || typeof placeholder !== "object") {
-      return;
-    }
-    if (raw === null || typeof raw !== "object") {
-      throw new Error(`Compaction invariant violation: id ${id} points to non-object value`);
-    }
-    const resolved = resolve(raw);
-    if (Array.isArray(placeholder)) {
-      if (!Array.isArray(resolved)) {
-        throw new Error(`Compaction invariant violation: id ${id} array placeholder mismatch`);
-      }
-      placeholder.length = 0;
-      for (const item of resolved) {
-        placeholder.push(item);
-      }
-      return;
-    }
-    if (Array.isArray(resolved) || resolved === null || typeof resolved !== "object") {
-      throw new Error(`Compaction invariant violation: id ${id} object placeholder mismatch`);
-    }
-    for (const [key, entryValue] of Object.entries(resolved)) {
-      placeholder[key] = entryValue;
-    }
-  }
-  collect(value, /* @__PURE__ */ new WeakSet());
-  for (const id of rawValuesById.keys()) {
-    ensurePlaceholder(id);
-  }
-  const visitedIds = /* @__PURE__ */ new Set();
-  for (const id of rawValuesById.keys()) {
-    fillPlaceholder(id, visitedIds);
-  }
-  return resolve(value);
-}
+// src/utils.ts
+import { isNonNullish as isNonNullish2, pickBy as pickBy2 } from "remeda";
 function text(strings, ...values) {
   const stringValues = values.map(String);
   let result = "";
-  for (let i = 0; i < strings.length; i++) {
+  for (let i = 0;i < strings.length; i++) {
     result += strings[i];
     if (i < stringValues.length) {
       const value = stringValues[i];
-      const lines = value.split("\n");
+      const lines = value.split(`
+`);
       const lastLineIndentMatch = strings[i].match(/(?:^|\n)([ \t]*)$/);
       const indent = lastLineIndentMatch ? lastLineIndentMatch[1] : "";
-      result += lines.map((line, j) => j === 0 ? line : indent + line).join("\n");
+      result += lines.map((line, j) => j === 0 ? line : indent + line).join(`
+`);
     }
   }
   return trimIndentation(result);
 }
 function trimIndentation(text2) {
-  const lines = text2.split("\n");
+  const lines = text2.split(`
+`);
   const indent = lines.filter((line) => line.trim() !== "").map((line) => line.match(/^\s*/)?.[0].length ?? 0).reduce((min, indent2) => Math.min(min, indent2), Infinity);
-  return lines.map((line) => line.slice(indent)).join("\n").trim();
+  return lines.map((line) => line.slice(indent)).join(`
+`).trim();
 }
 function bytesToHumanReadable(bytes) {
   const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
-  if (bytes === 0) return "0 Bytes";
+  if (bytes === 0)
+    return "0 Bytes";
   const i = Math.floor(Math.log(bytes) / Math.log(1024));
   return `${parseFloat((bytes / 1024 ** i).toFixed(2))} ${sizes[i]}`;
 }
@@ -1562,7 +1457,7 @@ function check(schema, value) {
 }
 function getOrCreate(map, key, createFn) {
   const existing = map.get(key);
-  if (existing !== void 0) {
+  if (existing !== undefined) {
     return existing;
   }
   const value = createFn(key);
@@ -1570,9 +1465,100 @@ function getOrCreate(map, key, createFn) {
   return value;
 }
 function stripNullish(obj) {
-  return pickBy(obj, isNonNullish);
+  return pickBy2(obj, isNonNullish2);
 }
 
-export { $addArgumentDescription, $addInputDescription, $args, $inputs, $outputs, $secrets, HighstateConfigKey, HighstateSignature, InstanceNameConflictError, WellKnownInstanceCustomStatus, bytesToHumanReadable, camelCaseToHumanReadable, check, clearKnownAbbreviations, commonObjectMetaSchema, compact, componentArgumentSchema, componentInputSchema, componentModelSchema, componentSecretSchema, decompact, defineComponent, defineEntity, defineUnit, entityModelSchema, fieldNameSchema, fileContentSchema, fileMetaSchema, fileSchema, findInput, findInputs, findRequiredInput, findRequiredInputs, genericNameSchema, getInstanceId, getOrCreate, getRuntimeInstances, globalCommonObjectMetaSchema, hubInputSchema, hubModelPatchSchema, hubModelSchema, inputKey, instanceIdSchema, instanceInputSchema, instanceModelPatchSchema, instanceModelSchema, instanceStatusFieldSchema, instanceStatusFieldValueSchema, isAssignableTo, isComponent, isEntity, isUnitModel, objectMetaSchema, objectRefSchema, objectWithIdSchema, originalCreate, pageBlockSchema, parseArgumentValue, parseInstanceId, parseVersionedName, positionSchema, registerKnownAbbreviations, resetEvaluation, runtimeSchema, serviceAccountMetaSchema, setValidationEnabled, stripNullish, terminalSpecSchema, text, timestampsSchema, triggerInvocationSchema, triggerSpecSchema, trimIndentation, unitArtifactId, unitArtifactSchema, unitConfigSchema, unitInputReference, unitModelSchema, unitPageSchema, unitSourceSchema, unitTerminalSchema, unitTriggerSchema, unitWorkerSchema, versionedNameSchema, workerRunOptionsSchema, yamlValueSchema };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+// src/index.ts
+import { z as z12 } from "zod";
+export {
+  z12 as z,
+  yamlValueSchema,
+  workerRunOptionsSchema,
+  versionedNameSchema,
+  unitWorkerSchema,
+  unitTriggerSchema,
+  unitTerminalSchema,
+  unitSourceSchema,
+  unitPageSchema,
+  unitModelSchema,
+  unitInputValueSchema,
+  unitInputSourceSchema,
+  unitConfigSchema,
+  unitArtifactSchema,
+  unitArtifactId,
+  trimIndentation,
+  triggerSpecSchema,
+  triggerInvocationSchema,
+  timestampsSchema,
+  text,
+  terminalSpecSchema,
+  stripNullish,
+  setValidationEnabled,
+  serviceAccountMetaSchema,
+  selectInput,
+  secretSchema,
+  runtimeSchema,
+  resetEvaluation,
+  registerKnownAbbreviations,
+  positionSchema,
+  parseVersionedName,
+  parseInstanceId,
+  parseArgumentValue,
+  pageBlockSchema,
+  originalCreate,
+  objectMetaSchema,
+  kind,
+  isUnitModel,
+  isSecret,
+  isEntity,
+  isComponent,
+  isAssignableTo,
+  instanceStatusFieldValueSchema,
+  instanceStatusFieldSchema,
+  instanceModelSchema,
+  instanceModelPatchSchema,
+  instanceInputSchema,
+  instanceIdSchema,
+  inputKey,
+  hubModelSchema,
+  hubModelPatchSchema,
+  hubInputSchema,
+  globalCommonObjectMetaSchema,
+  getRuntimeInstances,
+  getOrCreate,
+  getInstanceId,
+  getEntityId,
+  genericNameSchema,
+  fileSchema,
+  fileMetaSchema,
+  fileContentSchema,
+  fieldNameSchema,
+  entityModelSchema,
+  defineUnit,
+  defineEntity,
+  defineComponent,
+  cuidv2d,
+  createNonProvidedInput,
+  createInput,
+  componentSecretSchema,
+  componentModelSchema,
+  componentKindSchema,
+  componentInputSchema,
+  componentArgumentSchema,
+  commonObjectMetaSchema,
+  clearKnownAbbreviations,
+  check,
+  camelCaseToHumanReadable,
+  bytesToHumanReadable,
+  boundaryInput,
+  WellKnownInstanceCustomStatus,
+  InstanceNameConflictError,
+  HighstateSignature,
+  HighstateConfigKey,
+  $secrets,
+  $outputs,
+  $inputs,
+  $args,
+  $addInputDescription,
+  $addArgumentDescription
+};