@highstate/contract 0.9.16 → 0.9.18

package/dist/index.js

@@ -1,13 +1,274 @@
-// src/instance.ts
-import { Type } from "@sinclair/typebox";
-var boundaryInput = Symbol("boundaryInput");
+import z5, { z } from 'zod';
+export { z } from 'zod';
+import { mapValues, pickBy, isNonNullish } from 'remeda';
+import { Ajv } from 'ajv';
+
+// src/entity.ts
+var userObjectMetaSchema = z.object({
+  /**
+   * Human-readable name of the object.
+   *
+   * Used in UI components for better user experience.
+   */
+  title: z.string().optional(),
+  /**
+   * The title used globally for the object.
+   *
+   * For example, the title of an instance secret is "Password" which is okay
+   * to display in the instance secret list, but when the secret is displayed in a
+   * global secret list the name should be more descriptive, like "Proxmox Password".
+   */
+  globalTitle: z.string().optional(),
+  /**
+   * Description of the object.
+   *
+   * Provides additional context for users and developers.
+   */
+  description: z.string().optional(),
+  /**
+   * The color of the object.
+   *
+   * Used in UI components to visually distinguish objects.
+   */
+  color: z.string().optional(),
+  /**
+   * Primary icon identifier.
+   *
+   * Should reference a iconify icon name, like "mdi:server" or "gg:remote".
+   */
+  icon: z.string().optional(),
+  /**
+   * The color of the primary icon.
+   */
+  iconColor: z.string().optional(),
+  /**
+   * The secondary icon identifier.
+   *
+   * Used to provide additional context or actions related to the object.
+   *
+   * Should reference a iconify icon name, like "mdi:edit" or "mdi:delete".
+   */
+  secondaryIcon: z.string().optional(),
+  /**
+   * The color of the secondary icon.
+   */
+  secondaryIconColor: z.string().optional()
+});
+var objectMetaSchema = userObjectMetaSchema.extend({
+  /**
+   * Creation timestamp in milliseconds.
+   *
+   * Managed automatically by the system.
+   */
+  createdAt: z.number().optional(),
+  /**
+   * Last update timestamp in milliseconds.
+   *
+   * Managed automatically by the system.
+   */
+  updatedAt: z.number().optional(),
+  /**
+   * The optional version of the document to support optimistic concurrency control.
+   *
+   * Managed automatically by the system.
+   */
+  version: z.number().optional()
+});
+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);
+    }
+  }
+}
+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(" ");
+}
+
+// src/entity.ts
+var entityModelSchema = z.object({
+  /**
+   * The static type of the entity.
+   */
+  type: z.string(),
+  /**
+   * The JSON schema of the entity value.
+   */
+  schema: z.custom(),
+  /**
+   * The extra metadata of the entity.
+   */
+  meta: objectMetaSchema.required({ title: true }).pick({
+    title: true,
+    description: true,
+    color: true,
+    icon: true,
+    iconColor: true
+  }),
+  /**
+   * The CRC32 of the entity definition.
+   */
+  definitionHash: z.number()
+});
+function defineEntity(options) {
+  if (!options.type) {
+    throw new Error("Entity type is required");
+  }
+  if (!options.schema) {
+    throw new Error("Entity schema is required");
+  }
+  try {
+    return {
+      type: options.type,
+      schema: options.schema,
+      model: {
+        type: options.type,
+        schema: z.toJSONSchema(options.schema, { target: "draft-7" }),
+        meta: {
+          ...options.meta,
+          title: options.meta?.title ?? camelCaseToHumanReadable(options.type)
+        },
+        // will be calculated by the library loader
+        definitionHash: null
+      }
+    };
+  } catch (error) {
+    throw new Error(`Failed to define entity "${options.type}"`, { cause: error });
+  }
+}
+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(),
+  /**
+   * 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 type of the instance.
+   */
+  type: genericNameSchema,
+  /**
+   * 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 position of the instance on the canvas.
+   *
+   * Only for designer-first instances.
+   */
+  parentId: z.string().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.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 key: ${instanceId}`);
+    throw new Error(`Invalid instance ID: ${instanceId}`);
   }
   return parts;
 }
@@ -40,52 +301,51 @@ function findRequiredInputs(inputs, names) {
 }
 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 fileMetaSchema = Type.Object({
-  name: Type.String(),
-  contentType: Type.Optional(Type.String()),
-  size: Type.Optional(Type.Number()),
-  mode: Type.Optional(Type.Number()),
-  isBinary: Type.Optional(Type.Boolean())
+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 = Type.Object({
-  displayName: Type.Optional(Type.String()),
-  description: Type.Optional(Type.String()),
-  primaryIcon: Type.Optional(Type.String())
+var unitObjectMetaSchema = z.object({
+  displayName: z.string().optional(),
+  description: z.string().optional(),
+  primaryIcon: z.string().optional()
 });
-var unitArtifactSchema = Type.Object({
-  hash: Type.String(),
-  meta: Type.Optional(unitObjectMetaSchema)
+var unitSecretSchema = z.object({
+  ["56ebf97b-57de-4985-8c86-bc1bc5871e6e" /* Secret */]: z.literal(true),
+  id: z.uuidv7(),
+  value: z.unknown()
 });
-var fileContentSchema = Type.Union([
-  Type.Object({
-    type: Type.Literal("embedded"),
-    value: Type.String()
+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()
   }),
-  Type.Object({
-    type: Type.Literal("artifact"),
-    ["d55c63ac-3174-4756-808f-f778e99af0d1" /* Artifact */]: unitArtifactSchema
+  z.object({
+    type: z.literal("artifact"),
+    ...unitArtifactSchema.shape
   })
 ]);
-var fileSchema = Type.Object({
+var fileSchema = z.object({
   meta: fileMetaSchema,
   content: fileContentSchema
 });
 
-// src/evaluation.ts
-import { mapValues as mapValues3 } from "remeda";
-
-// src/unit.ts
-import { mapValues as mapValues2 } from "remeda";
-
-// src/component.ts
-import {
-  OptionalKind
-} from "@sinclair/typebox";
-import { isNonNullish, mapValues, pickBy } from "remeda";
-import { Ajv } from "ajv";
-
 // src/utils.ts
 function text(strings, ...values) {
   const stringValues = values.map(String);
@@ -113,40 +373,194 @@ function bytesToHumanReadable(bytes) {
   const i = Math.floor(Math.log(bytes) / Math.log(1024));
   return parseFloat((bytes / Math.pow(1024, i)).toFixed(2)) + " " + sizes[i];
 }
-
-// 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 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;
 }
-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);
+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;
     }
-    return word.charAt(0).toUpperCase() + word.slice(1);
-  }).join(" ");
+  }
 }
 
 // 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.
+   */
+  meta: objectMetaSchema.required({ title: true }).pick({
+    title: true,
+    description: true,
+    color: true,
+    icon: true,
+    iconColor: true,
+    secondaryIcon: true,
+    secondaryIconColor: true
+  }).extend({
+    /**
+     * The category of the component.
+     *
+     * Used to group components in the UI.
+     */
+    category: z.string().optional(),
+    /**
+     * The default name prefix for the component instances.
+     *
+     * Used to generate default names for the instances.
+     */
+    defaultNamePrefix: z.string().optional()
+  }),
+  /**
+   * The CRC32 of the component definition.
+   */
+  definitionHash: z.number()
+});
 var originalCreate = Symbol("originalCreate");
 function defineComponent(options) {
+  if (!options.type) {
+    throw new Error("Component type is required");
+  }
+  if (!options.create) {
+    throw new Error("Component create function is required");
+  }
   function create(params) {
     const { name, args, inputs } = params;
-    const id = `${options.type}:${name}`;
+    const instanceId = getInstanceId(options.type, name);
     const flatInputs = mapValues(pickBy(inputs ?? {}, isNonNullish), (inputs2) => [inputs2].flat(2));
     return registerInstance(
-      create.model,
+      create,
       {
-        id,
+        id: instanceId,
         type: options.type,
         name,
         args: args ?? {},
@@ -154,18 +568,23 @@ function defineComponent(options) {
         resolvedInputs: flatInputs
       },
       () => {
-        const markedInputs = mapValues(flatInputs, (inputs2, key) => {
+        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 result = inputs2.map((input) => ({
             ...input,
-            [boundaryInput]: { instanceId: id, output: key }
+            [boundaryInput]: { instanceId, output: key }
           }));
           return create.model.inputs?.[key]?.multiple === false ? result[0] : result;
         });
         const outputs = options.create({
-          id,
+          id: instanceId,
           name,
           args: validateArgsAndFillDefaults(
-            id,
+            instanceId,
             create.model,
             args ? { ...args } : {}
           ),
@@ -175,20 +594,26 @@ function defineComponent(options) {
       }
     );
   }
-  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,
-      displayName: options.meta?.displayName ?? camelCaseToHumanReadable(options.type)
-    }
-  };
-  create[originalCreate] = options.create;
-  return create;
+  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[originalCreate] = options.create;
+    return create;
+  } catch (error) {
+    throw new Error(`Failed to define component "${options.type}"`, { cause: error });
+  }
 }
 function isComponent(value) {
   return typeof value === "function" && "model" in value;
@@ -196,19 +621,19 @@ function isComponent(value) {
 function mapArgument(value, key) {
   if ("schema" in value) {
     return {
-      schema: value.schema,
-      required: value.required ?? (!value.schema[OptionalKind] && value.schema.default === void 0),
+      schema: z.toJSONSchema(value.schema, { target: "draft-7" }),
+      required: value.required ?? !isSchemaOptional(value.schema),
       meta: {
-        displayName: value.meta?.displayName ?? camelCaseToHumanReadable(key),
-        description: value.meta?.description
+        ...value.meta,
+        title: value.meta?.title ?? camelCaseToHumanReadable(key)
       }
     };
   }
   return {
-    schema: value,
-    required: !value[OptionalKind] && value.default === void 0,
+    schema: z.toJSONSchema(value, { target: "draft-7" }),
+    required: !isSchemaOptional(value),
     meta: {
-      displayName: camelCaseToHumanReadable(key)
+      title: camelCaseToHumanReadable(key)
     }
   };
 }
@@ -224,9 +649,8 @@ function createInputMapper(entities) {
         required: value.required ?? true,
         multiple: value.multiple ?? false,
         meta: {
-          displayName: value.displayName ?? camelCaseToHumanReadable(key),
-          description: value.description,
-          color: value.color
+          ...value.meta,
+          title: value.meta?.title ?? camelCaseToHumanReadable(key)
         }
       };
     }
@@ -236,7 +660,7 @@ function createInputMapper(entities) {
       required: true,
       multiple: false,
       meta: {
-        displayName: camelCaseToHumanReadable(key)
+        title: camelCaseToHumanReadable(key)
       }
     };
   };
@@ -245,18 +669,21 @@ function validateArgsAndFillDefaults(instanceId, model, args) {
   for (const [key, argModel] of Object.entries(model.args)) {
     let value = args[key];
     if (!value) {
-      if (argModel.required) {
+      if (argModel.required && validationEnabled) {
         throw new Error(`Missing required argument "${key}" for instance "${instanceId}"`);
       }
       value = argModel.schema.default;
       args[key] = value;
     }
-    if (value && !ajv.validate(argModel.schema, value)) {
+    if (validationEnabled && value && !ajv.validate(argModel.schema, value)) {
       throw new Error(`Invalid argument "${key}" for instance "${instanceId}": ${ajv.errorsText()}`);
     }
   }
   return args;
 }
+function isUnitModel(model) {
+  return "source" in model;
+}
 function $args(args) {
   return args;
 }
@@ -268,10 +695,20 @@ function $outputs(outputs) {
 }
 
 // src/unit.ts
-function isUnitModel(model) {
-  return "source" in model;
-}
+var componentSecretSchema = componentArgumentSchema.extend({
+  /**
+   * The secret cannot be modified by the user, but can be modified by the unit.
+   */
+  readonly: z5.boolean(),
+  /**
+   * The secret value is computed by the unit and should not be passed to it when invoked.
+   */
+  computed: z5.boolean()
+});
 function defineUnit(options) {
+  if (!options.source) {
+    throw new Error("Unit source is required");
+  }
   const component = defineComponent({
     ...options,
     create({ id }) {
@@ -288,116 +725,27 @@ function defineUnit(options) {
     }
   });
   component.model.source = options.source ?? {};
-  component.model.secrets = mapValues2(options.secrets ?? {}, mapArgument);
+  component.model.secrets = mapValues(options.secrets ?? {}, mapSecret);
   return component;
 }
 function $secrets(secrets) {
   return secrets;
 }
-
-// src/evaluation.ts
-var compositeInstances = /* @__PURE__ */ new Map();
-var currentCompositeInstance = null;
-function resetEvaluation() {
-  compositeInstances.clear();
-  currentCompositeInstance = null;
-}
-function getCompositeInstances() {
-  return Array.from(compositeInstances.values());
-}
-function registerInstance(component, instance, fn) {
-  let previousParentInstance = null;
-  if (currentCompositeInstance) {
-    instance.parentId = currentCompositeInstance.instance.id;
-    currentCompositeInstance.children.push(instance);
-  }
-  if (!isUnitModel(component)) {
-    previousParentInstance = currentCompositeInstance;
-    currentCompositeInstance = { instance, children: [] };
-    compositeInstances.set(currentCompositeInstance.instance.id, currentCompositeInstance);
-  }
-  try {
-    const outputs = fn();
-    instance.resolvedOutputs = outputs;
-    instance.outputs = mapValues3(
-      outputs ?? {},
-      (outputs2) => outputs2.map((output) => output[boundaryInput] ?? output)
-    );
-    return mapValues3(
-      outputs,
-      (outputs2, outputKey) => outputs2.map((output) => ({
-        ...output,
-        [boundaryInput]: { instanceId: instance.id, output: outputKey }
-      }))
-    );
-  } finally {
-    if (previousParentInstance) {
-      currentCompositeInstance = previousParentInstance;
-    }
+function mapSecret(value, key) {
+  if ("schema" in value) {
+    return {
+      ...mapArgument(value, key),
+      readonly: value.readonly ?? false,
+      computed: value.computed ?? false
+    };
   }
-}
-
-// src/entity.ts
-function defineEntity(options) {
   return {
-    meta: {},
-    ...options
+    ...mapArgument(value, key),
+    readonly: false,
+    computed: false
   };
 }
-function isEntity(value) {
-  return typeof value === "object" && value !== null && "type" in value && "schema" in value && "meta" in value;
-}
 
-// src/types.ts
-import "@sinclair/typebox";
-
-// src/index.ts
-export * from "@sinclair/typebox";
-import {
-  Type as BaseType
-} from "@sinclair/typebox";
-function StringEnum(values) {
-  return Type2.Union(values.map((value) => Type2.Literal(value)));
-}
-function Default(schema, defaultValue) {
-  return { ...schema, default: defaultValue };
-}
-var Type2 = {
-  ...BaseType,
-  StringEnum,
-  Default
-};
-export {
-  $args,
-  $inputs,
-  $outputs,
-  $secrets,
-  HighstateSignature,
-  Type2 as Type,
-  bytesToHumanReadable,
-  camelCaseToHumanReadable,
-  defineComponent,
-  defineEntity,
-  defineUnit,
-  fileContentSchema,
-  fileMetaSchema,
-  fileSchema,
-  findInput,
-  findInputs,
-  findRequiredInput,
-  findRequiredInputs,
-  getCompositeInstances,
-  getInstanceId,
-  isComponent,
-  isEntity,
-  isUnitModel,
-  originalCreate,
-  parseInstanceId,
-  registerKnownAbbreviations,
-  resetEvaluation,
-  text,
-  trimIndentation,
-  unitArtifactSchema,
-  unitObjectMetaSchema
-};
+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 };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map