@surveystudio/node-registery 1.0.1 → 1.1.0

package/README.md

@@ -16,10 +16,28 @@ Use `/logic` for Worker, export, and server runtimes. It is intentionally React-
 
 Use `/runner` and `/builder` only in React runtimes. React is a peer dependency and is not bundled.
 
+## Logic Pipeline
+
+Every node logic module should expose the same pure, Worker-safe pipeline:
+
+```ts
+const value = logicRegistry.plainText.normalizeValue(rawAnswer, node.data, context);
+const validation = logicRegistry.plainText.validate(value, node.data, context);
+const columns = logicRegistry.plainText.extractValue(value, node.data, context);
+```
+
+Runner APIs should persist and queue normalized values. Export/projection APIs should read normalized values through `extractValue`.
+
 ## Current Status
 
 Migrated nodes:
 
+- `textInput`
+- `numberInput`
+- `emailInput`
+- `dateInput`
+- `multiInput`
+- `zipCodeInput`
 - `plainText`
 
 The registry contract test intentionally fails until all planned question nodes are migrated.

package/dist/builder.d.mts

@@ -1,6 +1,7 @@
-import { J as JsonValue } from './types-Bsz6x6iU.mjs';
-export { B as BuilderRegistry, h as CompleteBuilderRegistry, i as NodeBuilder, j as NodeBuilderProps, k as NodeCanvasProps, l as NodeManifest, P as PropertyField, m as PropertyFieldType, Q as QuestionNodeDefinition, S as SelectOption, n as defineBuilderRegistry, b as defineQuestionNode } from './types-Bsz6x6iU.mjs';
-import { P as PlainTextData } from './types-HCD7-TAw.mjs';
+export { B as BuilderRegistry, C as CompleteBuilderRegistry, N as NodeBuilder, a as NodeBuilderProps, b as NodeCanvasProps, Q as QuestionNodeDefinition, d as defineBuilderRegistry, c as defineQuestionNode } from './types-CgiAR_DF.mjs';
+import { J as JsonValue } from './coreTypes-YSpR0Oyh.mjs';
+export { N as NodeManifest, P as PropertyField, a as PropertyFieldType, S as SelectOption } from './coreTypes-YSpR0Oyh.mjs';
+import { P as PlainTextData, B as BaseTextData, M as MultiInputData, N as NumberInputData, T as TextInputData, Z as ZipCodeInputData } from './types-CjF8-OZi.mjs';
 import 'react';
 
 declare const plainTextBuilder: {
@@ -47,11 +48,275 @@ declare const plainTextManifest: {
     })[];
 };
 
+declare const textInputBuilder: {
+    type: "textInput";
+    label: string;
+};
+declare const emailInputBuilder: {
+    type: "emailInput";
+    label: string;
+};
+declare const dateInputBuilder: {
+    type: "dateInput";
+    label: string;
+};
+declare const numberInputBuilder: {
+    type: "numberInput";
+    label: string;
+};
+declare const zipCodeInputBuilder: {
+    type: "zipCodeInput";
+    label: string;
+};
+declare const multiInputBuilder: {
+    type: "multiInput";
+    label: string;
+};
+
+declare const textInputManifest: {
+    type: "textInput";
+    label: string;
+    description: string;
+    category: "input";
+    dataType: "text";
+    defaultData: TextInputData;
+    properties: ({
+        name: string;
+        label: string;
+        type: "text";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "textarea";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "condition";
+        defaultValue: {
+            id: string;
+            type: "group";
+            logicType: "AND";
+            children: never[];
+        };
+    } | {
+        name: string;
+        label: string;
+        type: "number";
+        helperText: string;
+        defaultValue: number;
+    } | {
+        name: string;
+        label: string;
+        type: "text";
+        placeholder: string;
+        defaultValue: string;
+    } | {
+        name: string;
+        label: string;
+        type: "switch";
+        defaultValue: false;
+        placeholder?: never;
+    })[];
+};
+declare const emailInputManifest: {
+    type: "emailInput";
+    label: string;
+    description: string;
+    category: "input";
+    dataType: "text";
+    defaultData: BaseTextData;
+    properties: ({
+        name: string;
+        label: string;
+        type: "text";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "textarea";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "condition";
+        defaultValue: {
+            id: string;
+            type: "group";
+            logicType: "AND";
+            children: never[];
+        };
+    })[];
+};
+declare const dateInputManifest: {
+    type: "dateInput";
+    label: string;
+    description: string;
+    category: "input";
+    dataType: "text";
+    defaultData: BaseTextData;
+    properties: ({
+        name: string;
+        label: string;
+        type: "text";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "textarea";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "condition";
+        defaultValue: {
+            id: string;
+            type: "group";
+            logicType: "AND";
+            children: never[];
+        };
+    })[];
+};
+declare const numberInputManifest: {
+    type: "numberInput";
+    label: string;
+    description: string;
+    category: "input";
+    dataType: "number";
+    defaultData: NumberInputData;
+    properties: ({
+        name: string;
+        label: string;
+        type: "text";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "textarea";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "condition";
+        defaultValue: {
+            id: string;
+            type: "group";
+            logicType: "AND";
+            children: never[];
+        };
+    } | {
+        name: string;
+        label: string;
+        type: "number";
+    })[];
+};
+declare const zipCodeInputManifest: {
+    type: "zipCodeInput";
+    label: string;
+    description: string;
+    category: "input";
+    dataType: "text";
+    defaultData: ZipCodeInputData;
+    properties: ({
+        name: string;
+        label: string;
+        type: "text";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "textarea";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "condition";
+        defaultValue: {
+            id: string;
+            type: "group";
+            logicType: "AND";
+            children: never[];
+        };
+    } | {
+        name: string;
+        label: string;
+        type: "fileTextarea";
+        placeholder: string;
+        helperText: string;
+    })[];
+};
+declare const multiInputManifest: {
+    type: "multiInput";
+    label: string;
+    description: string;
+    category: "input";
+    dataType: "object";
+    defaultData: MultiInputData;
+    properties: ({
+        name: string;
+        label: string;
+        type: "text";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "textarea";
+        defaultValue?: never;
+    } | {
+        name: string;
+        label: string;
+        type: "condition";
+        defaultValue: {
+            id: string;
+            type: "group";
+            logicType: "AND";
+            children: never[];
+        };
+    } | {
+        name: string;
+        label: string;
+        type: "number";
+        helperText: string;
+        defaultValue: number;
+    } | {
+        name: string;
+        label: string;
+        type: "options";
+        defaultValue: never[];
+        helperText: string;
+    })[];
+};
+
 declare const builderRegistry: {
+    readonly textInput: {
+        type: "textInput";
+        label: string;
+    };
+    readonly numberInput: {
+        type: "numberInput";
+        label: string;
+    };
+    readonly emailInput: {
+        type: "emailInput";
+        label: string;
+    };
+    readonly dateInput: {
+        type: "dateInput";
+        label: string;
+    };
+    readonly multiInput: {
+        type: "multiInput";
+        label: string;
+    };
+    readonly zipCodeInput: {
+        type: "zipCodeInput";
+        label: string;
+    };
     readonly plainText: {
         type: "plainText";
         label: string;
     };
 };
 
