@elevasis/ui 2.25.5 → 2.26.0

package/dist/api/index.js

@@ -1,6 +1,6 @@
 import '../chunk-XCYKC6OZ.js';
-export { ApiClientProvider, useApiClient, useApiClientContext } from '../chunk-T6INEVX6.js';
-import '../chunk-SGXXJE52.js';
+export { ApiClientProvider, useApiClient, useApiClientContext } from '../chunk-SGS4CQ2B.js';
+import '../chunk-QD4X4H5A.js';
 import '../chunk-KRWALB24.js';
 import '../chunk-DD3CCMCZ.js';
 import '../chunk-I2KLQ2HA.js';

package/dist/app/index.css

@@ -11,14 +11,14 @@
 }
 .lead-gen-build-action-button:disabled,
 .lead-gen-build-action-button[data-disabled] {
-  background-color: color-mix(in srgb, var(--mantine-color-gray-8) 48%, var(--color-surface) 52%) !important;
-  border-color: color-mix(in srgb, var(--mantine-color-gray-8) 58%, var(--color-surface) 42%) !important;
+  background-color: var(--surface-primary-muted) !important;
+  border-color: var(--border-primary-subtle) !important;
   color: color-mix(in srgb, var(--color-text-subtle) 88%, var(--color-text-dimmed) 12%) !important;
   opacity: 0.78;
 }
 .lead-gen-build-action-button:disabled:hover,
 .lead-gen-build-action-button[data-disabled]:hover {
-  background-color: color-mix(in srgb, var(--mantine-color-gray-8) 48%, var(--color-surface) 52%) !important;
+  background-color: var(--surface-primary-muted) !important;
 }
 .mantine-Accordion-control:hover {
   background-color: var(--color-surface-hover);
@@ -26,35 +26,24 @@
 .mantine-Menu-item:hover:not([data-disabled]) {
   background-color: var(--color-surface-hover);
 }
-.mantine-Select-option:hover {
-  background-color: var(--color-surface-hover) !important;
+.mantine-Select-option:hover,
+.mantine-MultiSelect-option:hover,
+.mantine-TagsInput-option:hover,
+.mantine-Combobox-option:hover {
+  background-color: var(--surface-primary-muted) !important;
+}
+.mantine-Select-option[data-combobox-selected],
+.mantine-MultiSelect-option[data-combobox-selected],
+.mantine-TagsInput-option[data-combobox-selected],
+.mantine-Combobox-option[data-combobox-selected] {
+  background-color: var(--surface-primary-subtle) !important;
+  color: var(--color-text);
 }
-[data-mantine-color-scheme] .mantine-Tabs-root {
-  --tabs-color: var(--color-primary);
+[data-mantine-color-scheme=dark] .mantine-Tabs-root {
   --tab-border-color: var(--color-border);
-  --tab-hover-color: color-mix(in srgb, var(--color-surface-hover) 70%, transparent);
-}
-[data-mantine-color-scheme] .mantine-Tabs-list::before {
-  border-color: var(--color-border);
 }
-[data-mantine-color-scheme] .mantine-Tabs-tab {
-  color: var(--color-text);
-  border-color: transparent;
-  background-color: transparent;
-  transition:
-    background-color var(--duration-fast) var(--easing),
-    border-color var(--duration-fast) var(--easing),
-    color var(--duration-fast) var(--easing);
-}
-[data-mantine-color-scheme] .mantine-Tabs-tab:not([data-active]):hover {
-  background-color: var(--tab-hover-color);
-  border-color: var(--color-border);
-}
-[data-mantine-color-scheme] .mantine-Tabs-tab[data-active],
-[data-mantine-color-scheme] .mantine-Tabs-tab[data-active]:hover {
-  color: var(--color-text);
-  background-color: transparent;
-  border-color: var(--color-primary);
+.mantine-Tabs-tab:hover {
+  background-color: var(--color-surface-hover);
 }
 .mantine-Pagination-control:not([data-active]) {
   background: var(--color-surface);

package/dist/app/index.d.ts

@@ -1,7 +1,8 @@
 import { ReactNode, ComponentType } from 'react';
 import { AnyRouter } from '@tanstack/react-router';
 import { QueryClient } from '@tanstack/react-query';
-import { z } from 'zod';
+import * as z from 'zod';
+import { z as z$1 } from 'zod';
 import { MantineThemeOverride } from '@mantine/core';
 
 type Json = string | number | boolean | null | {
@@ -2911,87 +2912,87 @@ type Database = {
     };
 };
 
-/** Raw database row type for acq_deals table */
-type AcqDealRow = Database['public']['Tables']['acq_deals']['Row'];
-
 /**
  * Single list as returned by /api/acquisition/lists/:id etc.
  * Camel-cased domain shape matching AcqList in types.ts.
  */
-declare const AcqListResponseSchema: z.ZodObject<{
-    id: z.ZodString;
-    organizationId: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodNullable<z.ZodString>;
-    batchIds: z.ZodArray<z.ZodString>;
-    instantlyCampaignId: z.ZodNullable<z.ZodString>;
-    status: z.ZodEnum<{
+declare const AcqListResponseSchema: z$1.ZodObject<{
+    id: z$1.ZodString;
+    organizationId: z$1.ZodString;
+    name: z$1.ZodString;
+    description: z$1.ZodNullable<z$1.ZodString>;
+    batchIds: z$1.ZodArray<z$1.ZodString>;
+    instantlyCampaignId: z$1.ZodNullable<z$1.ZodString>;
+    status: z$1.ZodEnum<{
         closing: "closing";
         draft: "draft";
         enriching: "enriching";
         launched: "launched";
         archived: "archived";
     }>;
-    metadata: z.ZodObject<{
-        buildPlanSnapshot: z.ZodOptional<z.ZodObject<{
-            templateId: z.ZodString;
-            templateLabel: z.ZodString;
-            steps: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                label: z.ZodString;
-                description: z.ZodOptional<z.ZodString>;
-                primaryEntity: z.ZodEnum<{
+    metadata: z$1.ZodObject<{
+        buildPlanSnapshot: z$1.ZodOptional<z$1.ZodObject<{
+            templateId: z$1.ZodString;
+            templateLabel: z$1.ZodString;
+            steps: z$1.ZodArray<z$1.ZodObject<{
+                id: z$1.ZodString;
+                label: z$1.ZodString;
+                description: z$1.ZodOptional<z$1.ZodString>;
+                primaryEntity: z$1.ZodEnum<{
                     company: "company";
                     contact: "contact";
                 }>;
-                outputs: z.ZodArray<z.ZodEnum<{
+                outputs: z$1.ZodArray<z$1.ZodEnum<{
                     company: "company";
                     contact: "contact";
                     export: "export";
                 }>>;
-                stageKey: z.ZodString;
-                dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                dependencyMode: z.ZodLiteral<"per-record-eligibility">;
-                capabilityKey: z.ZodString;
-                defaultBatchSize: z.ZodNumber;
-                maxBatchSize: z.ZodNumber;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-    }, z.core.$catchall<z.ZodUnknown>>;
-    launchedAt: z.ZodNullable<z.ZodString>;
-    completedAt: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodString;
-    scrapingConfig: z.ZodObject<{
-        vertical: z.ZodOptional<z.ZodString>;
-        geography: z.ZodOptional<z.ZodString>;
-        size: z.ZodOptional<z.ZodString>;
-        apifyInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>;
-    icp: z.ZodObject<{
-        qualificationRubricKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        targetDescription: z.ZodOptional<z.ZodString>;
-        minReviewCount: z.ZodOptional<z.ZodNumber>;
-        minRating: z.ZodOptional<z.ZodNumber>;
-        excludeFranchises: z.ZodOptional<z.ZodBoolean>;
-        customRules: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    pipelineConfig: z.ZodObject<{
-        stages: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            key: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
-            enabled: z.ZodOptional<z.ZodBoolean>;
-            order: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-type AcqListResponse = z.infer<typeof AcqListResponseSchema>;
+                stageKey: z$1.ZodString;
+                dependsOn: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
+                dependencyMode: z$1.ZodLiteral<"per-record-eligibility">;
+                capabilityKey: z$1.ZodString;
+                defaultBatchSize: z$1.ZodNumber;
+                maxBatchSize: z$1.ZodNumber;
+            }, z$1.core.$strip>>;
+        }, z$1.core.$strip>>;
+    }, z$1.core.$catchall<z$1.ZodUnknown>>;
+    launchedAt: z$1.ZodNullable<z$1.ZodString>;
+    completedAt: z$1.ZodNullable<z$1.ZodString>;
+    createdAt: z$1.ZodString;
+    scrapingConfig: z$1.ZodObject<{
+        vertical: z$1.ZodOptional<z$1.ZodString>;
+        geography: z$1.ZodOptional<z$1.ZodString>;
+        size: z$1.ZodOptional<z$1.ZodString>;
+        apifyInput: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+    }, z$1.core.$strip>;
+    icp: z$1.ZodObject<{
+        qualificationRubricKey: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+        targetDescription: z$1.ZodOptional<z$1.ZodString>;
+        minReviewCount: z$1.ZodOptional<z$1.ZodNumber>;
+        minRating: z$1.ZodOptional<z$1.ZodNumber>;
+        excludeFranchises: z$1.ZodOptional<z$1.ZodBoolean>;
+        customRules: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>;
+    pipelineConfig: z$1.ZodObject<{
+        stages: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+            key: z$1.ZodString;
+            label: z$1.ZodOptional<z$1.ZodString>;
+            enabled: z$1.ZodOptional<z$1.ZodBoolean>;
+            order: z$1.ZodOptional<z$1.ZodNumber>;
+        }, z$1.core.$strip>>>;
+    }, z$1.core.$strip>;
+}, z$1.core.$strip>;
+type AcqListResponse = z$1.infer<typeof AcqListResponseSchema>;
+
+/** Raw database row type for acq_deals table */
+type AcqDealRow = Database['public']['Tables']['acq_deals']['Row'];
 
 interface ActionDef {
     key: string;
     label: string;
     isAvailableFor: (deal: AcqDealRow) => boolean;
     workflowId: string;
-    payloadSchema?: z.ZodTypeAny;
+    payloadSchema?: z$1.ZodTypeAny;
 }
 
 interface ApiErrorDetails {
@@ -3043,13 +3044,65 @@ interface ThemePreset {
 }
 type PresetName = 'default' | 'tactical' | 'regal' | 'cyber-volt' | 'aurora' | 'rose-gold' | 'midnight' | 'titanium' | 'canopy' | 'slate' | 'cyber-strike' | 'cyber-chrome' | 'cyber-void' | 'nirvana' | 'wave' | 'synapse' | 'cortex' | 'helios' | 'graphite' | 'quarry';
 
+/**
+ * All valid dotted paths into T.
+ * Arrays of primitives are treated as leaf (return K only).
+ * Arrays of objects are also treated as leaf (no drilling into element shape).
+ * Optional fields are unwrapped via NonNullable before recursing.
+ */
+type FieldPath<T> = T extends object ? {
+    [K in keyof T & string]: T[K] extends ReadonlyArray<unknown> | unknown[] ? K : T[K] extends object | undefined ? K | `${K}.${FieldPath<NonNullable<T[K]>>}` : K;
+}[keyof T & string] : never;
+/** Discriminated string union of supported Mantine components. */
+type StepConfigComponent = 'segmented' | 'tags' | 'multiselect' | 'select' | 'textinput' | 'textarea' | 'numberinput' | 'switch' | 'json';
+/** Rendering hint for a single field within a section. */
+interface StepConfigFieldHint<T> {
+    /** Typed dotted path into T — typo = TS error. */
+    path: FieldPath<T>;
+    /** Mantine component to render for this field. */
+    component: StepConfigComponent;
+    /** Overrides the field label derived from Zod .describe() or the key name. */
+    label?: string;
+    /** Help text shown below the field; overrides Zod .describe(). */
+    description?: string;
+    placeholder?: string;
+    /** Required for 'segmented', 'select', 'multiselect'; ignored for others. */
+    options?: ReadonlyArray<{
+        value: string;
+        label: string;
+    }>;
+    /** Minimum value — applies to 'numberinput'. */
+    min?: number;
+    /** Maximum value — applies to 'numberinput'. */
+    max?: number;
+    /** Stepper increment — applies to 'numberinput'. */
+    step?: number;
+    /** Per-field conditional visibility, evaluated against current form values. */
+    when?: (values: T) => boolean;
+}
+/** An ordered group of fields, optionally shown conditionally. */
+interface StepConfigSection<T> {
+    /** Stable key used for React rendering. */
+    id: string;
+    /** Section heading; omit for the top-level (untitled) section. */
+    title?: string;
+    description?: string;
+    /** Section-level conditional visibility predicate. */
+    when?: (values: T) => boolean;
+    /** Fields rendered in order within this section. */
+    fields: StepConfigFieldHint<T>[];
+}
+/** Top-level layout descriptor supplied by a per-integration registry entry. */
+interface StepConfigLayout<T> {
+    /** Ordered top-level sections of the form. */
+    sections: StepConfigSection<T>[];
+    /** Optional single Advanced collapse rendered below all sections. */
+    advanced?: StepConfigSection<T>;
+}
+
 type ListBuilderWorkflowCategory = 'build' | 'enrich' | 'qualify' | 'scrape' | 'utility';
 type LeadGenStageKey = string;
 type LeadGenCapabilityKey = string;
-interface ListBuilderWorkflowFormProps {
-    list: AcqListResponse;
-    onSubmit: (input: unknown) => void | Promise<void>;
-}
 interface ListBuilderWorkflow {
     resourceId: string;
     workflowId?: string;
@@ -3058,7 +3111,8 @@ interface ListBuilderWorkflow {
     description: string;
     category: ListBuilderWorkflowCategory;
     stagesAffected: readonly LeadGenStageKey[];
-    inputForm?: ComponentType<ListBuilderWorkflowFormProps>;
+    schema: z.ZodTypeAny;
+    layout: StepConfigLayout<any>;
     defaultInput?: (list: AcqListResponse) => unknown;
 }
 type ListBuilderRegistry = readonly ListBuilderWorkflow[];

package/dist/app/index.js

@@ -1,12 +1,13 @@
-import { ElevasisUIProvider } from '../chunk-MU4VPAMR.js';
-import '../chunk-QIW6OCEI.js';
+import { ElevasisUIProvider } from '../chunk-JPGX3533.js';
+import '../chunk-LH4GPYDX.js';
+import '../chunk-HLFFKKT3.js';
 import '../chunk-WLOQ4IBG.js';
-import '../chunk-JMI7L7Y7.js';
+import '../chunk-W2ZTLH7Y.js';
 import '../chunk-SZHARWKU.js';
-import '../chunk-T6INEVX6.js';
+import '../chunk-SGS4CQ2B.js';
 import '../chunk-HOIT677G.js';
 import '../chunk-E565XMTQ.js';
-import '../chunk-SGXXJE52.js';
+import '../chunk-QD4X4H5A.js';
 import '../chunk-KRWALB24.js';
 import { useInitialization } from '../chunk-WKJ47GIW.js';
 import '../chunk-DD3CCMCZ.js';

package/dist/charts/index.js

@@ -1,13 +1,14 @@
-export { ActivityTrendChart, ChartFrame, CombinedTrendChart, CostTrendChart, CyberAreaChart, CyberDonut, CyberDonutTooltip, CyberLegendItem, HeroStatsRow, getSeriesColor, useCyberColors } from '../chunk-KMAXFJPH.js';
+export { ActivityTrendChart, ChartFrame, CombinedTrendChart, CostTrendChart, HeroStatsRow } from '../chunk-OGXKOMUT.js';
+export { CyberAreaChart, CyberDonut, CyberDonutTooltip, CyberLegendItem, getSeriesColor, useCyberColors } from '../chunk-CW3UNAF2.js';
 import '../chunk-VKMNWHTL.js';
-import '../chunk-U36X6NZM.js';
-import '../chunk-NYBEU5TE.js';
-import '../chunk-SZHARWKU.js';
+import '../chunk-RIFTUOPE.js';
 import '../chunk-3KMDHCAR.js';
+import '../chunk-SZHARWKU.js';
+import '../chunk-NYBEU5TE.js';
 import '../chunk-2IFYDILW.js';
 import '../chunk-Q7DJKLEN.js';
 import '../chunk-DT3QYZVU.js';
-import '../chunk-SGXXJE52.js';
+import '../chunk-QD4X4H5A.js';
 import '../chunk-KRWALB24.js';
 import '../chunk-WFTNY755.js';
 import '../chunk-WKJ47GIW.js';

package/dist/chunk-3MEXPLWT.js

@@ -0,0 +1,265 @@
+import { TextInput, Textarea, Radio, Stack, Checkbox, Select, NumberInput, Button } from '@mantine/core';
+import { useForm } from '@mantine/form';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { z } from 'zod';
+
+// src/components/forms/ZodFormRenderer.tsx
+function FormFieldRenderer({ field, form, richTextRenderer }) {
+  const commonProps = {
+    label: field.label,
+    description: field.description,
+    placeholder: field.placeholder,
+    required: field.required,
+    ...form.getInputProps(field.name)
+  };
+  switch (field.type) {
+    case "text":
+      return /* @__PURE__ */ jsx(TextInput, { ...commonProps });
+    case "textarea":
+      return /* @__PURE__ */ jsx(Textarea, { ...commonProps, minRows: 3, autosize: true });
+    case "number":
+      return /* @__PURE__ */ jsx(NumberInput, { ...commonProps, min: field.min, max: field.max });
+    case "select":
+      return /* @__PURE__ */ jsx(
+        Select,
+        {
+          ...commonProps,
+          data: field.options?.map((opt) => ({
+            label: opt.label,
+            value: String(opt.value)
+          })) || []
+        }
+      );
+    case "checkbox":
+      return /* @__PURE__ */ jsx(Checkbox, { ...commonProps, ...form.getInputProps(field.name, { type: "checkbox" }) });
+    case "radio":
+      return /* @__PURE__ */ jsx(Radio.Group, { ...commonProps, children: /* @__PURE__ */ jsx(Stack, { gap: "xs", children: field.options?.map((opt) => /* @__PURE__ */ jsx(Radio, { value: String(opt.value), label: opt.label }, opt.value)) }) });
+    case "richtext": {
+      const inputProps = form.getInputProps(field.name);
+      if (richTextRenderer) {
+        return richTextRenderer({
+          content: inputProps.value || "",
+          onChange: (content) => form.setFieldValue(field.name, content),
+          placeholder: field.placeholder
+        });
+      }
+      return /* @__PURE__ */ jsx(Textarea, { ...commonProps, minRows: 5, autosize: true });
+    }
+    default:
+      return /* @__PURE__ */ jsx(TextInput, { ...commonProps });
+  }
+}
+function toJsonSchema(zodSchema) {
+  return z.toJSONSchema(zodSchema);
+}
+function humanizeKey(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
+}
+function unwrapNullable(schema) {
+  if (Array.isArray(schema.anyOf)) {
+    const nonNull = schema.anyOf.filter((s) => s.type !== "null");
+    if (nonNull.length === 1) return { ...nonNull[0], description: schema.description ?? nonNull[0].description };
+  }
+  return schema;
+}
+function defaultForLeaf(schema) {
+  if (schema.default !== void 0) return schema.default;
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) return schema.enum[0];
+  switch (schema.type) {
+    case "string":
+      return "";
+    case "integer":
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return schema.properties ? extractDefaults(schema) : {};
+    default:
+      return void 0;
+  }
+}
+function extractDefaults(jsonSchema) {
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) return {};
+  const result = {};
+  for (const [key, propSchema] of Object.entries(jsonSchema.properties)) {
+    result[key] = defaultForLeaf(unwrapNullable(propSchema));
+  }
+  return result;
+}
+function propSchemaToFormField(name, raw, required) {
+  const schema = unwrapNullable(raw);
+  const label = humanizeKey(name);
+  const description = schema.description ?? "";
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    const values = schema.enum.filter((v) => typeof v === "string" || typeof v === "number");
+    return {
+      name,
+      label,
+      type: "select",
+      required,
+      placeholder: "",
+      description,
+      options: values.map((v) => ({ label: String(v), value: typeof v === "number" ? v : String(v) })),
+      defaultValue: schema.default ?? values[0]
+    };
+  }
+  switch (schema.type) {
+    case "string": {
+      const isLong = (schema.maxLength ?? 0) > 200;
+      return {
+        name,
+        label,
+        type: isLong ? "textarea" : "text",
+        required,
+        placeholder: "",
+        description,
+        defaultValue: schema.default ?? ""
+      };
+    }
+    case "number":
+    case "integer": {
+      const field = {
+        name,
+        label,
+        type: "number",
+        required,
+        placeholder: "",
+        description,
+        defaultValue: schema.default ?? 0
+      };
+      if (typeof schema.minimum === "number" && schema.minimum > Number.MIN_SAFE_INTEGER) field.min = schema.minimum;
+      if (typeof schema.maximum === "number" && schema.maximum < Number.MAX_SAFE_INTEGER) field.max = schema.maximum;
+      return field;
+    }
+    case "boolean":
+      return {
+        name,
+        label,
+        type: "checkbox",
+        required,
+        placeholder: "",
+        description,
+        defaultValue: schema.default ?? false
+      };
+    default:
+      return null;
+  }
+}
+function jsonSchemaToFormFields(jsonSchema) {
+  const fields = [];
+  const initialValues = {};
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) {
+    fields.push({ name: "__input__", label: "Input (JSON)", fallback: true });
+    initialValues["__input__"] = jsonSchema.default !== void 0 ? JSON.stringify(jsonSchema.default, null, 2) : "";
+    return { fields, initialValues, isObject: false };
+  }
+  const required = new Set(jsonSchema.required ?? []);
+  for (const [name, propSchemaRaw] of Object.entries(jsonSchema.properties)) {
+    const propSchema = unwrapNullable(propSchemaRaw);
+    const isRequired = required.has(name) && propSchema.default === void 0;
+    const formField = propSchemaToFormField(name, propSchema, isRequired);
+    if (formField) {
+      fields.push(formField);
+      initialValues[name] = propSchema.default ?? formField.defaultValue;
+    } else {
+      fields.push({ name, label: humanizeKey(name), fallback: true });
+      initialValues[name] = propSchema.default !== void 0 ? JSON.stringify(propSchema.default, null, 2) : "";
+    }
+  }
+  return { fields, initialValues, isObject: true };
+}
+function sanitizeInput(schema, value) {
+  const jsonSchema = toJsonSchema(schema);
+  const emptyParse = schema.safeParse({});
+  const baseDefaults = emptyParse.success && emptyParse.data && typeof emptyParse.data === "object" && !Array.isArray(emptyParse.data) ? emptyParse.data : extractDefaults(jsonSchema);
+  if (value === null || value === void 0 || typeof value !== "object" || Array.isArray(value)) {
+    return baseDefaults;
+  }
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) {
+    const parsed = schema.safeParse(value);
+    return parsed.success && parsed.data && typeof parsed.data === "object" && !Array.isArray(parsed.data) ? parsed.data : baseDefaults;
+  }
+  const raw = value;
+  const result = { ...baseDefaults };
+  if (schema instanceof z.ZodObject) {
+    const shape = schema.shape;
+    for (const key of Object.keys(jsonSchema.properties)) {
+      if (key in raw && shape[key]) {
+        const fieldParsed = shape[key].safeParse(raw[key]);
+        if (fieldParsed.success) {
+          result[key] = fieldParsed.data;
+        }
+      }
+    }
+  }
+  return result;
+}
+function ZodFormRenderer({
+  schema,
+  defaults,
+  onSubmit,
+  submitLabel = "Submit",
+  isPending = false
+}) {
+  const jsonSchema = toJsonSchema(schema);
+  const { fields, initialValues, isObject } = jsonSchemaToFormFields(jsonSchema);
+  const mergedInitialValues = { ...initialValues };
+  if (isObject && defaults) {
+    for (const [key, value] of Object.entries(defaults)) {
+      if (value !== void 0) mergedInitialValues[key] = value;
+    }
+  } else if (!isObject && defaults !== void 0) {
+    mergedInitialValues["__input__"] = JSON.stringify(defaults, null, 2);
+  }
+  const form = useForm({ initialValues: mergedInitialValues });
+  const handleSubmit = (values) => {
+    const coerced = {};
+    for (const field of fields) {
+      const raw = values[field.name];
+      if ("fallback" in field) {
+        try {
+          coerced[field.name] = raw !== "" && raw !== void 0 ? JSON.parse(raw) : void 0;
+        } catch {
+          coerced[field.name] = raw;
+        }
+      } else {
+        coerced[field.name] = raw;
+      }
+    }
+    const payload = isObject ? coerced : coerced["__input__"] ?? coerced;
+    const parsed = schema.safeParse(payload);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        const path = issue.path.join(".");
+        if (path) form.setFieldError(path, issue.message);
+      }
+      return;
+    }
+    void onSubmit(parsed.data);
+  };
+  return /* @__PURE__ */ jsx("form", { onSubmit: form.onSubmit(handleSubmit), children: /* @__PURE__ */ jsxs(Stack, { children: [
+    fields.map((field) => {
+      if ("fallback" in field) {
+        return /* @__PURE__ */ jsx(
+          Textarea,
+          {
+            label: field.label,
+            placeholder: "Enter JSON value",
+            minRows: 3,
+            autosize: true,
+            ...form.getInputProps(field.name),
+            error: form.errors[field.name]
+          },
+          field.name
+        );
+      }
+      return /* @__PURE__ */ jsx(FormFieldRenderer, { field, form }, field.name);
+    }),
+    /* @__PURE__ */ jsx(Button, { type: "submit", loading: isPending, fullWidth: true, children: submitLabel })
+  ] }) });
+}
+
+export { FormFieldRenderer, ZodFormRenderer, sanitizeInput };

package/dist/{chunk-IS53MXE4.js → chunk-4KTLOK7K.js}

@@ -1,4 +1,4 @@
-import { DisplayMetadataSchema, ModelIdSchema, DescriptionSchema } from './chunk-JMI7L7Y7.js';
+import { DisplayMetadataSchema, ModelIdSchema, DescriptionSchema } from './chunk-W2ZTLH7Y.js';
 import { z } from 'zod';
 
 var ProspectingLifecycleStageSchema = DisplayMetadataSchema.extend({