@hatua/schema 0.0.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pedro Gomes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/contract.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generated/component.d.ts

@@ -0,0 +1,312 @@
+import { z } from 'zod';
+export declare const manifest: z.ZodObject<{
+    kind: z.ZodEnum<{
+        component: "component";
+        trigger: "trigger";
+    }>;
+    use: z.ZodString;
+    name: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    blurb: z.ZodOptional<z.ZodString>;
+    once: z.ZodOptional<z.ZodBoolean>;
+    fixed: z.ZodOptional<z.ZodBoolean>;
+    fields: z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodEnum<{
+            number: "number";
+            text: "text";
+            mono: "mono";
+            textarea: "textarea";
+            ref: "ref";
+            map: "map";
+            enum: "enum";
+            bool: "bool";
+            conn: "conn";
+            secret: "secret";
+        }>;
+        conn_type: z.ZodOptional<z.ZodString>;
+        req: z.ZodOptional<z.ZodBoolean>;
+        hint: z.ZodOptional<z.ZodString>;
+        ph: z.ZodOptional<z.ZodString>;
+        mono: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+            hint: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        toggleLabel: z.ZodOptional<z.ZodString>;
+        entry_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+        }>>>;
+        when: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    outputs: z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+            item: "item";
+        }>;
+        of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    metadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            text: "text";
+            datetime: "datetime";
+        }>;
+        role: z.ZodEnum<{
+            measure: "measure";
+            dimension: "dimension";
+        }>;
+        unit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type Manifest = z.infer<typeof manifest>;
+export declare const field: z.ZodObject<{
+    k: z.ZodString;
+    label: z.ZodString;
+    kind: z.ZodEnum<{
+        number: "number";
+        text: "text";
+        mono: "mono";
+        textarea: "textarea";
+        ref: "ref";
+        map: "map";
+        enum: "enum";
+        bool: "bool";
+        conn: "conn";
+        secret: "secret";
+    }>;
+    conn_type: z.ZodOptional<z.ZodString>;
+    req: z.ZodOptional<z.ZodBoolean>;
+    hint: z.ZodOptional<z.ZodString>;
+    ph: z.ZodOptional<z.ZodString>;
+    mono: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    toggleLabel: z.ZodOptional<z.ZodString>;
+    entry_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        text: "text";
+        datetime: "datetime";
+        list: "list";
+    }>>>;
+    when: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type Field = z.infer<typeof field>;
+export declare const output: z.ZodObject<{
+    k: z.ZodString;
+    label: z.ZodString;
+    t: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        text: "text";
+        datetime: "datetime";
+        list: "list";
+        item: "item";
+    }>;
+    of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+}, z.core.$strict>;
+export type Output = z.infer<typeof output>;
+export declare const metadataDescriptor: z.ZodObject<{
+    k: z.ZodString;
+    label: z.ZodString;
+    t: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        text: "text";
+        datetime: "datetime";
+    }>;
+    role: z.ZodEnum<{
+        measure: "measure";
+        dimension: "dimension";
+    }>;
+    unit: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type MetadataDescriptor = z.infer<typeof metadataDescriptor>;
+/**
+ * The Host-supplied declaration of a step type. Hatua ships its own set and Hosts add business-specific ones; the format is identical and the only difference is who wrote the file.
+ * Adding a component is adding a manifest entry: the library card, the inspector form, the reference tree, the map chips, the validation and the YAML output all follow from it, with no screen-level code.
+ * There is deliberately no connector manifest. Connections are established outside Hatua and arrive from a Host interface carrying their own type, which a `conn` field matches against via `conn_type`.
+ * Accepts either a single manifest or a `components:` catalogue — one file per component suits authoring and diffing, a catalogue suits serving.
+ */
+export declare const componentManifest: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        component: "component";
+        trigger: "trigger";
+    }>;
+    use: z.ZodString;
+    name: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    blurb: z.ZodOptional<z.ZodString>;
+    once: z.ZodOptional<z.ZodBoolean>;
+    fixed: z.ZodOptional<z.ZodBoolean>;
+    fields: z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        kind: z.ZodEnum<{
+            number: "number";
+            text: "text";
+            mono: "mono";
+            textarea: "textarea";
+            ref: "ref";
+            map: "map";
+            enum: "enum";
+            bool: "bool";
+            conn: "conn";
+            secret: "secret";
+        }>;
+        conn_type: z.ZodOptional<z.ZodString>;
+        req: z.ZodOptional<z.ZodBoolean>;
+        hint: z.ZodOptional<z.ZodString>;
+        ph: z.ZodOptional<z.ZodString>;
+        mono: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+            hint: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        toggleLabel: z.ZodOptional<z.ZodString>;
+        entry_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+        }>>>;
+        when: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    outputs: z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+            item: "item";
+        }>;
+        of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    metadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            text: "text";
+            datetime: "datetime";
+        }>;
+        role: z.ZodEnum<{
+            measure: "measure";
+            dimension: "dimension";
+        }>;
+        unit: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>, z.ZodObject<{
+    components: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            component: "component";
+            trigger: "trigger";
+        }>;
+        use: z.ZodString;
+        name: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        blurb: z.ZodOptional<z.ZodString>;
+        once: z.ZodOptional<z.ZodBoolean>;
+        fixed: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodArray<z.ZodObject<{
+            k: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                number: "number";
+                text: "text";
+                mono: "mono";
+                textarea: "textarea";
+                ref: "ref";
+                map: "map";
+                enum: "enum";
+                bool: "bool";
+                conn: "conn";
+                secret: "secret";
+            }>;
+            conn_type: z.ZodOptional<z.ZodString>;
+            req: z.ZodOptional<z.ZodBoolean>;
+            hint: z.ZodOptional<z.ZodString>;
+            ph: z.ZodOptional<z.ZodString>;
+            mono: z.ZodOptional<z.ZodBoolean>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+                hint: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            toggleLabel: z.ZodOptional<z.ZodString>;
+            entry_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                datetime: "datetime";
+                list: "list";
+            }>>>;
+            when: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        outputs: z.ZodArray<z.ZodObject<{
+            k: z.ZodString;
+            label: z.ZodString;
+            t: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                text: "text";
+                datetime: "datetime";
+                list: "list";
+                item: "item";
+            }>;
+            of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        metadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            k: z.ZodString;
+            label: z.ZodString;
+            t: z.ZodEnum<{
+                number: "number";
+                boolean: "boolean";
+                text: "text";
+                datetime: "datetime";
+            }>;
+            role: z.ZodEnum<{
+                measure: "measure";
+                dimension: "dimension";
+            }>;
+            unit: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>]>;
+export type ComponentManifest = z.infer<typeof componentManifest>;