-export { builderRegistry, plainTextBuilder, plainTextManifest };
+export { builderRegistry, dateInputBuilder, dateInputManifest, emailInputBuilder, emailInputManifest, multiInputBuilder, multiInputManifest, numberInputBuilder, numberInputManifest, plainTextBuilder, plainTextManifest, textInputBuilder, textInputManifest, zipCodeInputBuilder, zipCodeInputManifest };

package/dist/builder.mjs

@@ -12,6 +12,14 @@ var plainTextBuilder = {
   label: "Info / Text"
 };
 
+// src/nodes/textLike/builder.ts
+var textInputBuilder = { type: "textInput", label: "Text Answer" };
+var emailInputBuilder = { type: "emailInput", label: "Email" };
+var dateInputBuilder = { type: "dateInput", label: "Date Picker" };
+var numberInputBuilder = { type: "numberInput", label: "Number" };
+var zipCodeInputBuilder = { type: "zipCodeInput", label: "Accepted Zip Codes" };
+var multiInputBuilder = { type: "multiInput", label: "Multi-Input" };
+
 // src/nodes/plainText/manifest.ts
 var plainTextDefaultData = {
   label: "Info / Text",
@@ -50,14 +58,157 @@ var plainTextManifest = {
   ]
 };
 
+// src/nodes/textLike/manifest.ts
+var defaultCondition = {
+  id: "root",
+  type: "group",
+  logicType: "AND",
+  children: []
+};
+var baseTextData = {
+  label: "",
+  description: "",
+  condition: defaultCondition,
+  minChars: 0,
+  maxChars: 0,
+  minWords: 0,
+  maxWords: 0
+};
+var commonProperties = [
+  { name: "label", label: "Field Label", type: "text" },
+  { name: "description", label: "Description", type: "textarea" },
+  {
+    name: "condition",
+    label: "Logic Rule",
+    type: "condition",
+    defaultValue: defaultCondition
+  }
+];
+var textLimitProperties = [
+  { name: "minChars", label: "Min Characters", type: "number", helperText: "Requires at least this many characters.", defaultValue: 0 },
+  { name: "maxChars", label: "Max Characters", type: "number", helperText: "Limits total characters. 0 or empty for no limit.", defaultValue: 0 },
+  { name: "minWords", label: "Min Words", type: "number", helperText: "Requires at least this many words.", defaultValue: 0 },
+  { name: "maxWords", label: "Max Words", type: "number", helperText: "Limits total words. 0 or empty for no limit.", defaultValue: 0 }
+];
+var createBaseData = (label) => ({
+  ...baseTextData,
+  label
+});
+var textInputDefaultData = {
+  ...createBaseData("Text Answer"),
+  placeholder: "",
+  longAnswer: false
+};
+var emailInputDefaultData = createBaseData("Email");
+var dateInputDefaultData = createBaseData("Date Picker");
+var numberInputDefaultData = {
+  ...createBaseData("Number")
+};
+var zipCodeInputDefaultData = {
+  ...createBaseData("Accepted Zip Codes"),
+  allowedZips: ""
+};
+var multiInputDefaultData = {
+  ...createBaseData("Multi-Input"),
+  fields: []
+};
+var textInputManifest = {
+  type: "textInput",
+  label: "Text Answer",
+  description: "Capture text responses",
+  category: "input",
+  dataType: "text",
+  defaultData: textInputDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "placeholder", label: "Placeholder", type: "text", placeholder: "e.g., Type here...", defaultValue: "" },
+    { name: "longAnswer", label: "Long Answer (Multi-line)", type: "switch", defaultValue: false },
+    ...textLimitProperties
+  ]
+};
+var emailInputManifest = {
+  type: "emailInput",
+  label: "Email",
+  description: "Validate email addresses",
+  category: "input",
+  dataType: "text",
+  defaultData: emailInputDefaultData,
+  properties: commonProperties
+};
+var dateInputManifest = {
+  type: "dateInput",
+  label: "Date Picker",
+  description: "Select dates from a calendar",
+  category: "input",
+  dataType: "text",
+  defaultData: dateInputDefaultData,
+  properties: commonProperties
+};
+var numberInputManifest = {
+  type: "numberInput",
+  label: "Number",
+  description: "Input for numerical values",
+  category: "input",
+  dataType: "number",
+  defaultData: numberInputDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "min", label: "Minimum Value", type: "number" },
+    { name: "max", label: "Maximum Value", type: "number" }
+  ]
+};
+var zipCodeInputManifest = {
+  type: "zipCodeInput",
+  label: "Accepted Zip Codes",
+  description: "Validate against a list of zip codes",
+  category: "input",
+  dataType: "text",
+  defaultData: zipCodeInputDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "allowedZips", label: "Allowed Zip Codes", type: "fileTextarea", placeholder: "10001, 10002, 90210... (Leave empty to allow all)", helperText: "Validation: Only users entering these zip codes can proceed. Others will be blocked." }
+  ]
+};
+var multiInputManifest = {
+  type: "multiInput",
+  label: "Multi-Input",
+  description: "Multiple fields in one screen",
+  category: "input",
+  dataType: "object",
+  defaultData: multiInputDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "fields", label: "Input Fields", type: "options", defaultValue: [], helperText: "Value column represents input type (text, number, email)" },
+    ...textLimitProperties
+  ]
+};
+
 // src/builder/index.ts
 var builderRegistry = defineBuilderRegistry({
+  textInput: textInputBuilder,
+  numberInput: numberInputBuilder,
+  emailInput: emailInputBuilder,
+  dateInput: dateInputBuilder,
+  multiInput: multiInputBuilder,
+  zipCodeInput: zipCodeInputBuilder,
   plainText: plainTextBuilder
 });
 export {
   builderRegistry,
+  dateInputBuilder,
+  dateInputManifest,
   defineBuilderRegistry,
   defineQuestionNode,
+  emailInputBuilder,
+  emailInputManifest,
+  multiInputBuilder,
+  multiInputManifest,
+  numberInputBuilder,
+  numberInputManifest,
   plainTextBuilder,
-  plainTextManifest
+  plainTextManifest,
+  textInputBuilder,
+  textInputManifest,
+  zipCodeInputBuilder,
+  zipCodeInputManifest
 };

