@highstate/contract 0.19.1 → 0.20.0

package/dist/index.js

@@ -1,9 +1,41 @@
 import { z } from 'zod';
 export { z } from 'zod';
+import { sha256 } from '@noble/hashes/sha2.js';
 import { mapValues, pickBy, isNonNullish, uniqueBy } from 'remeda';
 import { parse } from 'yaml';
 
 // src/entity.ts
+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) - "0".charCodeAt(0);
+    return String.fromCharCode("a".charCodeAt(0) + 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();
@@ -28,6 +60,96 @@ 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 = /* @__PURE__ */ 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 === void 0) {
+              properties[key] = value;
+              continue;
+            }
+            properties[key] = { allOf: [existing, value] };
+          }
+        }
+        if ("additionalProperties" in objectSchema) {
+          if (additionalProperties === void 0) {
+            additionalProperties = objectSchema.additionalProperties;
+          } else if (additionalProperties !== objectSchema.additionalProperties) {
+            additionalProperties = false;
+          }
+        }
+      }
+      const mergedObjectSchema = {
+        type: "object",
+        properties,
+        ...required.size > 0 ? { required: Array.from(required) } : {},
+        ...additionalProperties !== void 0 ? { 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;
+}
 var objectMetaSchema = z.object({
   /**
    * Human-readable name of the object.
@@ -220,7 +342,11 @@ var entityModelSchema = z.object({
   definitionHash: z.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,35 +357,34 @@ function defineEntity(options) {
   if (!options.schema) {
     throw new Error("Entity schema is required");
   }
-  const includedEntities = 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
+  const includeRefs = Object.entries(options.includes ?? {}).map(
+    ([field, entityRef]) => {
+      if (isEntityIncludeRef(entityRef)) {
+        const required = entityRef.required ?? true;
+        const multiple = entityRef.multiple ?? false;
+        let getEntity2;
+        if (typeof entityRef.entity === "function") {
+          const entity = entityRef.entity;
+          getEntity2 = entity;
+        } else {
+          const entity = entityRef.entity;
+          getEntity2 = () => entity;
         }
-      };
-    }
-    return {
-      entity: entityRef,
-      inclusion: {
-        type: entityRef.type,
-        required: true,
-        multiple: false,
-        field
+        return { field, required, multiple, getEntity: getEntity2 };
       }
-    };
-  });
-  const inclusionShape = includedEntities.reduce(
-    (shape, { entity, inclusion }) => {
-      if (inclusion.multiple) {
-        shape[inclusion.field] = inclusion.required ? entity.schema.array() : entity.schema.array().optional();
+      const getEntity = () => entityRef;
+      return { field, required: true, multiple: false, getEntity };
+    }
+  );
+  const inclusionShape = includeRefs.reduce(
+    (shape, includeRef) => {
+      let schema = z.lazy(() => includeRef.getEntity().schema);
+      if (includeRef.multiple) {
+        schema = includeRef.required ? schema.array().min(1) : schema.array().default([]);
       } else {
-        shape[inclusion.field] = inclusion.required ? entity.schema : entity.schema.optional();
+        schema = includeRef.required ? schema : schema.optional();
       }
+      shape[includeRef.field] = schema;
       return shape;
     },
     {}
@@ -268,20 +393,26 @@ function defineEntity(options) {
     (schema, entity) => z.intersection(schema, entity.schema),
     options.schema
   );
-  if (includedEntities.length > 0) {
+  if (includeRefs.length > 0) {
     finalSchema = z.intersection(finalSchema, z.object(inclusionShape));
   }
-  const directInclusions = includedEntities.map(({ inclusion }) => inclusion);
+  finalSchema = z.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;
@@ -295,11 +426,21 @@ function defineEntity(options) {
         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,
+        get inclusions() {
+          const incs = getInclusions();
+          return incs.length > 0 ? incs : void 0;
+        },
+        get directInclusions() {
+          const incs = directInclusions();
+          return incs.length > 0 ? incs : void 0;
+        },
         get schema() {
           if (!_schema) {
-            _schema = z.toJSONSchema(finalSchema, { target: "draft-7", unrepresentable: "any" });
+            const rawSchema = z.toJSONSchema(finalSchema, {
+              target: "draft-7",
+              unrepresentable: "any"
+            });
+            _schema = fixJsonSchema(rawSchema);
           }
           return _schema;
         },
@@ -328,8 +469,51 @@ function isAssignableTo(entity, target) {
   }
   return entity.inclusions?.some((implementation) => implementation.type === target) ?? false;
 }
-var boundaryInput = Symbol("boundaryInput");
-var boundaryInputs = Symbol("boundaryInputs");
+var entityMetaSchema = z.object({
+  /**
+   * The type of the entity.
+   */
+  type: versionedNameSchema,
+  /**
+   * The globally unique identity of the entity.
+   *
+   * Anonymous entities are forbidden.
+   */
+  identity: z.string(),
+  /**
+   * The IDs of the entities to reference by this entity.
+   * Must already exist in the system (or be at least defined by this unit).
+   */
+  references: z.record(z.string(), z.string().array()).optional(),
+  ...objectMetaSchema.pick({
+    title: true,
+    description: true,
+    icon: true,
+    iconColor: true
+  }).shape
+});
+var entityWithMetaSchema = z.object({
+  $meta: entityMetaSchema
+});
+var entityIdCache = /* @__PURE__ */ 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;
+}
+var boundaryInput = /* @__PURE__ */ Symbol("boundaryInput");
+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) {
@@ -383,19 +567,41 @@ function registerInstance(component, instance, fn) {
     currentInstance = instance;
   }
   try {
-    const outputs = fn();
-    instance.resolvedOutputs = outputs;
-    instance.outputs = mapValues(
+    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 ?? {},
-      (outputs2) => outputs2.map((output) => output[boundaryInput] ?? output)
-    );
-    return mapValues(
-      outputs,
-      (outputs2, outputKey) => outputs2.map((output) => ({
-        ...output,
-        [boundaryInput]: { instanceId: instance.id, output: outputKey }
-      }))
+      (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;
@@ -403,8 +609,147 @@ function registerInstance(component, instance, fn) {
   }
 }
 
+// src/instance-input.ts
+function appendInputPath(currentPath, segment) {
+  return currentPath ? `${currentPath}.${segment}` : segment;
+}
+function createRuntimeInputAccessor(input, boundary) {
+  const accessorCache = input.provided ? void 0 : /* @__PURE__ */ 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 === void 0 || 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 = /* @__PURE__ */ 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 !== void 0) {
+        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/component.ts
-var runtimeSchema = Symbol("runtimeSchema");
+var runtimeSchema = /* @__PURE__ */ Symbol("runtimeSchema");
 var validationEnabled = true;
 function setValidationEnabled(enabled) {
   validationEnabled = enabled;
@@ -442,6 +787,12 @@ var componentInputSchema = z.object({
    * The type of the entity passed through the input.
    */
   type: versionedNameSchema,
+  /**
+   * The input name this output type is derived from.
+   *
+   * If set, the output uses the referenced input as its fallback type source.
+   */
+  fromInput: fieldNameSchema.optional(),
   /**
    * Whether the input is required.
    */
@@ -509,8 +860,8 @@ var componentModelSchema = z.object({
    */
   definitionHash: z.number()
 });
-var originalCreate = Symbol("originalCreate");
-var kind = Symbol("kind");
+var originalCreate = /* @__PURE__ */ Symbol("originalCreate");
+var kind = /* @__PURE__ */ Symbol("kind");
 function defineComponent(options) {
   try {
     componentModelSchema.shape.type.parse(options.type);
@@ -522,12 +873,13 @@ function defineComponent(options) {
   }
   const entities = /* @__PURE__ */ 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),
+    outputs: mapValues(options.outputs ?? {}, mapOutput),
     meta: {
       ...options.meta,
       title: options.meta?.title || camelCaseToHumanReadable(parseVersionedName(options.type)[0]),
@@ -541,27 +893,28 @@ 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,
@@ -572,23 +925,34 @@ function defineComponent(options) {
         name,
         args,
         inputs: tracedInputs,
-        resolvedInputs: mapValues(
-          flatInputs,
-          (inputs2) => inputs2.filter((input) => !("provided" in input && input.provided === false))
-        )
+        resolvedInputs: mapValues(flatInputs, (inputs2) => {
+          return inputs2.filter((input) => input.provided).map((input) => ({
+            instanceId: input.instanceId,
+            output: input.output,
+            ...input.path ? { path: input.path } : {}
+          }));
+        })
       },
       () => {
         const markedInputs = mapValues(model.inputs, (componentInput, key) => {
           if (!componentInput.multiple) {
             const input = flatInputs[key]?.[0];
-            if (input) {
-              return { ...input, [boundaryInput]: { instanceId, output: key } };
+            if (input?.provided) {
+              return createDeepOutputAccessor({
+                ...input,
+                [boundaryInput]: { instanceId, output: key }
+              });
             }
-            return { provided: false, [boundaryInput]: { instanceId, output: key } };
+            return createNonProvidedInput({ instanceId, output: key });
           }
-          const inputs2 = flatInputs[key] ?? [];
-          inputs2[boundaryInputs] = [{ instanceId, output: key }];
-          return inputs2;
+          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,
@@ -596,9 +960,51 @@ function defineComponent(options) {
           args: processArgs(instanceId, create.model, args),
           inputs: markedInputs
         }) ?? {};
-        return mapValues(pickBy(outputs, isNonNullish), (outputs2) => [outputs2].flat(2));
+        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;
+            }
+            visit(item);
+          }
+          return;
+        }
+        const normalizedInput = normalizeIncomingInput(value, inputName);
+        group.push(normalizedInput[boundaryInput]);
+        inputs2.push(normalizedInput);
+      };
+      visit(inputGroup);
+      return { group, inputs: inputs2 };
+    }
   }
   try {
     create.entities = entities;
@@ -629,6 +1035,86 @@ function processArgs(instanceId, model, args) {
   }
   return validatedArgs;
 }
+function withDeepOutputAccessors(outputs, model, instanceId) {
+  return mapValues(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;
 }
@@ -688,6 +1174,33 @@ 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}`;
 }
@@ -697,6 +1210,17 @@ function toFullComponentArgumentOptions(args) {
 function toFullComponentInputOptions(inputs) {
   return mapValues(inputs, (input) => "entity" in input ? input : { entity: input });
 }
+function toFullComponentOutputOptions(outputs) {
+  return mapValues(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 +1228,7 @@ function $inputs(inputs) {
   return toFullComponentInputOptions(inputs);
 }
 function $outputs(outputs) {
-  return toFullComponentInputOptions(outputs);
+  return toFullComponentOutputOptions(outputs);
 }
 function $addArgumentDescription(argument, description) {
   if ("schema" in argument) {
@@ -743,7 +1267,7 @@ function $addInputDescription(input, description) {
 
 // src/instance.ts
 function inputKey(input) {
-  return `${input.instanceId}:${input.output}`;
+  return input.path ? `${input.instanceId}:${input.output}:${input.path}` : `${input.instanceId}:${input.output}`;
 }
 var positionSchema = z.object({
   x: z.number(),
@@ -752,7 +1276,8 @@ var positionSchema = z.object({
 var instanceIdSchema = z.templateLiteral([versionedNameSchema, ":", genericNameSchema]);
 var instanceInputSchema = z.object({
   instanceId: instanceIdSchema,
-  output: z.string()
+  output: z.string(),
+  path: z.string().optional()
 });
 var hubInputSchema = z.object({
   hubId: z.string()
@@ -868,53 +1393,38 @@ function parseInstanceId(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) {
+function selectInput(inputs, name) {
+  const groupBoundary = inputs[boundaryInput] ?? inputs[0]?.[boundaryInput];
+  if (inputs.length === 0 && !groupBoundary) {
     throw new Error(
-      `Multiple inputs found for "${name}": ${matchedInputs.map((input) => input.instanceId).join(", ")}. Specify the full instance id to disambiguate.`
+      `Cannot select input "${name}": empty input group has no boundary metadata to build a missing input reference.`
     );
   }
-  return matchedInputs[0];
-}
-function findRequiredInput(inputs, name) {
-  const input = findInput(inputs, name);
-  if (input === null) {
-    throw new Error(`Required input "${name}" not found.`);
+  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);
   }
-  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));
+  const boundary = groupBoundary ?? input[boundaryInput];
+  return createInput(input, { boundary });
 }
 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";
+  HighstateSignature2["Secret"] = "240e5789-6ae4-4b22-b9d8-87169e8b4bab";
   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(),
@@ -946,6 +1456,19 @@ var instanceStatusFieldSchema = z.object({
   complementaryTo: z.string().optional(),
   value: instanceStatusFieldValueSchema.optional()
 });
+function secretSchema(schema) {
+  const secretType = z.object({
+    ["240e5789-6ae4-4b22-b9d8-87169e8b4bab" /* Secret */]: z.literal(true),
+    value: schema
+  });
+  return z.codec(z.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;
+}
 var componentSecretSchema = componentArgumentSchema.extend({
   /**
    * The secret cannot be modified by the user, but can be modified by the unit.
@@ -991,12 +1514,15 @@ 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;
     }
@@ -1058,18 +1584,31 @@ var triggerInvocationSchema = z.object({
 });
 
 // src/pulumi.ts
-var unitInputReference = z.object({
-  ...instanceInputSchema.shape,
+var unitInputSourceSchema = z.object({
+  ...instanceInputSchema.shape
+});
+var unitInputValueSchema = z.object({
   /**
-   * The resolved inclusion needed to extract the input value.
+   * Inline resolved value passed to the unit.
+   *
+   * The backend is responsible for resolving the correct entity snapshot value
+   * and applying any inclusion transformations.
    */
-  inclusion: entityInclusionSchema.optional()
+  value: z.unknown(),
+  /**
+   * Optional provenance of the value.
+   */
+  source: unitInputSourceSchema.optional()
 });
 var unitConfigSchema = z.object({
   /**
    * The ID of the instance.
    */
   instanceId: z.string(),
+  /**
+   * The state ID of the instance.
+   */
+  stateId: z.string(),
   /**
    * The record of argument values for the unit.
    */
@@ -1077,19 +1616,17 @@ var unitConfigSchema = z.object({
   /**
    * The record of input references for the unit.
    */
-  inputs: z.record(z.string(), unitInputReference.array()),
+  inputs: z.record(z.string(), unitInputValueSchema.array()),
   /**
    * The list of triggers that have been invoked for this unit.
    */
   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.
+   * The record of secret values provided to the unit.
+   *
+   * It is stored in Pulumi stack config as a secret.
    */
-  stateIdMap: z.record(instanceIdSchema, z.string()),
+  secretValues: z.record(z.string(), z.unknown()),
   /**
    * The base path for imports.
    * Used to resolve dynamic dependencies in strict environments (like in pnpm node_modules isolation).
@@ -1112,10 +1649,9 @@ function parseArgumentValue(value) {
 }
 var HighstateConfigKey = /* @__PURE__ */ ((HighstateConfigKey2) => {
   HighstateConfigKey2["Config"] = "highstate";
-  HighstateConfigKey2["Secrets"] = "highstate.secrets";
   return HighstateConfigKey2;
 })(HighstateConfigKey || {});
-var unitArtifactId = Symbol("unitArtifactId");
+var unitArtifactId = /* @__PURE__ */ Symbol("unitArtifactId");
 var unitArtifactSchema = z.object({
   ["d55c63ac-3174-4756-808f-f778e99af0d1" /* Artifact */]: z.literal(true),
   // only for internal use
@@ -1139,6 +1675,21 @@ var fileContentSchema = z.union([
      */
     value: z.string()
   }),
+  z.object({
+    type: z.literal("embedded-secret"),
+    /**
+     * 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 wrapped as a Highstate secret.
+     *
+     * If `isBinary` is true, this will be a base64 encoded string.
+     */
+    value: secretSchema(z.string())
+  }),
   z.object({
     type: z.literal("artifact"),
     ...unitArtifactSchema.shape
@@ -1236,301 +1787,6 @@ var workerRunOptionsSchema = z.object({
    */
   apiKey: z.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);
-}
 function text(strings, ...values) {
   const stringValues = values.map(String);
   let result = "";
@@ -1573,6 +1829,6 @@ function stripNullish(obj) {
   return pickBy(obj, isNonNullish);
 }
 
-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 };
+export { $addArgumentDescription, $addInputDescription, $args, $inputs, $outputs, $secrets, HighstateConfigKey, HighstateSignature, InstanceNameConflictError, WellKnownInstanceCustomStatus, bytesToHumanReadable, camelCaseToHumanReadable, check, clearKnownAbbreviations, commonObjectMetaSchema, componentArgumentSchema, componentInputSchema, componentModelSchema, componentSecretSchema, createInput, createNonProvidedInput, cuidv2d, defineComponent, defineEntity, defineUnit, entityModelSchema, fieldNameSchema, fileContentSchema, fileMetaSchema, fileSchema, genericNameSchema, getEntityId, getInstanceId, getOrCreate, getRuntimeInstances, globalCommonObjectMetaSchema, hubInputSchema, hubModelPatchSchema, hubModelSchema, inputKey, instanceIdSchema, instanceInputSchema, instanceModelPatchSchema, instanceModelSchema, instanceStatusFieldSchema, instanceStatusFieldValueSchema, isAssignableTo, isComponent, isEntity, isSecret, isUnitModel, objectMetaSchema, originalCreate, pageBlockSchema, parseArgumentValue, parseInstanceId, parseVersionedName, positionSchema, registerKnownAbbreviations, resetEvaluation, runtimeSchema, secretSchema, selectInput, serviceAccountMetaSchema, setValidationEnabled, stripNullish, terminalSpecSchema, text, timestampsSchema, triggerInvocationSchema, triggerSpecSchema, trimIndentation, unitArtifactId, unitArtifactSchema, unitConfigSchema, unitInputSourceSchema, unitInputValueSchema, unitModelSchema, unitPageSchema, unitSourceSchema, unitTerminalSchema, unitTriggerSchema, unitWorkerSchema, versionedNameSchema, workerRunOptionsSchema, yamlValueSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map