@highstate/contract 0.9.18 → 0.9.20

package/dist/index.js

@@ -1,10 +1,34 @@
 import z5, { z } from 'zod';
 export { z } from 'zod';
-import { mapValues, pickBy, isNonNullish } from 'remeda';
-import { Ajv } from 'ajv';
+import { mapValues, pickBy, isNonNullish, uniqueBy } from 'remeda';
+import { parse } from 'yaml';
 
 // src/entity.ts
-var userObjectMetaSchema = z.object({
+
+// src/i18n.ts
+var knownAbbreviationsMap = /* @__PURE__ */ new Map();
+function registerKnownAbbreviations(abbreviations) {
+  for (const abbr of abbreviations) {
+    const lower = abbr.toLowerCase();
+    if (!knownAbbreviationsMap.has(lower)) {
+      knownAbbreviationsMap.set(lower, abbr);
+    }
+  }
+}
+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);
+  return words.map((word) => {
+    const lower = word.toLowerCase();
+    if (knownAbbreviationsMap.has(lower)) {
+      return knownAbbreviationsMap.get(lower);
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }).join(" ");
+}
+var objectMetaSchema = z.object({
   /**
    * Human-readable name of the object.
    *
@@ -41,6 +65,10 @@ var userObjectMetaSchema = z.object({
    * 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.
    *
@@ -54,56 +82,86 @@ var userObjectMetaSchema = z.object({
    */
   secondaryIconColor: z.string().optional()
 });
-var objectMetaSchema = userObjectMetaSchema.extend({
-  /**
-   * Creation timestamp in milliseconds.
-   *
-   * Managed automatically by the system.
-   */
-  createdAt: z.number().optional(),
+var commonObjectMetaSchema = objectMetaSchema.pick({
+  title: true,
+  description: true,
+  icon: true,
+  iconColor: true
+}).required({
+  title: true
+});
+var globalCommonObjectMetaSchema = objectMetaSchema.pick({
+  title: true,
+  globalTitle: true,
+  description: true,
+  icon: true,
+  iconColor: true
+}).required({
+  title: true
+});
+var serviceAccountMetaSchema = objectMetaSchema.pick({
+  title: true,
+  description: true,
+  avatarUrl: true,
+  icon: true,
+  iconColor: true
+}).required({ title: true });
+var timestampsSchema = z.object({
   /**
-   * Last update timestamp in milliseconds.
-   *
-   * Managed automatically by the system.
+   * The timestamp when the object was created.
    */
-  updatedAt: z.number().optional(),
+  createdAt: z.date(),
   /**
-   * The optional version of the document to support optimistic concurrency control.
-   *
-   * Managed automatically by the system.
+   * The timestamp when the object was last updated.
    */
-  version: z.number().optional()
+  updatedAt: z.date()
 });
 var genericNameSchema = z.string().regex(/^[a-z][a-z0-9-_.]+$/).min(2).max(64);
-var fieldNameSchema = z.string().regex(/^[a-z][a-zA-Z0-9]+$/).min(2).max(64);
-
-// src/i18n.ts
-var knownAbbreviationsMap = /* @__PURE__ */ new Map();
-function registerKnownAbbreviations(abbreviations) {
-  for (const abbr of abbreviations) {
-    const lower = abbr.toLowerCase();
-    if (!knownAbbreviationsMap.has(lower)) {
-      knownAbbreviationsMap.set(lower, abbr);
-    }
+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("."),
+    genericNameSchema,
+    z.literal("."),
+    z.literal("v"),
+    z.number().int().min(1)
+  ]),
+  z.templateLiteral([
+    genericNameSchema,
+    z.literal("."),
+    genericNameSchema,
+    z.literal("."),
+    genericNameSchema,
+    z.literal("."),
+    z.literal("v"),
+    z.number().int().min(1)
+  ])
+]);
+function parseVersionedName(name) {
+  const lastDotVIndex = name.lastIndexOf(".v");
+  if (lastDotVIndex === -1) {
+    throw new Error(`Invalid versioned name: ${name}`);
   }
+  const baseName = name.substring(0, lastDotVIndex);
+  const versionPart = name.substring(lastDotVIndex + 2);
+  const version = parseInt(versionPart, 10);
+  if (Number.isNaN(version) || version < 1) {
+    throw new Error(`Invalid version in versioned name: ${name}`);
+  }
+  return [baseName, version];
 }
-function camelCaseToHumanReadable(text2) {
-  const words = text2.split(/(?=[A-Z])|_|-|\./);
-  return words.map((word) => {
-    const lower = word.toLowerCase();
-    if (knownAbbreviationsMap.has(lower)) {
-      return knownAbbreviationsMap.get(lower);
-    }
-    return word.charAt(0).toUpperCase() + word.slice(1);
-  }).join(" ");
-}
+var fieldNameSchema = z.string().regex(/^[a-z][a-zA-Z0-9]+$/).min(2).max(64);
 
 // src/entity.ts
 var entityModelSchema = z.object({
   /**
    * The static type of the entity.
    */
-  type: z.string(),
+  type: versionedNameSchema,
   /**
    * The JSON schema of the entity value.
    */
@@ -124,8 +182,10 @@ var entityModelSchema = z.object({
   definitionHash: z.number()
 });
 function defineEntity(options) {
-  if (!options.type) {
-    throw new Error("Entity type is required");
+  try {
+    entityModelSchema.shape.type.parse(options.type);
+  } catch (error) {
+    throw new Error(`Invalid entity type "${options.type}"`, { cause: error });
   }
   if (!options.schema) {
     throw new Error("Entity schema is required");
@@ -139,9 +199,9 @@ function defineEntity(options) {
         schema: z.toJSONSchema(options.schema, { target: "draft-7" }),
         meta: {
           ...options.meta,
-          title: options.meta?.title ?? camelCaseToHumanReadable(options.type)
+          title: options.meta?.title || camelCaseToHumanReadable(parseVersionedName(options.type)[0])
         },
-        // will be calculated by the library loader
+        // biome-ignore lint/style/noNonNullAssertion: will be calculated by the library loader
         definitionHash: null
       }
     };
@@ -152,371 +212,159 @@ function defineEntity(options) {
 function isEntity(value) {
   return typeof value === "object" && value !== null && "model" in value;
 }
-var positionSchema = z.object({
-  x: z.number(),
-  y: z.number()
-});
-var instanceIdSchema = z.templateLiteral([genericNameSchema, ":", 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(),
+var boundaryInput = Symbol("boundaryInput");
+var boundaryInputs = Symbol("boundaryInputs");
+function formatInstancePath(instance) {
+  let result = instance.id;
+  while (instance.parentId) {
+    const parent = runtimeInstances.get(instance.parentId)?.instance;
+    if (!parent) {
+      break;
+    }
+    result = `${parent.id} -> ${result}`;
+    instance = parent;
+  }
+  return result;
+}
+var InstanceNameConflictError = class extends Error {
+  constructor(instanceId, firstPath, 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();
+function resetEvaluation() {
+  runtimeInstances.clear();
+  currentInstance = null;
+}
+function getRuntimeInstances() {
+  return Array.from(runtimeInstances.values());
+}
+function registerInstance(component, instance, fn) {
+  const conflicting = runtimeInstances.get(instance.id);
+  if (conflicting) {
+    throw new InstanceNameConflictError(
+      instance.id,
+      formatInstancePath(conflicting.instance),
+      formatInstancePath(instance)
+    );
+  }
+  runtimeInstances.set(instance.id, { instance, component });
+  let previousParentInstance = null;
+  if (currentInstance) {
+    instance.parentId = currentInstance.id;
+  }
+  if (component.model.kind === "composite") {
+    previousParentInstance = currentInstance;
+    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 }
+      }))
+    );
+  } finally {
+    if (previousParentInstance) {
+      currentInstance = previousParentInstance;
+    }
+  }
+}
+
+// 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 direct instances passed as inputs to the instance.
+   * The JSON schema of the argument value.
    */
-  inputs: z.record(z.string(), z.array(instanceInputSchema)).optional(),
+  schema: z.custom(),
   /**
-   * The resolved unit inputs for the instance.
+   * The original Zod schema of the argument.
    *
-   * Only for computed composite instances.
+   * Only available at runtime.
    */
-  hubInputs: z.record(z.string(), z.array(hubInputSchema)).optional(),
+  [runtimeSchema]: z.instanceof(z.ZodType).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.
+   * Whether the argument is required.
    */
-  injectionInputs: z.array(hubInputSchema).optional(),
+  required: z.boolean(),
   /**
-   * The position of the instance on the canvas.
-   *
-   * Only for designer-first instances.
+   * The extra metadata of the argument.
    */
-  position: positionSchema.optional()
+  meta: objectMetaSchema.required({ title: true }).pick({
+    title: true,
+    globalTitle: true,
+    description: true,
+    color: true,
+    icon: true,
+    iconColor: true
+  })
 });
-var instanceModelSchema = z.object({
-  /**
-   * The id of the instance unique within the project.
-   *
-   * The format is `${instanceType}:${instanceName}`.
-   */
-  id: instanceIdSchema,
+var componentInputSchema = z.object({
   /**
-   * The type of the instance.
+   * The type of the entity passed through the input.
    */
-  type: genericNameSchema,
+  type: versionedNameSchema,
   /**
-   * The name of the instance.
-   *
-   * Must be unique within instances of the same type in the project.
+   * Whether the input is required.
    */
-  name: genericNameSchema,
-  ...instanceModelPatchSchema.shape,
+  required: z.boolean(),
   /**
-   * The id of the top level parent instance.
-   *
-   * Only for child instances of the composite instances.
+   * Whether the input can have multiple values.
    */
-  resolvedInputs: z.record(z.string(), z.array(instanceInputSchema)).optional(),
+  multiple: z.boolean(),
   /**
-   * The position of the instance on the canvas.
-   *
-   * Only for designer-first instances.
+   * The extra metadata of the input.
    */
-  parentId: z.string().optional(),
+  meta: objectMetaSchema.required({ title: true }).pick({
+    title: true,
+    description: true
+  })
+});
+var componentModelSchema = z.object({
   /**
-   * The direct instance outputs returned by the instance as outputs.
-   *
-   * Only for computed composite instances.
+   * The type of the component.
    */
-  outputs: z.record(z.string(), z.array(instanceInputSchema)).optional(),
+  type: genericNameSchema,
   /**
-   * The resolved unit outputs for the instance.
-   *
-   * Only for computed composite instances.
+   * The kind of the component.
    */
-  resolvedOutputs: z.record(z.string(), z.array(instanceInputSchema)).optional()
-});
-var hubModelPatchSchema = z.object({
+  kind: componentKindSchema,
   /**
-   * The position of the hub on the canvas.
+   * The record of the argument schemas.
    */
-  position: positionSchema.optional(),
+  args: z.record(fieldNameSchema, componentArgumentSchema),
   /**
-   * The inputs of the hub.
+   * The record of the input schemas.
    */
-  inputs: z.array(instanceInputSchema).optional(),
+  inputs: z.record(fieldNameSchema, componentInputSchema),
   /**
-   * 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.
+   * The record of the output schemas.
    */
-  injectionInputs: z.array(hubInputSchema).optional()
-});
-var hubModelSchema = z.object({
+  outputs: z.record(fieldNameSchema, componentInputSchema),
   /**
-   * The id of the hub unique within the project.
-   */
-  id: z.nanoid(),
-  ...hubModelPatchSchema.shape
-});
-function getInstanceId(instanceType, instanceName) {
-  return `${instanceType}:${instanceName}`;
-}
-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["Secret"] = "56ebf97b-57de-4985-8c86-bc1bc5871e6e";
-  HighstateSignature2["Yaml"] = "c857cac5-caa6-4421-b82c-e561fbce6367";
-  return HighstateSignature2;
-})(HighstateSignature || {});
-var yamlValueSchema = z.object({
-  ["c857cac5-caa6-4421-b82c-e561fbce6367" /* Yaml */]: z.literal(true),
-  value: z.string()
-});
-var fileMetaSchema = z.object({
-  name: z.string(),
-  contentType: z.string().optional(),
-  size: z.number().optional(),
-  mode: z.number().optional(),
-  isBinary: z.boolean().optional()
-});
-var unitObjectMetaSchema = z.object({
-  displayName: z.string().optional(),
-  description: z.string().optional(),
-  primaryIcon: z.string().optional()
-});
-var unitSecretSchema = z.object({
-  ["56ebf97b-57de-4985-8c86-bc1bc5871e6e" /* Secret */]: z.literal(true),
-  id: z.uuidv7(),
-  value: z.unknown()
-});
-var unitArtifactSchema = z.object({
-  ["d55c63ac-3174-4756-808f-f778e99af0d1" /* Artifact */]: z.literal(true),
-  hash: z.string(),
-  meta: unitObjectMetaSchema.optional()
-});
-var fileContentSchema = z.union([
-  z.object({
-    type: z.literal("embedded"),
-    value: z.string()
-  }),
-  z.object({
-    type: z.literal("artifact"),
-    ...unitArtifactSchema.shape
-  })
-]);
-var fileSchema = z.object({
-  meta: fileMetaSchema,
-  content: fileContentSchema
-});
-
-// src/utils.ts
-function text(strings, ...values) {
-  const stringValues = values.map(String);
-  let result = "";
-  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 lastLineIndentMatch = strings[i].match(/(?:^|\n)([ \t]*)$/);
-      const indent = lastLineIndentMatch ? lastLineIndentMatch[1] : "";
-      result += lines.map((line, j) => j === 0 ? line : indent + line).join("\n");
-    }
-  }
-  return trimIndentation(result);
-}
-function trimIndentation(text2) {
-  const lines = text2.split("\n");
-  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();
-}
-function bytesToHumanReadable(bytes) {
-  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
-  if (bytes === 0) return "0 Bytes";
-  const i = Math.floor(Math.log(bytes) / Math.log(1024));
-  return parseFloat((bytes / Math.pow(1024, i)).toFixed(2)) + " " + sizes[i];
-}
-function formatInstancePath(instance) {
-  let result = instance.id;
-  while (instance.parentId) {
-    const parent = runtimeInstances.get(instance.parentId)?.instance;
-    if (!parent) {
-      break;
-    }
-    result = `${parent.id} -> ${result}`;
-    instance = parent;
-  }
-  return result;
-}
-var InstanceNameConflictError = class extends Error {
-  constructor(instanceId, firstPath, 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();
-function resetEvaluation() {
-  runtimeInstances.clear();
-  currentInstance = null;
-}
-function getRuntimeInstances() {
-  return Array.from(runtimeInstances.values());
-}
-function registerInstance(component, instance, fn) {
-  if (runtimeInstances.has(instance.id)) {
-    const existing = runtimeInstances.get(instance.id);
-    throw new InstanceNameConflictError(
-      instance.id,
-      formatInstancePath(existing.instance),
-      formatInstancePath(instance)
-    );
-  }
-  runtimeInstances.set(instance.id, { instance, component });
-  let previousParentInstance = null;
-  if (currentInstance) {
-    instance.parentId = currentInstance.id;
-  }
-  if (!isUnitModel(component.model)) {
-    previousParentInstance = currentInstance;
-    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 }
-      }))
-    );
-  } finally {
-    if (previousParentInstance) {
-      currentInstance = previousParentInstance;
-    }
-  }
-}
-
-// src/component.ts
-var boundaryInput = Symbol("boundaryInput");
-var ajv = new Ajv({ strict: false });
-var validationEnabled = true;
-function setValidationEnabled(enabled) {
-  validationEnabled = enabled;
-}
-var componentArgumentSchema = z.object({
-  /**
-   * The JSON schema of the argument value.
-   */
-  schema: z.custom(),
-  /**
-   * Whether the argument is required.
-   */
-  required: z.boolean(),
-  /**
-   * The extra metadata of the argument.
-   */
-  meta: objectMetaSchema.required({ title: true }).pick({
-    title: true,
-    globalTitle: true,
-    description: true,
-    color: true,
-    icon: true,
-    iconColor: true
-  })
-});
-function isSchemaOptional(schema) {
-  return schema.safeParse(void 0).success;
-}
-var componentInputSchema = z.object({
-  /**
-   * The type of the input.
-   */
-  type: genericNameSchema,
-  /**
-   * Whether the input is required.
-   */
-  required: z.boolean(),
-  /**
-   * Whether the input can have multiple values.
-   */
-  multiple: z.boolean(),
-  /**
-   * The extra metadata of the input.
-   */
-  meta: objectMetaSchema.required({ title: true }).pick({
-    title: true,
-    description: true
-  })
-});
-var componentModelSchema = z.object({
-  /**
-   * The type of the component.
-   */
-  type: genericNameSchema,
-  /**
-   * 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.
+   * The extra metadata of the component.
    */
   meta: objectMetaSchema.required({ title: true }).pick({
     title: true,
@@ -538,7 +386,7 @@ var componentModelSchema = z.object({
      *
      * Used to generate default names for the instances.
      */
-    defaultNamePrefix: z.string().optional()
+    defaultNamePrefix: z.string()
   }),
   /**
    * The CRC32 of the component definition.
@@ -546,48 +394,90 @@ var componentModelSchema = z.object({
   definitionHash: z.number()
 });
 var originalCreate = Symbol("originalCreate");
+var kind = Symbol("kind");
 function defineComponent(options) {
-  if (!options.type) {
-    throw new Error("Component type is required");
+  try {
+    componentModelSchema.shape.type.parse(options.type);
+  } catch (error) {
+    throw new Error(`Invalid component type "${options.type}"`, { cause: error });
   }
   if (!options.create) {
     throw new Error("Component create function is required");
   }
+  const entities = /* @__PURE__ */ new Map();
+  const mapInput = createInputMapper(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),
+    meta: {
+      ...options.meta,
+      title: options.meta?.title || camelCaseToHumanReadable(parseVersionedName(options.type)[0]),
+      defaultNamePrefix: options.meta?.defaultNamePrefix || parseVersionedName(options.type)[0].split(".").slice(-1)[0]
+    },
+    // biome-ignore lint/style/noNonNullAssertion: will be calculated by library loader
+    definitionHash: null
+  };
   function create(params) {
-    const { name, args, inputs } = params;
+    const { name, args = {}, inputs } = params;
     const instanceId = getInstanceId(options.type, name);
-    const flatInputs = mapValues(pickBy(inputs ?? {}, isNonNullish), (inputs2) => [inputs2].flat(2));
+    const flatInputs = {};
+    const tracedInputs = {};
+    for (const [key, inputGroup] of Object.entries(inputs ?? {})) {
+      if (!inputGroup) {
+        continue;
+      }
+      if (!Array.isArray(inputGroup)) {
+        if (inputGroup[boundaryInput]) {
+          tracedInputs[key] = [inputGroup[boundaryInput]];
+        }
+        flatInputs[key] = [inputGroup];
+        continue;
+      }
+      const group = [...inputGroup[boundaryInputs] ?? []];
+      const inputs2 = [];
+      for (const item of inputGroup.flat(1)) {
+        if (item[boundaryInput]) {
+          group.push(item[boundaryInput]);
+        }
+        inputs2.push(item);
+      }
+      tracedInputs[key] = uniqueBy(group, inputKey);
+      flatInputs[key] = uniqueBy(inputs2, inputKey);
+    }
     return registerInstance(
       create,
       {
         id: instanceId,
         type: options.type,
+        kind: options[kind] ?? "composite",
         name,
-        args: args ?? {},
-        inputs: mapValues(flatInputs, (inputs2) => inputs2.map((input) => input[boundaryInput] ?? input)),
-        resolvedInputs: flatInputs
+        args,
+        inputs: tracedInputs,
+        resolvedInputs: mapValues(
+          flatInputs,
+          (inputs2) => inputs2.filter((input) => !("provided" in input && input.provided === false))
+        )
       },
       () => {
-        const componentInputs = create.model.inputs;
-        const markedInputs = mapValues(componentInputs, (componentInput, key) => {
-          const inputs2 = flatInputs[key];
-          if (!inputs2 || inputs2.length === 0) {
-            return create.model.inputs[key].multiple ? [{ instanceId, output: key }] : { instanceId, output: key };
+        const markedInputs = mapValues(model.inputs, (componentInput, key) => {
+          if (!componentInput.multiple) {
+            const input = flatInputs[key]?.[0];
+            if (input) {
+              return { ...input, [boundaryInput]: { instanceId, output: key } };
+            }
+            return { provided: false, [boundaryInput]: { instanceId, output: key } };
           }
-          const result = inputs2.map((input) => ({
-            ...input,
-            [boundaryInput]: { instanceId, output: key }
-          }));
-          return create.model.inputs?.[key]?.multiple === false ? result[0] : result;
+          const inputs2 = flatInputs[key] ?? [];
+          inputs2[boundaryInputs] = [{ instanceId, output: key }];
+          return inputs2;
         });
         const outputs = options.create({
           id: instanceId,
           name,
-          args: validateArgsAndFillDefaults(
-            instanceId,
-            create.model,
-            args ? { ...args } : {}
-          ),
+          args: processArgs(instanceId, create.model, args),
           inputs: markedInputs
         }) ?? {};
         return mapValues(pickBy(outputs, isNonNullish), (outputs2) => [outputs2].flat(2));
@@ -595,42 +485,55 @@ function defineComponent(options) {
     );
   }
   try {
-    create.entities = /* @__PURE__ */ new Map();
-    const mapInput = createInputMapper(create.entities);
-    create.model = {
-      type: options.type,
-      args: mapValues(options.args ?? {}, mapArgument),
-      inputs: mapValues(options.inputs ?? {}, mapInput),
-      outputs: mapValues(options.outputs ?? {}, mapInput),
-      meta: {
-        ...options.meta,
-        title: options.meta?.title ?? camelCaseToHumanReadable(options.type)
-      },
-      definitionHash: null
-      // will be calculated by library loader
-    };
+    create.entities = entities;
+    create.model = model;
     create[originalCreate] = options.create;
     return create;
   } catch (error) {
     throw new Error(`Failed to define component "${options.type}"`, { cause: error });
   }
 }
+function processArgs(instanceId, model, args) {
+  if (!validationEnabled) {
+    return args;
+  }
+  const validatedArgs = {};
+  for (const [key, arg] of Object.entries(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}`
+        );
+      }
+      validatedArgs[key] = result.data;
+    } else {
+      validatedArgs[key] = args[key];
+    }
+  }
+  return validatedArgs;
+}
 function isComponent(value) {
   return typeof value === "function" && "model" in value;
 }
+function isSchemaOptional(schema) {
+  return schema.safeParse(void 0).success;
+}
 function mapArgument(value, key) {
   if ("schema" in value) {
     return {
-      schema: z.toJSONSchema(value.schema, { target: "draft-7" }),
-      required: value.required ?? !isSchemaOptional(value.schema),
+      schema: z.toJSONSchema(value.schema, { target: "draft-7", io: "input" }),
+      [runtimeSchema]: value.schema,
+      required: !isSchemaOptional(value.schema),
       meta: {
         ...value.meta,
-        title: value.meta?.title ?? camelCaseToHumanReadable(key)
+        title: value.meta?.title || camelCaseToHumanReadable(key)
       }
     };
   }
   return {
-    schema: z.toJSONSchema(value, { target: "draft-7" }),
+    schema: z.toJSONSchema(value, { target: "draft-7", io: "input" }),
+    [runtimeSchema]: value,
     required: !isSchemaOptional(value),
     meta: {
       title: camelCaseToHumanReadable(key)
@@ -650,7 +553,7 @@ function createInputMapper(entities) {
         multiple: value.multiple ?? false,
         meta: {
           ...value.meta,
-          title: value.meta?.title ?? camelCaseToHumanReadable(key)
+          title: value.meta?.title || camelCaseToHumanReadable(key)
         }
       };
     }
@@ -665,37 +568,284 @@ function createInputMapper(entities) {
     };
   };
 }
-function validateArgsAndFillDefaults(instanceId, model, args) {
-  for (const [key, argModel] of Object.entries(model.args)) {
-    let value = args[key];
-    if (!value) {
-      if (argModel.required && validationEnabled) {
-        throw new Error(`Missing required argument "${key}" for instance "${instanceId}"`);
-      }
-      value = argModel.schema.default;
-      args[key] = value;
-    }
-    if (validationEnabled && value && !ajv.validate(argModel.schema, value)) {
-      throw new Error(`Invalid argument "${key}" for instance "${instanceId}": ${ajv.errorsText()}`);
-    }
-  }
-  return args;
+function getInstanceId(instanceType, instanceName) {
+  return `${instanceType}:${instanceName}`;
 }
-function isUnitModel(model) {
-  return "source" in model;
+function toFullComponentArgumentOptions(args) {
+  return mapValues(args, (arg) => "schema" in arg ? arg : { schema: arg });
+}
+function toFullComponentInputOptions(inputs) {
+  return mapValues(inputs, (input) => "entity" in input ? input : { entity: input });
 }
 function $args(args) {
-  return args;
+  return toFullComponentArgumentOptions(args);
 }
 function $inputs(inputs) {
-  return inputs;
+  return toFullComponentInputOptions(inputs);
 }
 function $outputs(outputs) {
-  return outputs;
+  return toFullComponentInputOptions(outputs);
 }
-
-// src/unit.ts
-var componentSecretSchema = componentArgumentSchema.extend({
+function $addArgumentDescription(argument, description) {
+  if ("schema" in argument) {
+    return {
+      ...argument,
+      meta: {
+        ...argument.meta,
+        description: argument.meta?.description ?? description
+      }
+    };
+  }
+  return {
+    schema: argument,
+    meta: {
+      description
+    }
+  };
+}
+function $addInputDescription(input, description) {
+  if ("entity" in input) {
+    return {
+      ...input,
+      meta: {
+        ...input.meta,
+        description: input.meta?.description ?? description
+      }
+    };
+  }
+  return {
+    entity: input,
+    meta: {
+      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";
+  return HighstateSignature2;
+})(HighstateSignature || {});
+var yamlValueSchema = z.object({
+  ["c857cac5-caa6-4421-b82c-e561fbce6367" /* Yaml */]: z.literal(true),
+  value: z.string()
+});
+var fileMetaSchema = z.object({
+  name: z.string(),
+  contentType: z.string().optional(),
+  size: z.number().optional(),
+  mode: z.number().optional()
+});
+var unitArtifactSchema = z.object({
+  ["d55c63ac-3174-4756-808f-f778e99af0d1" /* Artifact */]: z.literal(true),
+  hash: z.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()
+  }),
+  z.object({
+    type: z.literal("artifact"),
+    ...unitArtifactSchema.shape
+  })
+]);
+var fileSchema = z.object({
+  meta: fileMetaSchema,
+  content: fileContentSchema
+});
+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()
+});
+var componentSecretSchema = componentArgumentSchema.extend({
   /**
    * The secret cannot be modified by the user, but can be modified by the unit.
    */
@@ -705,12 +855,38 @@ var componentSecretSchema = componentArgumentSchema.extend({
    */
   computed: z5.boolean()
 });
+var unitSourceSchema = z5.object({
+  /**
+   * The package where the unit implementation is located.
+   *
+   * May be both: local monorepo package or a remote NPM package.
+   */
+  package: z5.string(),
+  /**
+   * The path to the unit implementation within the package.
+   *
+   * If not provided, the root of the package is assumed.
+   */
+  path: z5.string().optional()
+});
+var unitModelSchema = z5.object({
+  ...componentModelSchema.shape,
+  /**
+   * The source of the unit.
+   */
+  source: unitSourceSchema,
+  /**
+   * The record of the secret specs.
+   */
+  secrets: z5.record(z5.string(), componentSecretSchema)
+});
 function defineUnit(options) {
   if (!options.source) {
     throw new Error("Unit source is required");
   }
   const component = defineComponent({
     ...options,
+    [kind]: "unit",
     create({ id }) {
       const outputs = {};
       for (const key in options.outputs ?? {}) {
@@ -724,12 +900,16 @@ function defineUnit(options) {
       return outputs;
     }
   });
-  component.model.source = options.source ?? {};
-  component.model.secrets = mapValues(options.secrets ?? {}, mapSecret);
+  try {
+    component.model.source = options.source ?? {};
+    component.model.secrets = mapValues(options.secrets ?? {}, mapSecret);
+  } catch (error) {
+    throw new Error(`Failed to map secrets for unit "${options.type}"`, { cause: error });
+  }
   return component;
 }
-function $secrets(secrets) {
-  return secrets;
+function $secrets(secrets2) {
+  return toFullComponentArgumentOptions(secrets2);
 }
 function mapSecret(value, key) {
   if ("schema" in value) {
@@ -745,7 +925,209 @@ function mapSecret(value, key) {
     computed: false
   };
 }
+function isUnitModel(model) {
+  return "source" in model;
+}
+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 unitTerminalSchema = z.object({
+  name: z.string(),
+  meta: objectMetaSchema.pick({
+    title: true,
+    globalTitle: true,
+    description: true,
+    icon: true,
+    iconColor: true
+  }).required({ title: true }),
+  spec: terminalSpecSchema
+});
+var pageBlockSchema = z.union([
+  z.object({
+    type: z.literal("markdown"),
+    content: z.string()
+  }),
+  z.object({
+    type: z.literal("qr"),
+    content: z.string(),
+    showContent: z.coerce.boolean(),
+    language: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("file"),
+    file: fileSchema
+  })
+]);
+var unitPageSchema = z.object({
+  name: z.string(),
+  meta: objectMetaSchema.pick({
+    title: true,
+    globalTitle: true,
+    description: true,
+    icon: true,
+    iconColor: true
+  }).required({ title: true }),
+  content: pageBlockSchema.array()
+});
+var triggerSpecSchema = z.union([
+  z.object({
+    type: z.literal("before-destroy")
+  })
+]);
+var unitTriggerSchema = z.object({
+  name: z.string(),
+  meta: objectMetaSchema.pick({
+    title: true,
+    globalTitle: true,
+    description: true,
+    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 unitWorkerSchema = z.object({
+  name: z.string(),
+  image: z.string(),
+  params: z.record(z.string(), z.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()
+});
+function text(strings, ...values) {
+  const stringValues = values.map(String);
+  let result = "";
+  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 lastLineIndentMatch = strings[i].match(/(?:^|\n)([ \t]*)$/);
+      const indent = lastLineIndentMatch ? lastLineIndentMatch[1] : "";
+      result += lines.map((line, j) => j === 0 ? line : indent + line).join("\n");
+    }
+  }
+  return trimIndentation(result);
+}
+function trimIndentation(text2) {
+  const lines = text2.split("\n");
+  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();
+}
+function bytesToHumanReadable(bytes) {
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  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]}`;
+}
+function check(schema, value) {
+  return schema.safeParse(value).success;
+}
+function getOrCreate(map, key, createFn) {
+  const existing = map.get(key);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const value = createFn(key);
+  map.set(key, value);
+  return value;
+}
+function stripNullish(obj) {
+  return pickBy(obj, isNonNullish);
+}
+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(), instanceInputSchema.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.
+   */
+  stateIdMap: z.record(instanceIdSchema, z.string())
+});
+var yamlResultCache = /* @__PURE__ */ new WeakMap();
+function parseArgumentValue(value) {
+  const yamlResult = yamlValueSchema.safeParse(value);
+  if (!yamlResult.success) {
+    return value;
+  }
+  const existingResult = yamlResultCache.get(value);
+  if (existingResult !== void 0) {
+    return existingResult;
+  }
+  const result = parse(yamlResult.data.value);
+  yamlResultCache.set(value, result);
+  return result;
+}
+var HighstateConfigKey = /* @__PURE__ */ ((HighstateConfigKey2) => {
+  HighstateConfigKey2["Config"] = "highstate";
+  HighstateConfigKey2["Secrets"] = "highstate.secrets";
+  return HighstateConfigKey2;
+})(HighstateConfigKey || {});
 
-export { $args, $inputs, $outputs, $secrets, HighstateSignature, InstanceNameConflictError, bytesToHumanReadable, camelCaseToHumanReadable, componentArgumentSchema, componentInputSchema, componentModelSchema, componentSecretSchema, defineComponent, defineEntity, defineUnit, entityModelSchema, fieldNameSchema, fileContentSchema, fileMetaSchema, fileSchema, findInput, findInputs, findRequiredInput, findRequiredInputs, genericNameSchema, getInstanceId, getRuntimeInstances, hubInputSchema, hubModelPatchSchema, hubModelSchema, instanceIdSchema, instanceInputSchema, instanceModelPatchSchema, instanceModelSchema, isComponent, isEntity, isUnitModel, objectMetaSchema, originalCreate, parseInstanceId, positionSchema, registerKnownAbbreviations, resetEvaluation, setValidationEnabled, text, trimIndentation, unitArtifactSchema, unitObjectMetaSchema, unitSecretSchema, userObjectMetaSchema, yamlValueSchema };
+export { $addArgumentDescription, $addInputDescription, $args, $inputs, $outputs, $secrets, HighstateConfigKey, HighstateSignature, InstanceNameConflictError, WellKnownInstanceCustomStatus, bytesToHumanReadable, camelCaseToHumanReadable, check, clearKnownAbbreviations, commonObjectMetaSchema, componentArgumentSchema, componentInputSchema, componentModelSchema, componentSecretSchema, 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, isComponent, isEntity, isUnitModel, objectMetaSchema, originalCreate, pageBlockSchema, parseArgumentValue, parseInstanceId, parseVersionedName, positionSchema, registerKnownAbbreviations, resetEvaluation, runtimeSchema, serviceAccountMetaSchema, setValidationEnabled, stripNullish, terminalSpecSchema, text, timestampsSchema, triggerInvocationSchema, triggerSpecSchema, trimIndentation, unitArtifactSchema, unitConfigSchema, unitModelSchema, unitPageSchema, unitSourceSchema, unitTerminalSchema, unitTriggerSchema, unitWorkerSchema, versionedNameSchema, workerRunOptionsSchema, yamlValueSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map