package/dist/{types-Bsz6x6iU.d.mts → coreTypes-YSpR0Oyh.d.mts}

@@ -1,5 +1,3 @@
-import { ReactNode, ComponentType } from 'react';
-
 declare const QUESTION_NODE_TYPES: readonly ["textInput", "numberInput", "emailInput", "dateInput", "multiInput", "zipCodeInput", "singleChoice", "multipleChoice", "dropdown", "ranking", "cascadingChoice", "matrixChoice", "rating", "slider", "consent", "captcha", "image", "video", "audio", "plainText", "emojiRating"];
 declare const FLOW_NODE_TYPES: readonly ["start", "end", "branch", "validation"];
 type QuestionNodeType = (typeof QUESTION_NODE_TYPES)[number];
@@ -43,6 +41,14 @@ interface ValidationResult {
     readonly valid: boolean;
     readonly error?: string;
 }
+interface NodeLogicContext<TType extends SurveyNodeType = SurveyNodeType> {
+    readonly nodeId: string;
+    readonly nodeType: TType;
+    readonly answerKey?: string;
+}
+interface ValidationContext<TType extends SurveyNodeType = SurveyNodeType> extends NodeLogicContext<TType> {
+    readonly mode?: "LIVE" | "TEST";
+}
 interface ExtractedValue {
     readonly questionId?: string;
     readonly columnKey?: string;
@@ -56,9 +62,7 @@ interface ExtractedValue {
     readonly objectValue?: Readonly<Record<string, JsonValue>>;
     readonly metadata?: Readonly<Record<string, JsonValue>>;
 }
-interface ExtractionContext<TType extends SurveyNodeType = SurveyNodeType> {
-    readonly nodeId: string;
-    readonly nodeType: TType;
+interface ExtractionContext<TType extends SurveyNodeType = SurveyNodeType> extends NodeLogicContext<TType> {
     readonly questionLabel?: string;
 }
 interface NodeLogic<TType extends SurveyNodeType = SurveyNodeType, TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
@@ -66,60 +70,16 @@ interface NodeLogic<TType extends SurveyNodeType = SurveyNodeType, TData extends
     readonly dataType: DataType;
     readonly defaultData: Readonly<TData>;
     readonly defaultValue?: TValue;
-    validate(value: TValue, nodeData: Readonly<TData>): ValidationResult;
+    normalizeValue(rawValue: unknown, nodeData: Readonly<TData>, context: NodeLogicContext<TType>): TValue;
+    validate(value: TValue, nodeData: Readonly<TData>, context: ValidationContext<TType>): ValidationResult;
     extractValue(value: TValue, nodeData: Readonly<TData>, context: ExtractionContext<TType>): readonly ExtractedValue[];
 }
-interface NodeRunnerProps<TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
-    readonly data: Readonly<TData>;
-    readonly value: TValue;
-    readonly onChange: (newValue: TValue) => void;
-    readonly onNext?: () => void;
-    readonly error?: string;
-    readonly isActive?: boolean;
-}
-interface NodeRunner<TType extends SurveyNodeType = SurveyNodeType, TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
-    readonly type: TType;
-    readonly Component?: ComponentType<NodeRunnerProps<TData, TValue>>;
-}
-interface NodeBuilderProps<TData extends NodeData = NodeData> {
-    readonly data: Readonly<TData>;
-    readonly onChange: (newData: TData) => void;
-}
-interface NodeCanvasProps<TData extends NodeData = NodeData> {
-    readonly id: string;
-    readonly type: SurveyNodeType;
-    readonly data: Readonly<TData>;
-    readonly selected?: boolean;
-}
-interface NodeBuilder<TType extends SurveyNodeType = SurveyNodeType, TData extends NodeData = NodeData> {
-    readonly type: TType;
-    readonly label: string;
-    readonly icon?: ReactNode;
-    readonly SettingsComponent?: ComponentType<NodeBuilderProps<TData>>;
-    readonly CanvasComponent?: ComponentType<NodeCanvasProps<TData>>;
-}
-interface QuestionNodeDefinition<TType extends QuestionNodeType = QuestionNodeType, TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
-    readonly manifest: NodeManifest<TType, TData>;
-    readonly logic: NodeLogic<TType, TData, TValue>;
-    readonly builder: NodeBuilder<TType, TData>;
-    readonly runner: NodeRunner<TType, TData, TValue>;
-}
 type CompleteLogicRegistry<TType extends QuestionNodeType = QuestionNodeType> = Readonly<Record<TType, NodeLogic<TType, NodeData, NodeValue>>>;