package/dist/generated/context.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const contextKey: z.ZodObject<{
+    k: z.ZodString;
+    label: z.ZodString;
+    t: z.ZodEnum<{
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        text: "text";
+        datetime: "datetime";
+        list: "list";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ContextKey = z.infer<typeof contextKey>;
+/**
+ * The Host-supplied declaration of the ambient values it hands its runner for every execution — the run id, the tenant, the caller's address, when the run started, who triggered it. Addressed as `run.` from any Expression, beside `triggers.` and `var.`.
+ * Hatua only ever reads these. It declares no keys of its own and invents none: without a declaration there is no Run Context, the same bargain ADR-0007 strikes for connections and ADR-0010 for functions — a shape Hatua reads so the builder can offer and type-check it, and values the Host's runner supplies.
+ * There is exactly one Run Context per execution, so this file declares keys directly rather than naming a type someone instantiates. That is why there is no `use`, no `name`, and no catalogue wrapper: a Host serves one of these, and a second is a mistake rather than a longer list.
+ * A key is spelled `{k, label, t}` — the same triple every declared output already uses, with `of` nesting the same way — because the reference tree, the completion list and the type checker read outputs today and a second spelling for the same idea would be a second reader to keep in step. What it adds is `description`, for the sentence the completion list shows under the focused row.
+ * This is a separate file rather than a fourth `kind:` inside the Component Manifest, for the reason ADR-0010 gives about functions: a conditional manifest shape would need the JSON-Schema-to-zod generator to grow `if`/`then`, and ADR-0006 keeps that generator deliberately narrow precisely because a silent mistranslation there is the failure the whole decision prevents. A Component Manifest requires `use`, `name`, `fields` and `outputs`, none of which a Run Context has.
+ */
+export declare const runContextManifest: z.ZodObject<{
+    kind: z.ZodEnum<{
+        context: "context";
+    }>;
+    keys: z.ZodArray<z.ZodObject<{
+        k: z.ZodString;
+        label: z.ZodString;
+        t: z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            text: "text";
+            datetime: "datetime";
+            list: "list";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        of: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RunContextManifest = z.infer<typeof runContextManifest>;