-type CompleteBuilderRegistry<TType extends QuestionNodeType = QuestionNodeType> = Readonly<Record<TType, NodeBuilder<TType, NodeData>>>;
-type CompleteRunnerRegistry<TType extends QuestionNodeType = QuestionNodeType> = Readonly<Record<TType, NodeRunner<TType, NodeData, NodeValue>>>;
 type LogicRegistry<TType extends SurveyNodeType = SurveyNodeType> = Readonly<Partial<{
     [K in TType]: NodeLogic<K, NodeData, NodeValue>;
 }>>;
-type BuilderRegistry<TType extends SurveyNodeType = SurveyNodeType> = Readonly<Partial<{
-    [K in TType]: NodeBuilder<K, NodeData>;
-}>>;
-type RunnerRegistry<TType extends SurveyNodeType = SurveyNodeType> = Readonly<Partial<{
-    [K in TType]: NodeRunner<K, NodeData, NodeValue>;
-}>>;
-declare function defineQuestionNode<const TType extends QuestionNodeType, TData extends NodeData, TValue extends NodeValue>(definition: QuestionNodeDefinition<TType, TData, TValue>): QuestionNodeDefinition<TType, TData, TValue>;
 type RegistryKeySet = Readonly<Partial<Record<SurveyNodeType, unknown>>>;
 declare function defineLogicRegistry<const TRegistry extends RegistryKeySet>(registry: TRegistry): TRegistry;
-declare function defineBuilderRegistry<const TRegistry extends RegistryKeySet>(registry: TRegistry): TRegistry;
-declare function defineRunnerRegistry<const TRegistry extends RegistryKeySet>(registry: TRegistry): TRegistry;
+declare function createInitialData<TData extends NodeData>(manifest: NodeManifest<SurveyNodeType, TData>): TData;
 
-export { type BuilderRegistry as B, type CompleteLogicRegistry as C, type DataType as D, type ExtractedValue as E, type JsonValue as J, type LogicRegistry as L, type NodeLogic as N, type PropertyField as P, type QuestionNodeDefinition as Q, type RunnerRegistry as R, type SelectOption as S, type ValidationResult as V, type ExtractionContext as a, defineQuestionNode as b, type CompleteRunnerRegistry as c, defineLogicRegistry as d, type NodeRunner as e, type NodeRunnerProps as f, defineRunnerRegistry as g, type CompleteBuilderRegistry as h, type NodeBuilder as i, type NodeBuilderProps as j, type NodeCanvasProps as k, type NodeManifest as l, type PropertyFieldType as m, defineBuilderRegistry as n, type NodeData as o };
+export { type CompleteLogicRegistry as C, type DataType as D, type ExtractedValue as E, type JsonValue as J, type LogicRegistry as L, type NodeManifest as N, type PropertyField as P, type QuestionNodeType as Q, type SelectOption as S, type ValidationContext as V, type PropertyFieldType as a, type NodeLogic as b, type ExtractionContext as c, type NodeLogicContext as d, type ValidationResult as e, createInitialData as f, defineLogicRegistry as g, type NodeData as h, type SurveyNodeType as i, type NodeValue as j };

package/dist/logic.d.mts

@@ -1,41 +1,24 @@
-import { P as PlainTextData, a as PlainTextValue } from './types-HCD7-TAw.mjs';
-export { C as CompleteLogicRegistry, D as DataType, E as ExtractedValue, a as ExtractionContext, L as LogicRegistry, N as NodeLogic, Q as QuestionNodeDefinition, V as ValidationResult, d as defineLogicRegistry, b as defineQuestionNode } from './types-Bsz6x6iU.mjs';
-import 'react';
+import { P as PlainTextData, a as PlainTextValue, D as DateInputData, b as TextValue, E as EmailInputData, M as MultiInputData, c as MultiInputValue, N as NumberInputData, T as TextInputData, Z as ZipCodeInputData, B as BaseTextData } from './types-CjF8-OZi.mjs';
+import { b as NodeLogic } from './coreTypes-YSpR0Oyh.mjs';
+export { C as CompleteLogicRegistry, D as DataType, E as ExtractedValue, c as ExtractionContext, L as LogicRegistry, d as NodeLogicContext, V as ValidationContext, e as ValidationResult, f as createInitialData, g as defineLogicRegistry } from './coreTypes-YSpR0Oyh.mjs';
 
-declare const plainTextLogic: {
-    type: "plainText";
-    dataType: "none";
-    defaultData: PlainTextData;
-    defaultValue: {
-        viewed: false;
-    };
-    validate: () => {
-        valid: true;
-    };
-    extractValue: (value: PlainTextValue) => {
-        columnKey: string;
-        columnLabel: string;
-        booleanValue: boolean;
-    }[];
-};
+declare const plainTextLogic: NodeLogic<"plainText", PlainTextData, PlainTextValue>;
+
+declare const textInputLogic: NodeLogic<"textInput", TextInputData, TextValue>;
+declare const emailInputLogic: NodeLogic<"emailInput", EmailInputData, TextValue>;
+declare const dateInputLogic: NodeLogic<"dateInput", DateInputData, TextValue>;
+declare const numberInputLogic: NodeLogic<"numberInput", NumberInputData, TextValue>;
+declare const zipCodeInputLogic: NodeLogic<"zipCodeInput", ZipCodeInputData, TextValue>;
+declare const multiInputLogic: NodeLogic<"multiInput", MultiInputData, MultiInputValue>;
 
 declare const logicRegistry: {
-    readonly plainText: {
-        type: "plainText";
-        dataType: "none";
-        defaultData: PlainTextData;
-        defaultValue: {
-            viewed: false;
-        };
-        validate: () => {
-            valid: true;
-        };
-        extractValue: (value: PlainTextValue) => {
-            columnKey: string;
-            columnLabel: string;
-            booleanValue: boolean;
-        }[];
-    };
+    readonly textInput: NodeLogic<"textInput", TextInputData, string>;
+    readonly numberInput: NodeLogic<"numberInput", NumberInputData, string>;
+    readonly emailInput: NodeLogic<"emailInput", BaseTextData, string>;
+    readonly dateInput: NodeLogic<"dateInput", BaseTextData, string>;
+    readonly multiInput: NodeLogic<"multiInput", MultiInputData, MultiInputValue>;
+    readonly zipCodeInput: NodeLogic<"zipCodeInput", ZipCodeInputData, string>;
+    readonly plainText: NodeLogic<"plainText", PlainTextData, PlainTextValue>;
 };
 
-export { logicRegistry, plainTextLogic };
+export { NodeLogic, dateInputLogic, emailInputLogic, logicRegistry, multiInputLogic, numberInputLogic, plainTextLogic, textInputLogic, zipCodeInputLogic };

package/dist/logic.mjs

@@ -1,10 +1,10 @@
-// src/types.ts
-function defineQuestionNode(definition) {
-  return definition;
-}
+// src/coreTypes.ts
 function defineLogicRegistry(registry) {
   return registry;
 }
+function createInitialData(manifest) {
+  return { ...manifest.defaultData };
+}
 
 // src/nodes/plainText/manifest.ts
 var plainTextDefaultData = {
@@ -45,28 +45,309 @@ var plainTextManifest = {
 };
 
 // src/nodes/plainText/logic.ts
+var normalizePlainTextValue = (value) => {
+  if (!value || typeof value !== "object") {
+    return { viewed: false };
+  }
+  return { viewed: Boolean(value.viewed) };
+};
 var plainTextLogic = {
   type: "plainText",
   dataType: "none",
   defaultData: plainTextDefaultData,
   defaultValue: { viewed: false },
+  normalizeValue: (value) => normalizePlainTextValue(value),
   validate: () => ({ valid: true }),
   extractValue: (value) => [
     {
       columnKey: "viewed",
       columnLabel: "Viewed",
-      booleanValue: Boolean(value?.viewed)
+      booleanValue: Boolean(value.viewed)
+    }
+  ]
+};
+
+// src/nodes/textLike/manifest.ts
+var defaultCondition = {
+  id: "root",
+  type: "group",
+  logicType: "AND",
+  children: []
+};
+var baseTextData = {
+  label: "",
+  description: "",
+  condition: defaultCondition,
+  minChars: 0,
+  maxChars: 0,
+  minWords: 0,
+  maxWords: 0
+};
+var commonProperties = [
+  { name: "label", label: "Field Label", type: "text" },
+  { name: "description", label: "Description", type: "textarea" },
+  {
+    name: "condition",
+    label: "Logic Rule",
+    type: "condition",
+    defaultValue: defaultCondition
+  }
+];
+var textLimitProperties = [
+  { name: "minChars", label: "Min Characters", type: "number", helperText: "Requires at least this many characters.", defaultValue: 0 },
+  { name: "maxChars", label: "Max Characters", type: "number", helperText: "Limits total characters. 0 or empty for no limit.", defaultValue: 0 },
+  { name: "minWords", label: "Min Words", type: "number", helperText: "Requires at least this many words.", defaultValue: 0 },
+  { name: "maxWords", label: "Max Words", type: "number", helperText: "Limits total words. 0 or empty for no limit.", defaultValue: 0 }
+];
+var createBaseData = (label) => ({
+  ...baseTextData,
+  label
+});
+var textInputDefaultData = {
+  ...createBaseData("Text Answer"),
+  placeholder: "",
+  longAnswer: false
+};
+var emailInputDefaultData = createBaseData("Email");
+var dateInputDefaultData = createBaseData("Date Picker");
+var numberInputDefaultData = {
+  ...createBaseData("Number")
+};
+var zipCodeInputDefaultData = {
+  ...createBaseData("Accepted Zip Codes"),
+  allowedZips: ""
+};
+var multiInputDefaultData = {
+  ...createBaseData("Multi-Input"),
+  fields: []
+};
+var textInputManifest = {
+  type: "textInput",
+  label: "Text Answer",
+  description: "Capture text responses",
+  category: "input",
+  dataType: "text",
+  defaultData: textInputDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "placeholder", label: "Placeholder", type: "text", placeholder: "e.g., Type here...", defaultValue: "" },
+    { name: "longAnswer", label: "Long Answer (Multi-line)", type: "switch", defaultValue: false },
+    ...textLimitProperties
+  ]
+};
+var numberInputManifest = {
+  type: "numberInput",
+  label: "Number",
+  description: "Input for numerical values",
+  category: "input",
+  dataType: "number",
+  defaultData: numberInputDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "min", label: "Minimum Value", type: "number" },
+    { name: "max", label: "Maximum Value", type: "number" }
+  ]
+};
+var zipCodeInputManifest = {
+  type: "zipCodeInput",
+  label: "Accepted Zip Codes",
+  description: "Validate against a list of zip codes",
+  category: "input",
+  dataType: "text",
+  defaultData: zipCodeInputDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "allowedZips", label: "Allowed Zip Codes", type: "fileTextarea", placeholder: "10001, 10002, 90210... (Leave empty to allow all)", helperText: "Validation: Only users entering these zip codes can proceed. Others will be blocked." }
+  ]
+};
+var multiInputManifest = {
+  type: "multiInput",
+  label: "Multi-Input",
+  description: "Multiple fields in one screen",
+  category: "input",
+  dataType: "object",
+  defaultData: multiInputDefaultData,
+  properties: [
+    ...commonProperties,
+    { name: "fields", label: "Input Fields", type: "options", defaultValue: [], helperText: "Value column represents input type (text, number, email)" },
+    ...textLimitProperties
+  ]
+};
+
+// src/nodes/textLike/logic.ts
+var normalizeTextValue = (value) => {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "";
+};
+var normalizeMultiInputValue = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [key, normalizeTextValue(item)])
+  );
+};
+var numberLimit = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+};
+var countWords = (value) => value.trim().split(/\s+/).filter(Boolean).length;
+var validateTextLimits = (value, nodeData) => {
+  const minChars = numberLimit(nodeData.minChars);
+  const maxChars = numberLimit(nodeData.maxChars);
+  const minWords = numberLimit(nodeData.minWords);
+  const maxWords = numberLimit(nodeData.maxWords);
+  if (minChars && value.length < minChars) {
+    return { valid: false, error: `Minimum character requirement not met (${value.length}/${minChars})` };
+  }
+  if (maxChars && value.length > maxChars) {
+    return { valid: false, error: `Character limit exceeded (${value.length}/${maxChars})` };
+  }
+  const wordCount = countWords(value);
+  if (minWords && wordCount < minWords) {
+    return { valid: false, error: `Minimum word requirement not met (${wordCount}/${minWords})` };
+  }
+  if (maxWords && wordCount > maxWords) {
+    return { valid: false, error: `Word limit exceeded (${wordCount}/${maxWords})` };
+  }
+  return { valid: true };
+};
+var extractTextValue = (value) => [
+  {
+    columnKey: "value",
+    columnLabel: "Value",
+    textValue: value
+  }
+];
+var emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var textInputLogic = {
+  type: "textInput",
+  dataType: "text",
+  defaultData: textInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: validateTextLimits,
+  extractValue: extractTextValue
+};
+var emailInputLogic = {
+  type: "emailInput",
+  dataType: "text",
+  defaultData: emailInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: (value, nodeData) => {
+    const limitResult = validateTextLimits(value, nodeData);
+    if (!limitResult.valid) return limitResult;
+    if (value.trim() && !emailRegex.test(value)) return { valid: false, error: "Please enter a valid email address" };
+    return { valid: true };
+  },
+  extractValue: extractTextValue
+};
+var dateInputLogic = {
+  type: "dateInput",
+  dataType: "text",
+  defaultData: dateInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: validateTextLimits,
+  extractValue: extractTextValue
+};
+var numberInputLogic = {
+  type: "numberInput",
+  dataType: "number",
+  defaultData: numberInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: (value, nodeData) => {
+    const limitResult = validateTextLimits(value, nodeData);
+    if (!limitResult.valid) return limitResult;
+    if (!value.trim()) return { valid: true };
+    const numberValue = Number(value);
+    if (Number.isNaN(numberValue)) return { valid: false, error: "Please enter a valid number" };
+    if (typeof nodeData.min === "number" && numberValue < nodeData.min) {
+      return { valid: false, error: `Minimum value is ${nodeData.min}` };
+    }
+    if (typeof nodeData.max === "number" && numberValue > nodeData.max) {
+      return { valid: false, error: `Maximum value is ${nodeData.max}` };
+    }
+    return { valid: true };
+  },
+  extractValue: (value) => [
+    value.trim() ? {
+      columnKey: "value",
+      columnLabel: "Value",
+      textValue: value,
+      numberValue: Number(value)
+    } : {
+      columnKey: "value",
+      columnLabel: "Value",
+      textValue: value
     }
   ]
 };
+var parseZipList = (value) => value.split(/[\s,]+/).map((item) => item.trim()).filter(Boolean);
+var zipCodeInputLogic = {
+  type: "zipCodeInput",
+  dataType: "text",
+  defaultData: zipCodeInputDefaultData,
+  defaultValue: "",
+  normalizeValue: normalizeTextValue,
+  validate: (value, nodeData) => {
+    const limitResult = validateTextLimits(value, nodeData);
+    if (!limitResult.valid) return limitResult;
+    const allowedZips = parseZipList(String(nodeData.allowedZips || ""));
+    if (allowedZips.length > 0 && value.trim() && !allowedZips.includes(value.trim())) {
+      return { valid: false, error: "Zip code is not accepted" };
+    }
+    return { valid: true };
+  },
+  extractValue: extractTextValue
+};
+var multiInputLogic = {
+  type: "multiInput",
+  dataType: "object",
+  defaultData: multiInputDefaultData,
+  defaultValue: {},
+  normalizeValue: normalizeMultiInputValue,
+  validate: (value, nodeData) => {
+    for (const [fieldId, fieldValue] of Object.entries(value)) {
+      const limitResult = validateTextLimits(fieldValue, nodeData);
+      if (!limitResult.valid) return { valid: false, error: `${fieldId}: ${limitResult.error}` };
+    }
+    return { valid: true };
+  },
+  extractValue: (value, nodeData) => {
+    const fields = Array.isArray(nodeData.fields) ? nodeData.fields : [];
+    return Object.entries(value).map(([fieldId, fieldValue]) => {
+      const field = fields.find((item) => item.id === fieldId);
+      const label = field?.label || fieldId;
+      return {
+        columnKey: fieldId,
+        columnLabel: label,
+        textValue: fieldValue
+      };
+    });
+  }
+};
 
 // src/logic/index.ts
 var logicRegistry = defineLogicRegistry({
+  textInput: textInputLogic,
+  numberInput: numberInputLogic,
+  emailInput: emailInputLogic,
+  dateInput: dateInputLogic,
+  multiInput: multiInputLogic,
+  zipCodeInput: zipCodeInputLogic,
   plainText: plainTextLogic
 });
 export {
+  createInitialData,
+  dateInputLogic,
   defineLogicRegistry,
-  defineQuestionNode,
+  emailInputLogic,
   logicRegistry,
-  plainTextLogic
+  multiInputLogic,
+  numberInputLogic,
+  plainTextLogic,
+  textInputLogic,
+  zipCodeInputLogic
 };

package/dist/runner.d.mts

@@ -1,14 +1,52 @@
-export { c as CompleteRunnerRegistry, e as NodeRunner, f as NodeRunnerProps, Q as QuestionNodeDefinition, R as RunnerRegistry, b as defineQuestionNode, g as defineRunnerRegistry } from './types-Bsz6x6iU.mjs';
+export { e as CompleteRunnerRegistry, f as NodeRunner, g as NodeRunnerProps, Q as QuestionNodeDefinition, R as RunnerRegistry, c as defineQuestionNode, h as defineRunnerRegistry } from './types-CgiAR_DF.mjs';
 import 'react';
+import './coreTypes-YSpR0Oyh.mjs';
 
 declare const plainTextRunner: {
     type: "plainText";
 };
 
+declare const textInputRunner: {
+    type: "textInput";
+};
+declare const emailInputRunner: {
+    type: "emailInput";
+};
+declare const dateInputRunner: {
+    type: "dateInput";
+};
+declare const numberInputRunner: {
+    type: "numberInput";
+};
+declare const zipCodeInputRunner: {
+    type: "zipCodeInput";
+};
+declare const multiInputRunner: {
+    type: "multiInput";
+};
+
 declare const runnerRegistry: {
+    readonly textInput: {
+        type: "textInput";
+    };
+    readonly numberInput: {
+        type: "numberInput";
+    };
+    readonly emailInput: {
+        type: "emailInput";
+    };
+    readonly dateInput: {
+        type: "dateInput";
+    };
+    readonly multiInput: {
+        type: "multiInput";
+    };
+    readonly zipCodeInput: {
+        type: "zipCodeInput";
+    };
     readonly plainText: {
         type: "plainText";
     };
 };
 
-export { plainTextRunner, runnerRegistry };
+export { dateInputRunner, emailInputRunner, multiInputRunner, numberInputRunner, plainTextRunner, runnerRegistry, textInputRunner, zipCodeInputRunner };

package/dist/runner.mjs

@@ -11,13 +11,33 @@ var plainTextRunner = {
   type: "plainText"
 };
 
+// src/nodes/textLike/runner.ts
+var textInputRunner = { type: "textInput" };
+var emailInputRunner = { type: "emailInput" };
+var dateInputRunner = { type: "dateInput" };
+var numberInputRunner = { type: "numberInput" };
+var zipCodeInputRunner = { type: "zipCodeInput" };
+var multiInputRunner = { type: "multiInput" };
+
 // src/runner/index.ts
 var runnerRegistry = defineRunnerRegistry({
+  textInput: textInputRunner,
+  numberInput: numberInputRunner,
+  emailInput: emailInputRunner,
+  dateInput: dateInputRunner,
+  multiInput: multiInputRunner,
+  zipCodeInput: zipCodeInputRunner,
   plainText: plainTextRunner
 });
 export {
+  dateInputRunner,
   defineQuestionNode,
   defineRunnerRegistry,
+  emailInputRunner,
+  multiInputRunner,
+  numberInputRunner,
   plainTextRunner,
-  runnerRegistry
+  runnerRegistry,
+  textInputRunner,
+  zipCodeInputRunner
 };

package/dist/types-CgiAR_DF.d.mts

@@ -0,0 +1,51 @@
+import { ReactNode, ComponentType } from 'react';
+import { i as SurveyNodeType, h as NodeData, Q as QuestionNodeType, j as NodeValue, N as NodeManifest, b as NodeLogic } from './coreTypes-YSpR0Oyh.mjs';
+
+interface NodeRunnerProps<TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
+    readonly data: Readonly<TData>;
+    readonly value: TValue;
+    readonly onChange: (newValue: TValue) => void;
+    readonly onNext?: () => void;
+    readonly error?: string;
+    readonly isActive?: boolean;
+}
+interface NodeRunner<TType extends SurveyNodeType = SurveyNodeType, TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
+    readonly type: TType;
+    readonly Component?: ComponentType<NodeRunnerProps<TData, TValue>>;
+}
+interface NodeBuilderProps<TData extends NodeData = NodeData> {
+    readonly data: Readonly<TData>;
+    readonly onChange: (newData: TData) => void;
+}
+interface NodeCanvasProps<TData extends NodeData = NodeData> {
+    readonly id: string;
+    readonly type: SurveyNodeType;
+    readonly data: Readonly<TData>;
+    readonly selected?: boolean;
+}
+interface NodeBuilder<TType extends SurveyNodeType = SurveyNodeType, TData extends NodeData = NodeData> {
+    readonly type: TType;
+    readonly label: string;
+    readonly icon?: ReactNode;
+    readonly SettingsComponent?: ComponentType<NodeBuilderProps<TData>>;
+    readonly CanvasComponent?: ComponentType<NodeCanvasProps<TData>>;
+}
+interface QuestionNodeDefinition<TType extends QuestionNodeType = QuestionNodeType, TData extends NodeData = NodeData, TValue extends NodeValue = NodeValue> {
+    readonly manifest: NodeManifest<TType, TData>;
+    readonly logic: NodeLogic<TType, TData, TValue>;
+    readonly builder: NodeBuilder<TType, TData>;
+    readonly runner: NodeRunner<TType, TData, TValue>;
+}
+type CompleteBuilderRegistry<TType extends QuestionNodeType = QuestionNodeType> = Readonly<Record<TType, NodeBuilder<TType, NodeData>>>;
+type CompleteRunnerRegistry<TType extends QuestionNodeType = QuestionNodeType> = Readonly<Record<TType, NodeRunner<TType, NodeData, NodeValue>>>;
+type BuilderRegistry<TType extends SurveyNodeType = SurveyNodeType> = Readonly<Partial<{
+    [K in TType]: NodeBuilder<K, NodeData>;
+}>>;
+type RunnerRegistry<TType extends SurveyNodeType = SurveyNodeType> = Readonly<Partial<{
+    [K in TType]: NodeRunner<K, NodeData, NodeValue>;
+}>>;
+declare function defineQuestionNode<const TType extends QuestionNodeType, TData extends NodeData, TValue extends NodeValue>(definition: QuestionNodeDefinition<TType, TData, TValue>): QuestionNodeDefinition<TType, TData, TValue>;
+declare function defineBuilderRegistry<const TRegistry extends Readonly<Partial<Record<SurveyNodeType, unknown>>>>(registry: TRegistry): TRegistry;
+declare function defineRunnerRegistry<const TRegistry extends Readonly<Partial<Record<SurveyNodeType, unknown>>>>(registry: TRegistry): TRegistry;
+
+export { type BuilderRegistry as B, type CompleteBuilderRegistry as C, type NodeBuilder as N, type QuestionNodeDefinition as Q, type RunnerRegistry as R, type NodeBuilderProps as a, type NodeCanvasProps as b, defineQuestionNode as c, defineBuilderRegistry as d, type CompleteRunnerRegistry as e, type NodeRunner as f, type NodeRunnerProps as g, defineRunnerRegistry as h };

package/dist/types-CjF8-OZi.d.mts

@@ -0,0 +1,59 @@
+import { h as NodeData, J as JsonValue } from './coreTypes-YSpR0Oyh.mjs';
+
+type PlainTextData = NodeData & {
+    label: string;
+    description: string;
+    buttonLabel: string;
+    condition: {
+        id: string;
+        type: "group";
+        logicType: "AND" | "OR";
+        children: JsonValue[];
+    };
+};
+type PlainTextValue = {
+    viewed: boolean;
+};
+
+type ConditionData = {
+    id: string;
+    type: "group";
+    logicType: "AND" | "OR";
+    children: JsonValue[];
+};
+type TextLimitData = NodeData & {
+    minChars?: number;
+    maxChars?: number;
+    minWords?: number;
+    maxWords?: number;
+};
+type BaseTextData = TextLimitData & {
+    label: string;
+    description: string;
+    condition: ConditionData;
+};
+type TextInputData = BaseTextData & {
+    placeholder: string;
+    longAnswer: boolean;
+};
+type EmailInputData = BaseTextData;
+type DateInputData = BaseTextData;
+type NumberInputData = BaseTextData & {
+    min?: number;
+    max?: number;
+};
+type ZipCodeInputData = BaseTextData & {
+    allowedZips: string;
+};
+type MultiInputField = {
+    id: string;
+    label?: string;
+    value?: string;
+};
+type MultiInputData = BaseTextData & {
+    fields: MultiInputField[];
+};
+type TextValue = string;
+type MultiInputValue = Record<string, string>;
+
+export type { BaseTextData as B, DateInputData as D, EmailInputData as E, MultiInputData as M, NumberInputData as N, PlainTextData as P, TextInputData as T, ZipCodeInputData as Z, PlainTextValue as a, TextValue as b, MultiInputValue as c };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@surveystudio/node-registery",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Typed survey question node registry with split builder, runner, and logic entrypoints.",
   "main": "./dist/logic.mjs",
   "types": "./dist/logic.d.mts",
@@ -46,7 +46,7 @@
     "react-dom": "^19.2.3"
   },
   "scripts": {
-    "test": "node --test test/*.test.mjs",
+    "test": "pnpm build && node --test test/*.test.mjs",
     "typecheck": "tsc --noEmit",
     "build": "tsup",
     "prepack": "pnpm build",

package/dist/types-HCD7-TAw.d.mts

@@ -1,18 +0,0 @@
-import { o as NodeData, J as JsonValue } from './types-Bsz6x6iU.mjs';
-
-type PlainTextData = NodeData & {
-    label: string;
-    description: string;
-    buttonLabel: string;
-    condition: {
-        id: string;
-        type: "group";
-        logicType: "AND" | "OR";
-        children: JsonValue[];
-    };
-};
-type PlainTextValue = {
-    viewed: boolean;
-};
-
-export type { PlainTextData as P, PlainTextValue as a };