@ikas/component-cli 2.6.0 → 2.7.0

package/dist/commands/config.js

@@ -1,7 +1,7 @@
 import { Command } from "commander";
 import * as fs from "fs";
 import * as path from "path";
-import { PROP_TYPES, toPascalCase, generateTypesFile, generateGlobalTypesFile, collectUsedEnumIds, generateComponentFile, generateStylesFile, generateProjectId, isValidProjectId, generateComponentId, generateUniqueId, updateBarrelExport, findPropGroup, collectPropGroupIds, movePropGroupInTree, validateFilteredComponentIds, } from "../utils/component-helpers.js";
+import { PROP_TYPES, toPascalCase, generateTypesFile, isBuiltInEnumTypeId, generateGlobalTypesFile, collectUsedEnumIds, generateComponentFile, generateStylesFile, generateProjectId, isValidProjectId, generateComponentId, generateUniqueId, updateBarrelExport, findPropGroup, collectPropGroupIds, movePropGroupInTree, validateFilteredComponentIds, } from "../utils/component-helpers.js";
 function loadConfig() {
     const configPath = path.resolve(process.cwd(), "ikas.config.json");
     if (!fs.existsSync(configPath)) {
@@ -96,6 +96,11 @@ function assertKnownComponentIds(input, config) {
     }
     return input;
 }
+// The set of component ids that currently exist in the project, for validateComponentDefaultValue's
+// existence check. Undefined when no config is loaded, which makes the check a no-op (back-compat).
+function existingComponentIdSet(config) {
+    return config ? new Set(config.components.map((c) => c.id)) : undefined;
+}
 function regenerateTypes(component, componentType, config) {
     const componentDir = path.resolve(process.cwd(), path.dirname(component.entry));
     const typesPath = path.join(componentDir, "types.ts");
@@ -162,7 +167,91 @@ const ALLOWED_PROP_FIELDS = new Set([
     "enumTypeId",
     "filteredComponentIds",
     "privateVarMap",
+    "numberRangeData",
 ]);
+// Emit the standard CLI error envelope and exit(1) when a validator returned a message; a no-op
+// when the message is null. Collapses the repeated `if (err) { console.log(...); process.exit(1) }`
+// tail that follows every default-value validator call.
+function failIf(error) {
+    if (error) {
+        console.log(JSON.stringify({ success: false, error }));
+        process.exit(1);
+    }
+}
+/**
+ * Validate/sanitize a numberRangeData object for a NUMBER_RANGE prop. Accepts an object
+ * or a JSON string. min/max/interval are truncated to integers; only a positive interval
+ * is kept (0/negative would yield an invalid slider step). Exits with a structured error
+ * on malformed input.
+ */
+function parseNumberRangeData(raw, propName) {
+    const fail = (error) => {
+        console.log(JSON.stringify({ success: false, error }));
+        process.exit(1);
+    };
+    let obj = raw;
+    if (typeof raw === "string") {
+        try {
+            obj = JSON.parse(raw);
+        }
+        catch {
+            fail(`Invalid --numberRangeData JSON for prop "${propName}": ${raw}`);
+        }
+    }
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+        fail(`numberRangeData for prop "${propName}" must be an object { min, max, interval?, unit? }.`);
+    }
+    const o = obj;
+    const asInt = (v, field) => {
+        if (v === undefined || v === null)
+            return undefined;
+        if (typeof v !== "number" || !Number.isFinite(v)) {
+            fail(`numberRangeData.${field} for prop "${propName}" must be a finite number.`);
+        }
+        return Math.trunc(v);
+    };
+    const min = asInt(o.min, "min");
+    const max = asInt(o.max, "max");
+    const interval = asInt(o.interval, "interval");
+    const unit = typeof o.unit === "string" && o.unit.trim() ? o.unit.trim() : undefined;
+    if (min !== undefined && max !== undefined && min >= max) {
+        fail(`numberRangeData for prop "${propName}": min (${min}) must be less than max (${max}).`);
+    }
+    return {
+        ...(min !== undefined ? { min } : {}),
+        ...(max !== undefined ? { max } : {}),
+        ...(interval !== undefined && interval > 0 ? { interval } : {}),
+        ...(unit ? { unit } : {}),
+    };
+}
+const numberRangeDataRequiredError = (propName) => `numberRangeData with min and max is required for NUMBER_RANGE prop "${propName}". ` +
+    `Provide it, e.g. --numberRangeData '{"min":0,"max":100,"interval":5,"unit":"px"}' ` +
+    `(or a "numberRangeData" field inside --props). interval and unit are optional.`;
+// A NUMBER_RANGE slider config is complete only with both bounds; interval/unit stay optional.
+export const isNumberRangeComplete = (data) => data.min !== undefined && data.max !== undefined;
+/**
+ * A NUMBER_RANGE prop must carry a slider config with at least min and max — the editor UI marks
+ * Minimum/Maksimum Değer as required, so a prop authored without them yields a half-configured
+ * slider. Enforce it at creation time: reject when numberRangeData is absent or missing min/max.
+ */
+export function requireNumberRangeData(raw, propName) {
+    if (raw === undefined) {
+        console.log(JSON.stringify({
+            success: false,
+            error: numberRangeDataRequiredError(propName),
+        }));
+        process.exit(1);
+    }
+    const parsed = parseNumberRangeData(raw, propName);
+    if (!isNumberRangeComplete(parsed)) {
+        console.log(JSON.stringify({
+            success: false,
+            error: numberRangeDataRequiredError(propName),
+        }));
+        process.exit(1);
+    }
+    return parsed;
+}
 /**
  * Parse and validate the --props JSON flag for add-component.
  * Returns validated ComponentProp[] or exits with error.
@@ -188,6 +277,8 @@ async function parsePropsFlag(propsJson, config, configPath) {
     }
     const seenNames = new Set();
     const props = [];
+    // Loop-invariant: build the known-id set once for the whole batch, not per prop.
+    const existingComponentIds = existingComponentIdSet(config);
     for (const raw of rawProps) {
         const r = raw;
         const unknownFields = Object.keys(r).filter((k) => !ALLOWED_PROP_FIELDS.has(k));
@@ -240,23 +331,35 @@ async function parsePropsFlag(propsJson, config, configPath) {
             }));
             process.exit(1);
         }
+        // Dynamic (merchant-data reference) props can't carry a static default.
+        rejectDynamicDefault(r.name, propType, r.defaultValue);
         // Validate LINK / LIST_OF_LINK defaultValue shape (reject JSON strings and legacy { href })
         if ((propType === "LINK" || propType === "LIST_OF_LINK") &&
             r.defaultValue !== undefined) {
             const linkError = validateLinkDefaultValue(propType, r.defaultValue, r.name);
-            if (linkError) {
-                console.log(JSON.stringify({ success: false, error: linkError }));
-                process.exit(1);
-            }
+            failIf(linkError);
         }
         // Validate SVG / SVG_LIST defaultValue (reject malformed/oversized/unsafe SVG)
         if ((propType === "SVG" || propType === "SVG_LIST") &&
             r.defaultValue !== undefined) {
             const svgError = validateSvgDefaultValue(propType, r.defaultValue, r.name);
-            if (svgError) {
-                console.log(JSON.stringify({ success: false, error: svgError }));
-                process.exit(1);
-            }
+            failIf(svgError);
+        }
+        // Validate COMPONENT / COMPONENT_LIST defaultValue (reference-only child code components)
+        if ((propType === "COMPONENT" || propType === "COMPONENT_LIST") &&
+            r.defaultValue !== undefined) {
+            failIf(validateComponentDefaultValue(propType, r.defaultValue, r.name, r.filteredComponentIds, existingComponentIds));
+        }
+        // Validate TYPE (structured/style) defaultValue shape — must be an object (or an array for an
+        // _array typeId), never a bare string that would be emitted as a wrong-shaped default.
+        if (propType === "TYPE" && r.defaultValue !== undefined) {
+            const typeError = validateTypeDefaultValue(r.defaultValue, r.name, r.typeId);
+            failIf(typeError);
+        }
+        // Validate NUMBER defaultValue — reject empty/non-finite (Number("") silently becomes 0).
+        if (propType === "NUMBER" && r.defaultValue !== undefined) {
+            const numError = validateNumberDefaultValue(r.defaultValue, r.name);
+            failIf(numError);
         }
         // Auto-generate displayName if omitted
         const displayName = typeof r.displayName === "string" && r.displayName
@@ -285,7 +388,7 @@ async function parsePropsFlag(propsJson, config, configPath) {
             if (config &&
                 configPath &&
                 typeof r.enumTypeId === "string" &&
-                !r.enumTypeId.startsWith("@ikas/")) {
+                !isBuiltInEnumTypeId(r.enumTypeId)) {
                 const resolved = await resolveEnumType(r.enumTypeId, config, configPath);
                 if (!resolved) {
                     console.log(JSON.stringify({
@@ -328,6 +431,9 @@ async function parsePropsFlag(propsJson, config, configPath) {
                     privateVarMap: r.privateVarMap,
                 }
                 : {}),
+            ...(propType === "NUMBER_RANGE"
+                ? { numberRangeData: requireNumberRangeData(r.numberRangeData, r.name) }
+                : {}),
         };
         props.push(prop);
     }
@@ -375,6 +481,8 @@ async function addComponent(name, options) {
     const props = options.props
         ? await parsePropsFlag(options.props, config, configPath)
         : [];
+    // Reject section-disallowed TYPE props at definition time (best-effort, needs dev server)
+    await assertTypeIdsUsable(componentType, props.flatMap((p) => (p.type === "TYPE" && p.typeId ? [p.typeId] : [])));
     const componentId = generateComponentId(config.projectId);
     const componentDir = path.resolve(process.cwd(), `src/components/${pascalName}`);
     // Create directory
@@ -465,6 +573,10 @@ async function addProp(ref, options) {
         }));
         process.exit(1);
     }
+    // Reject section-disallowed types at definition time (best-effort, needs dev server)
+    if (propType === "TYPE" && options.typeId) {
+        await assertTypeIdsUsable(component.type, [options.typeId]);
+    }
     // Validate enumTypeId for ENUM props
     if (propType === "ENUM" && !options.enumTypeId) {
         console.log(JSON.stringify({
@@ -477,7 +589,7 @@ async function addProp(ref, options) {
     // (checks config.customTypes first, then falls back to the live dev server)
     if (propType === "ENUM" &&
         options.enumTypeId &&
-        !options.enumTypeId.startsWith("@ikas/")) {
+        !isBuiltInEnumTypeId(options.enumTypeId)) {
         const resolved = await resolveEnumType(options.enumTypeId, config, configPath);
         if (!resolved) {
             console.log(JSON.stringify({
@@ -551,24 +663,39 @@ async function addProp(ref, options) {
             process.exit(1);
         }
     }
+    rejectDynamicDefault(options.name, propType, options.defaultValue);
     const parsedDefaultValue = options.defaultValue !== undefined
         ? parseDefaultValue(options.defaultValue, propType)
         : undefined;
     if ((propType === "LINK" || propType === "LIST_OF_LINK") &&
         parsedDefaultValue !== undefined) {
         const linkError = validateLinkDefaultValue(propType, parsedDefaultValue, options.name);
-        if (linkError) {
-            console.log(JSON.stringify({ success: false, error: linkError }));
-            process.exit(1);
-        }
+        failIf(linkError);
     }
     if ((propType === "SVG" || propType === "SVG_LIST") &&
         parsedDefaultValue !== undefined) {
         const svgError = validateSvgDefaultValue(propType, parsedDefaultValue, options.name);
-        if (svgError) {
-            console.log(JSON.stringify({ success: false, error: svgError }));
-            process.exit(1);
-        }
+        failIf(svgError);
+    }
+    if ((propType === "COMPONENT" || propType === "COMPONENT_LIST") &&
+        parsedDefaultValue !== undefined) {
+        failIf(validateComponentDefaultValue(propType, parsedDefaultValue, options.name, parsedFilteredIds, existingComponentIdSet(config)));
+    }
+    if (propType === "TYPE" && parsedDefaultValue !== undefined) {
+        const typeError = validateTypeDefaultValue(parsedDefaultValue, options.name, options.typeId);
+        failIf(typeError);
+    }
+    // Validate against the raw flag string so an empty --defaultValue (Number("") → 0) is caught.
+    if (propType === "NUMBER" && options.defaultValue !== undefined) {
+        const numError = validateNumberDefaultValue(options.defaultValue, options.name);
+        failIf(numError);
+    }
+    const parsedNumberRangeData = propType === "NUMBER_RANGE"
+        ? requireNumberRangeData(options.numberRangeData, options.name)
+        : undefined;
+    if (propType === "NUMBER_RANGE" && parsedDefaultValue !== undefined) {
+        const nrError = validateNumberRangeDefaultValue(parsedDefaultValue, parsedNumberRangeData, options.name);
+        failIf(nrError);
     }
     const newProp = {
         name: options.name,
@@ -584,6 +711,9 @@ async function addProp(ref, options) {
         ...(options.enumTypeId ? { enumTypeId: options.enumTypeId } : {}),
         ...(parsedFilteredIds ? { filteredComponentIds: parsedFilteredIds } : {}),
         ...(parsedPrivateVarMap ? { privateVarMap: parsedPrivateVarMap } : {}),
+        ...(parsedNumberRangeData
+            ? { numberRangeData: parsedNumberRangeData }
+            : {}),
     };
     component.props.push(newProp);
     saveConfig(configPath, config);
@@ -606,30 +736,30 @@ async function addProp(ref, options) {
             ...(newProp.privateVarMap
                 ? { privateVarMap: newProp.privateVarMap }
                 : {}),
+            ...(newProp.numberRangeData
+                ? { numberRangeData: newProp.numberRangeData }
+                : {}),
         },
     }));
 }
-function parseDefaultValue(value, propType) {
+export function parseDefaultValue(value, propType) {
     switch (propType) {
         case "NUMBER":
             return Number(value);
         case "BOOLEAN":
             return value === "true";
+        case "COMPONENT":
+        case "COMPONENT_LIST":
         case "LINK":
         case "LIST_OF_LINK":
-            // The --default-value flag arrives as a string; LINK values must be stored as a
-            // typed object. Parse it here; if it is not valid JSON, return the raw string so
-            // validateLinkDefaultValue can report a precise error.
-            try {
-                return JSON.parse(value);
-            }
-            catch {
-                return value;
-            }
         case "SVG_LIST":
-            // Same reasoning as LINK_LIST: SVG_LIST must be stored as an array of SVG strings.
-            // Parse it here; if it is not valid JSON, return the raw string so
-            // validateSvgDefaultValue can report a precise "must be an array" error.
+        case "NUMBER_RANGE":
+        case "TYPE":
+            // These all carry a typed value (object/array), not a scalar. The --defaultValue flag arrives
+            // as a string, so parse it here; if it is not valid JSON, return the raw string so the type's
+            // validator (validateLinkDefaultValue / validateSvgDefaultValue / validateNumberRangeDefaultValue
+            // / validateTypeDefaultValue / validateComponentDefaultValue) can report a precise error instead
+            // of silently storing a bad shape.
             try {
                 return JSON.parse(value);
             }
@@ -640,7 +770,46 @@ function parseDefaultValue(value, propType) {
             return value;
     }
 }
-const VALID_LINK_TYPES = ["PAGE", "EXTERNAL", "FILE"];
+// Prop types whose value is a dynamic reference to merchant storefront data (products, media,
+// categories, brands, blogs, raffles). They resolve at storefront render time, so a static config
+// default is invalid and is rejected on add/update-prop. Keep in sync with @ikas/editor-models
+// DYNAMIC_PROP_TYPES (the CLI must not depend on that private package).
+export const DYNAMIC_PROP_TYPES = [
+    "IMAGE",
+    "IMAGE_LIST",
+    "VIDEO",
+    "PRODUCT",
+    "PRODUCT_LIST",
+    "PRODUCT_ATTRIBUTE",
+    "PRODUCT_ATTRIBUTE_LIST",
+    "BRAND",
+    "BRAND_LIST",
+    "CATEGORY",
+    "CATEGORY_LIST",
+    "BLOG",
+    "BLOG_LIST",
+    "BLOG_CATEGORY",
+    "BLOG_CATEGORY_LIST",
+    "RAFFLE",
+    "RAFFLE_LIST",
+];
+const dynamicPropDefaultError = (propName, propType) => `defaultValue is not allowed for prop "${propName}" of type ${propType}. ${propType} resolves to merchant storefront data at render time, so it can't carry a static default — omit defaultValue.`;
+// Reject a static default on a dynamic (merchant-data reference) prop type: print the standard
+// error and exit. No-op when the type isn't dynamic or no default was supplied.
+export const rejectDynamicDefault = (propName, propType, defaultValue) => {
+    if (DYNAMIC_PROP_TYPES.includes(propType) && defaultValue !== undefined) {
+        console.log(JSON.stringify({
+            success: false,
+            error: dynamicPropDefaultError(propName, propType),
+        }));
+        process.exit(1);
+    }
+};
+const nonEmpty = (v) => typeof v === "string" && v.trim().length > 0;
+// FILE is intentionally excluded from CLI-authored defaults: a code-component / AI-authored default
+// can't reference a store-specific uploaded file, so a "FILE" link default is always rejected. Store
+// owners can still create FILE links manually in the editor (editor-core keeps FILE in its own set).
+const VALID_LINK_TYPES = ["PAGE", "EXTERNAL"];
 const LINK_SHAPE_HELP = 'A link must be an object: { "linkType": "EXTERNAL", "label": "Text", "externalLink": "https://...", "subLinks": [] } ' +
     'for external links, or { "linkType": "PAGE", "label": "Text", "pageType": "INDEX", "subLinks": [] } for store pages. ' +
     "Do NOT pass a JSON string or a { label, href } shape.";
@@ -662,6 +831,15 @@ const validateSingleLink = (link, propName, path) => {
         !VALID_LINK_TYPES.includes(l.linkType)) {
         return `${where} must have a valid "linkType" (one of ${VALID_LINK_TYPES.join(", ")}). ${LINK_SHAPE_HELP}`;
     }
+    // Require the destination field for the declared linkType, so a link that points nowhere never
+    // reaches a published theme. A PAGE default carries a pageType (pageId is per-store, filled on
+    // materialization); pageId alone is also accepted for a specific page.
+    if (l.linkType === "PAGE" && !nonEmpty(l.pageType) && !nonEmpty(l.pageId)) {
+        return `${where}: a "PAGE" link needs a "pageType" (e.g. "INDEX") — or a "pageId" for a specific page. ${LINK_SHAPE_HELP}`;
+    }
+    if (l.linkType === "EXTERNAL" && !nonEmpty(l.externalLink)) {
+        return `${where}: an "EXTERNAL" link needs a non-empty "externalLink" URL. ${LINK_SHAPE_HELP}`;
+    }
     if (l.subLinks !== undefined && !Array.isArray(l.subLinks)) {
         return `${where}: "subLinks" must be an array (use [] when there are none).`;
     }
@@ -674,7 +852,7 @@ const validateSingleLink = (link, propName, path) => {
 // These defaults are a frequent source of bad data: agents tend to pass a JSON string or a
 // legacy { label, href } shape. Rejecting them at authoring time keeps malformed link values
 // out of published themes.
-function validateLinkDefaultValue(propType, value, propName) {
+export function validateLinkDefaultValue(propType, value, propName) {
     if (value === undefined || value === null)
         return null;
     if (propType === "LINK") {
@@ -693,8 +871,57 @@ function validateLinkDefaultValue(propType, value, propName) {
     const links = value.links;
     return firstError(links, (link, i) => validateSingleLink(link, propName, `.links[${i}]`));
 }
+const COMPONENT_SHAPE_HELP = 'A COMPONENT / COMPONENT_LIST default must be an object listing child code components: ' +
+    '{ "components": [ { "codeComponentId": "<id>" } ] }. Only code components are allowed; each entry ' +
+    "needs a string \"codeComponentId\" (no componentId, no inline propValues).";
+/**
+ * Validate a COMPONENT / COMPONENT_LIST defaultValue. Reference-only: each entry must name a code
+ * component via `codeComponentId`. Rejects non-CC (`componentId`) children, missing ids, more than
+ * one entry for a single COMPONENT, and ids outside the prop's filteredComponentIds allowlist.
+ * Returns an error message, or null if valid.
+ */
+export function validateComponentDefaultValue(propType, value, propName, filteredComponentIds, existingComponentIds) {
+    if (value === undefined || value === null)
+        return null;
+    const where = `defaultValue for prop "${propName}"`;
+    if (typeof value === "string") {
+        return `${where} is a JSON string but must be an object. ${COMPONENT_SHAPE_HELP}`;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value) || !Array.isArray(value.components)) {
+        return `${where} must be an object with a "components" array. ${COMPONENT_SHAPE_HELP}`;
+    }
+    const components = value.components;
+    if (propType === "COMPONENT" && components.length > 1) {
+        return `${where}: a COMPONENT prop holds a single child — provide at most one entry (use COMPONENT_LIST for many).`;
+    }
+    const allow = filteredComponentIds && filteredComponentIds.length ? new Set(filteredComponentIds) : null;
+    return firstError(components, (entry, i) => {
+        const at = `${where}.components[${i}]`;
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            return `${at} must be an object { "codeComponentId": "<id>" }. ${COMPONENT_SHAPE_HELP}`;
+        }
+        const e = entry;
+        if ("componentId" in e && !("codeComponentId" in e)) {
+            return `${at} references a non-code component (componentId). Only code components are allowed as defaults. ${COMPONENT_SHAPE_HELP}`;
+        }
+        if (typeof e.codeComponentId !== "string" || e.codeComponentId.trim().length === 0) {
+            return `${at} must have a non-empty string "codeComponentId". ${COMPONENT_SHAPE_HELP}`;
+        }
+        if (allow && !allow.has(e.codeComponentId)) {
+            return `${at}: "${e.codeComponentId}" is not in this prop's filteredComponentIds allowlist.`;
+        }
+        // Reject a reference to a component that does not exist in the project (deleted, renamed, or
+        // never created). A dangling default would seed a ghost entry on every placement that renders
+        // nothing. Only enforced when the caller supplies the known-component set (the config-backed
+        // add-prop / update-prop / batch sites); pure-shape callers pass no set and skip this check.
+        if (existingComponentIds && !existingComponentIds.has(e.codeComponentId)) {
+            return `${at}: no component with id "${e.codeComponentId}" exists in this project. Create it first (config add-component) or reference an existing component id (config list).`;
+        }
+        return null;
+    });
+}
 const SVG_DEFAULT_HELP = "An SVG default must be a single well-formed <svg>…</svg> string ≤ 64 KB with no embedded base64 raster images. " +
-    "Tip: the editor uses each svg's `class` attribute as its display name — set class=\"my-icon\" to name it; " +
+    'Tip: the editor uses each svg\'s `class` attribute as its display name — set class="my-icon" to name it; ' +
     "SVG_LIST items with no class show as svg-1, svg-2, ….";
 // Keep the cap and base64 pattern in sync with @ikas/editor-models validate-svg.ts (the
 // authoritative validator). Duplicated here on purpose — see validateSvgShape below.
@@ -736,7 +963,7 @@ function validateSvgShape(input) {
 // Validates an SVG / SVG_LIST defaultValue. Returns an error message, or null if valid.
 // Authoring an SVG default is a common mistake source for agents; rejecting here (with an
 // instructive message) keeps malformed/oversized SVGs out of published components.
-function validateSvgDefaultValue(propType, value, propName) {
+export function validateSvgDefaultValue(propType, value, propName) {
     if (value === undefined || value === null)
         return null;
     if (propType === "SVG") {
@@ -756,7 +983,177 @@ function validateSvgDefaultValue(propType, value, propName) {
             : null;
     });
 }
-function updateProp(ref, options) {
+const NUMBER_RANGE_DEFAULT_HELP = 'A NUMBER_RANGE default must be an object { "value": <number>, "unit": "px" | null }. ' +
+    "When the prop defines numberRangeData, value must be within [min, max] and on the interval grid (min + k·interval).";
+// Validates a NUMBER_RANGE defaultValue. Returns an error message, or null if valid.
+// Checks the { value, unit } shape and — when the prop carries numberRangeData — that the
+// value is within [min, max] and lands on the interval grid, mirroring the editor's slider
+// so an agent can't author an out-of-range or off-step default.
+export function validateNumberRangeDefaultValue(value, numberRangeData, propName) {
+    if (value === undefined || value === null)
+        return null;
+    const where = `defaultValue for prop "${propName}"`;
+    if (typeof value === "string") {
+        return `${where} is a JSON string but must be an object. ${NUMBER_RANGE_DEFAULT_HELP}`;
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return `${where} must be an object. ${NUMBER_RANGE_DEFAULT_HELP}`;
+    }
+    const v = value;
+    if (typeof v.value !== "number" || !Number.isFinite(v.value)) {
+        return `${where}: "value" must be a finite number. ${NUMBER_RANGE_DEFAULT_HELP}`;
+    }
+    if (v.unit !== undefined && v.unit !== null && typeof v.unit !== "string") {
+        return `${where}: "unit" must be a string or null. ${NUMBER_RANGE_DEFAULT_HELP}`;
+    }
+    if (numberRangeData) {
+        const { min, max, interval } = numberRangeData;
+        if (min !== undefined && v.value < min) {
+            return `${where}: value ${v.value} is below the configured min (${min}).`;
+        }
+        if (max !== undefined && v.value > max) {
+            return `${where}: value ${v.value} is above the configured max (${max}).`;
+        }
+        if (interval !== undefined &&
+            interval > 0 &&
+            min !== undefined &&
+            (v.value - min) % interval !== 0) {
+            return `${where}: value ${v.value} is not on the interval grid (min ${min} + k·${interval}).`;
+        }
+    }
+    return null;
+}
+const NUMBER_DEFAULT_HELP = "A NUMBER default must be a finite number, e.g. --defaultValue 42.";
+// Validates a NUMBER defaultValue. Returns an error message, or null if valid. Guards two footguns:
+// an empty/whitespace flag string (Number("") === 0 would silently store 0) and a non-numeric or
+// non-finite value (e.g. "42px" → NaN, "Infinity"). The flag path passes the raw --defaultValue
+// string; the --props path passes the already-parsed JSON value — both are handled here.
+export function validateNumberDefaultValue(value, propName) {
+    if (value === undefined || value === null)
+        return null;
+    const where = `defaultValue for prop "${propName}"`;
+    if (typeof value === "string") {
+        if (value.trim() === "") {
+            return `${where} is empty, but NUMBER requires a finite number. ${NUMBER_DEFAULT_HELP}`;
+        }
+        if (!Number.isFinite(Number(value))) {
+            return `${where} ("${value}") is not a finite number. ${NUMBER_DEFAULT_HELP}`;
+        }
+        return null;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return `${where} must be a finite number. ${NUMBER_DEFAULT_HELP}`;
+    }
+    return null;
+}
+const STYLE_TYPE_DEFAULT_HELP = "A size/style TYPE default must be an object matching the type's shape: " +
+    '{ "value": <number>, "unit": "px" | "rem" | "%" | "vh" | "vw" } (or { "css": "<raw css>" }). ' +
+    "Author it via add-component --props '[…]' or --defaultValue '<json>'.";
+const BP_STOREFRONT_PREFIX = "@ikas/bp-storefront-models-";
+// The size/style types that share the { css?, value?, unit? } shape. This is EXACTLY the set of
+// TYPE typeIds whose default the generator emits (mirror of DYNAMIC_STYLE_TYPE_IDS in
+// @ikas/blueprint-modules design-generator/generate-helpers/styles.ts — the standalone CLI must not
+// depend on that package, so it is hand-maintained here and kept in sync by a parity test). Every
+// OTHER TYPE typeId (BorderStyleType, BoxShadowStyleType, GridTemplateColumnsStyleType, string-union
+// styles like TextAlignStyleType, IkasProduct, custom types) has a DIFFERENT value shape, so their
+// defaults are not shape-checked (and are dead code in the generator anyway).
+const SIZE_STYLE_TYPE_NAMES = [
+    "SizeStyleType",
+    "PaddingStyleType",
+    "PaddingTopStyleType",
+    "PaddingRightStyleType",
+    "PaddingBottomStyleType",
+    "PaddingLeftStyleType",
+    "MarginStyleType",
+    "MarginTopStyleType",
+    "MarginRightStyleType",
+    "MarginBottomStyleType",
+    "MarginLeftStyleType",
+    "BorderRadiusStyleType",
+    "BorderRadiusTopLeftStyleType",
+    "BorderRadiusTopRightStyleType",
+    "BorderRadiusBottomRightStyleType",
+    "BorderRadiusBottomLeftStyleType",
+    "FontSizeStyleType",
+    "LineHeightStyleType",
+    "LetterSpacingStyleType",
+    "HeightStyleType",
+    "MinHeightStyleType",
+    "MaxHeightStyleType",
+    "WidthStyleType",
+    "MinWidthStyleType",
+    "MaxWidthStyleType",
+    "GapStyleType",
+    "BorderWidthStyleType",
+    "TopStyleType",
+    "RightStyleType",
+    "BottomStyleType",
+    "LeftStyleType",
+];
+// Validates a single style-type default object. Every size style type shares the optional
+// { css?, value?, unit? } shape, so inner fields are checked loosely — the key rejection is a
+// non-object (e.g. a bare JSON string, the common failure when a --defaultValue flag is not parsed).
+function styleDefaultObjectError(value, where) {
+    if (typeof value === "string") {
+        return `${where} is a JSON string but must be an object. ${STYLE_TYPE_DEFAULT_HELP}`;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return `${where} must be an object. ${STYLE_TYPE_DEFAULT_HELP}`;
+    }
+    const v = value;
+    // css/value/unit are all optional, and the editor treats an explicit null as "unset" (it accepts
+    // { value: null }). So only type-check a field that is present AND non-null — otherwise the CLI
+    // would be stricter than the authoritative editor and reject a value it would happily accept.
+    // Unknown fields ARE rejected below: every size-style type shares exactly this { css?, value?, unit? }
+    // shape, so an extra key is always a mistake (this matches the editor). The per-type value-DOMAIN
+    // (which units a given type allows — BorderWidth also permits em/vmin/vmax while the rest are
+    // px/rem/%/vh/vw) stays editor-side: it is per-type and can't be mirrored offline without drift.
+    if (v.css !== undefined && v.css !== null && typeof v.css !== "string") {
+        return `${where}: "css" must be a string. ${STYLE_TYPE_DEFAULT_HELP}`;
+    }
+    if (v.value !== undefined &&
+        v.value !== null &&
+        (typeof v.value !== "number" || !Number.isFinite(v.value))) {
+        return `${where}: "value" must be a finite number. ${STYLE_TYPE_DEFAULT_HELP}`;
+    }
+    if (v.unit !== undefined && v.unit !== null && typeof v.unit !== "string") {
+        return `${where}: "unit" must be a string. ${STYLE_TYPE_DEFAULT_HELP}`;
+    }
+    const unknownKey = Object.keys(v).find((k) => k !== "css" && k !== "value" && k !== "unit");
+    if (unknownKey) {
+        return `${where}: unknown field "${unknownKey}". A size/style default allows only "css", "value", "unit". ${STYLE_TYPE_DEFAULT_HELP}`;
+    }
+    return null;
+}
+// Validates a TYPE prop defaultValue — but ONLY for the size/style types whose shape we know
+// ({ css?, value?, unit? }). Any other TYPE typeId (color/border/box-shadow/grid/string-union
+// styles, IkasProduct, custom types) has a different value shape we can't verify offline, so its
+// default is passed through unchecked. The generator only emits a default for these size/style
+// types anyway. Returns an error message, or null if valid / not a size-style type.
+export function validateTypeDefaultValue(value, propName, typeId) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof typeId !== "string" || !typeId.startsWith(BP_STOREFRONT_PREFIX)) {
+        return null;
+    }
+    // Strip the prefix and an optional _array suffix to get the base type name.
+    const withoutPrefix = typeId.slice(BP_STOREFRONT_PREFIX.length);
+    const isArray = withoutPrefix.endsWith("_array");
+    const baseName = isArray
+        ? withoutPrefix.slice(0, -"_array".length)
+        : withoutPrefix;
+    if (!SIZE_STYLE_TYPE_NAMES.includes(baseName))
+        return null;
+    const where = `defaultValue for prop "${propName}"`;
+    if (isArray) {
+        if (!Array.isArray(value)) {
+            return `${where} must be an array for an _array TYPE prop: [ { "value": …, "unit": … }, … ]. ${STYLE_TYPE_DEFAULT_HELP}`;
+        }
+        return firstError(value, (el, i) => styleDefaultObjectError(el, `${where}[${i}]`));
+    }
+    return styleDefaultObjectError(value, where);
+}
+async function updateProp(ref, options) {
     const { config, configPath } = loadConfig();
     const component = resolveComponent(config, ref);
     const propIndex = component.props.findIndex((p) => p.name === options.prop);
@@ -788,14 +1185,85 @@ function updateProp(ref, options) {
     if (options.description !== undefined) {
         prop.description = options.description || undefined;
     }
+    // Resolve numberRangeData before defaultValue so a NUMBER_RANGE default can be validated
+    // against the (possibly just-updated) slider config in the same call.
+    if (options.numberRangeData !== undefined) {
+        if (options.numberRangeData === "" || options.numberRangeData === "none") {
+            delete prop.numberRangeData;
+        }
+        else {
+            prop.numberRangeData = parseNumberRangeData(options.numberRangeData, prop.name);
+        }
+    }
+    // A NUMBER_RANGE prop must keep a valid slider config (min + max). Enforce the invariant only when
+    // this update touches the type or numberRangeData — a benign update (e.g. displayName) on an
+    // existing prop must still pass. This catches switching a prop TO NUMBER_RANGE without a config, or
+    // clearing/blanking numberRangeData on a NUMBER_RANGE prop.
+    if ((options.type !== undefined || options.numberRangeData !== undefined) &&
+        prop.type === "NUMBER_RANGE" &&
+        (!prop.numberRangeData || !isNumberRangeComplete(prop.numberRangeData))) {
+        console.log(JSON.stringify({
+            success: false,
+            error: numberRangeDataRequiredError(prop.name),
+        }));
+        process.exit(1);
+    }
+    // Resolve filteredComponentIds before defaultValue so a COMPONENT / COMPONENT_LIST default can be
+    // validated against the (possibly just-updated) allowlist in the same call.
+    if (options.filteredComponentIds !== undefined) {
+        if (options.filteredComponentIds === "" ||
+            options.filteredComponentIds === "none") {
+            delete prop.filteredComponentIds;
+        }
+        else {
+            try {
+                const parsed = JSON.parse(options.filteredComponentIds);
+                if (!Array.isArray(parsed)) {
+                    console.log(JSON.stringify({
+                        success: false,
+                        error: "--filteredComponentIds must be a JSON array of strings.",
+                    }));
+                    process.exit(1);
+                }
+                assertKnownComponentIds(parsed, config);
+                prop.filteredComponentIds = parsed;
+            }
+            catch (err) {
+                if (err instanceof SyntaxError) {
+                    console.log(JSON.stringify({
+                        success: false,
+                        error: `Invalid --filteredComponentIds JSON: ${options.filteredComponentIds}`,
+                    }));
+                    process.exit(1);
+                }
+                throw err;
+            }
+        }
+    }
     if (options.defaultValue !== undefined) {
+        rejectDynamicDefault(prop.name, prop.type, options.defaultValue);
         const parsed = parseDefaultValue(options.defaultValue, prop.type);
+        // Validate against the raw flag string so an empty --defaultValue (Number("") → 0) is caught.
+        if (prop.type === "NUMBER") {
+            const numError = validateNumberDefaultValue(options.defaultValue, prop.name);
+            failIf(numError);
+        }
         if (prop.type === "LINK" || prop.type === "LIST_OF_LINK") {
             const linkError = validateLinkDefaultValue(prop.type, parsed, prop.name);
-            if (linkError) {
-                console.log(JSON.stringify({ success: false, error: linkError }));
-                process.exit(1);
-            }
+            failIf(linkError);
+        }
+        if ((prop.type === "COMPONENT" || prop.type === "COMPONENT_LIST") &&
+            parsed !== undefined) {
+            failIf(validateComponentDefaultValue(prop.type, parsed, prop.name, prop.filteredComponentIds, existingComponentIdSet(config)));
+        }
+        if (prop.type === "NUMBER_RANGE") {
+            const nrError = validateNumberRangeDefaultValue(parsed, prop.numberRangeData, prop.name);
+            failIf(nrError);
+        }
+        if (prop.type === "TYPE") {
+            // Prefer a typeId supplied in this same update over the stored one.
+            const typeError = validateTypeDefaultValue(parsed, prop.name, options.typeId ?? prop.typeId);
+            failIf(typeError);
         }
         prop.defaultValue = parsed;
     }
@@ -830,6 +1298,13 @@ function updateProp(ref, options) {
             prop.typeId = options.typeId;
         }
     }
+    // Reject section-disallowed types when the caller changes type/typeId;
+    // untouched legacy props stay editable (displayName, group, ...).
+    if ((options.type !== undefined || options.typeId !== undefined) &&
+        prop.type === "TYPE" &&
+        prop.typeId) {
+        await assertTypeIdsUsable(component.type, [prop.typeId]);
+    }
     if (options.enumTypeId !== undefined) {
         if (options.enumTypeId === "" || options.enumTypeId === "none") {
             delete prop.enumTypeId;
@@ -838,36 +1313,6 @@ function updateProp(ref, options) {
             prop.enumTypeId = options.enumTypeId;
         }
     }
-    if (options.filteredComponentIds !== undefined) {
-        if (options.filteredComponentIds === "" ||
-            options.filteredComponentIds === "none") {
-            delete prop.filteredComponentIds;
-        }
-        else {
-            try {
-                const parsed = JSON.parse(options.filteredComponentIds);
-                if (!Array.isArray(parsed)) {
-                    console.log(JSON.stringify({
-                        success: false,
-                        error: "--filteredComponentIds must be a JSON array of strings.",
-                    }));
-                    process.exit(1);
-                }
-                assertKnownComponentIds(parsed, config);
-                prop.filteredComponentIds = parsed;
-            }
-            catch (err) {
-                if (err instanceof SyntaxError) {
-                    console.log(JSON.stringify({
-                        success: false,
-                        error: `Invalid --filteredComponentIds JSON: ${options.filteredComponentIds}`,
-                    }));
-                    process.exit(1);
-                }
-                throw err;
-            }
-        }
-    }
     if (options.privateVarMap !== undefined) {
         if (options.privateVarMap === "" || options.privateVarMap === "none") {
             delete prop.privateVarMap;
@@ -912,6 +1357,9 @@ function updateProp(ref, options) {
                 ? { filteredComponentIds: prop.filteredComponentIds }
                 : {}),
             ...(prop.privateVarMap ? { privateVarMap: prop.privateVarMap } : {}),
+            ...(prop.numberRangeData
+                ? { numberRangeData: prop.numberRangeData }
+                : {}),
         },
     }));
 }
@@ -1410,6 +1858,7 @@ export function createConfigCommand() {
         .option("--enumTypeId <enumTypeId>", "Enum type ID for ENUM props (required when type is ENUM)")
         .option("--filteredComponentIds <json>", "JSON array of component IDs to restrict selection (for COMPONENT/COMPONENT_LIST)")
         .option("--privateVarMap <json>", "JSON object mapping variable keys to {id, typeId} (for COMPONENT/COMPONENT_LIST)")
+        .option("--numberRangeData <json>", 'JSON slider config for NUMBER_RANGE props, e.g. \'{"min":0,"max":100,"interval":5,"unit":"px"}\'')
         .action((options) => {
         addProp({ id: options.componentId, name: options.component }, options);
     });
@@ -1429,6 +1878,7 @@ export function createConfigCommand() {
         .option("--enumTypeId <enumTypeId>", "Enum type ID for ENUM props (use 'none' to clear)")
         .option("--filteredComponentIds <json>", "JSON array of component IDs (use 'none' to clear)")
         .option("--privateVarMap <json>", "JSON object mapping variable keys to {id, typeId} (use 'none' to clear)")
+        .option("--numberRangeData <json>", "JSON slider config for NUMBER_RANGE props (use 'none' to clear)")
         .action((options) => {
         updateProp({ id: options.componentId, name: options.component }, options);
     });
@@ -1560,62 +2010,15 @@ export function createConfigCommand() {
  * Returns the matching type (with enumOptions) if found, null otherwise.
  */
 async function fetchLiveEditorEnumById(enumId) {
-    const { WebSocket } = await import("ws");
-    const WS_URL = "ws://localhost:5201";
-    const TIMEOUT_MS = 1500;
-    return new Promise((resolve) => {
-        let ws;
-        let settled = false;
-        const finish = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            try {
-                ws?.close();
-            }
-            catch {
-                /* ignore */
-            }
-            resolve(value);
-        };
-        try {
-            ws = new WebSocket(WS_URL);
-        }
-        catch {
-            resolve(null);
-            return;
+    const types = await fetchLiveEditorTypes();
+    const match = types?.find((t) => t.category === "enum" && t.id === enumId);
+    return match
+        ? {
+            id: match.id,
+            name: match.name,
+            ...(match.enumOptions ? { enumOptions: match.enumOptions } : {}),
         }
-        const timeout = setTimeout(() => finish(null), TIMEOUT_MS);
-        ws.on("open", () => {
-            ws.send(JSON.stringify({ type: "request-types" }));
-        });
-        ws.on("message", (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                if (message.type === "types-list") {
-                    clearTimeout(timeout);
-                    const types = message.payload?.types || [];
-                    const match = types.find((t) => t.category === "enum" && t.id === enumId);
-                    finish(match
-                        ? {
-                            id: match.id,
-                            name: match.name,
-                            ...(match.enumOptions
-                                ? { enumOptions: match.enumOptions }
-                                : {}),
-                        }
-                        : null);
-                }
-            }
-            catch {
-                // Ignore non-JSON messages
-            }
-        });
-        ws.on("error", () => {
-            clearTimeout(timeout);
-            finish(null);
-        });
-    });
+        : null;
 }
 /**
  * Best-effort lookup of an enum by PascalCase name in the live editor session.
@@ -1625,6 +2028,16 @@ async function fetchLiveEditorEnumById(enumId) {
  * must treat null as "could not verify, fall back to on-disk check only".
  */
 async function fetchLiveEditorEnumByName(pascalName) {
+    const types = await fetchLiveEditorTypes();
+    const match = types?.find((t) => t.category === "enum" && toPascalCase(t.name) === pascalName);
+    return match ? { id: match.id, name: match.name } : null;
+}
+/**
+ * Best-effort fetch of the editor's synced type list (with category /
+ * sectionAllowed / enumOptions metadata). Returns null on any failure (no dev
+ * server, timeout) — callers must treat null as "could not verify, allow".
+ */
+async function fetchLiveEditorTypes() {
     const { WebSocket } = await import("ws");
     const WS_URL = "ws://localhost:5201";
     const TIMEOUT_MS = 1500;
@@ -1659,9 +2072,7 @@ async function fetchLiveEditorEnumByName(pascalName) {
                 const message = JSON.parse(data.toString());
                 if (message.type === "types-list") {
                     clearTimeout(timeout);
-                    const types = message.payload?.types || [];
-                    const match = types.find((t) => t.category === "enum" && toPascalCase(t.name) === pascalName);
-                    finish(match ? { id: match.id, name: match.name } : null);
+                    finish(message.payload?.types || []);
                 }
             }
             catch {
@@ -1674,6 +2085,47 @@ async function fetchLiveEditorEnumByName(pascalName) {
         });
     });
 }
+/**
+ * Definition-time guard for TYPE-prop typeIds, verified against the live
+ * editor's type list (skipped when the dev server is unreachable or the type
+ * is unknown to the editor). Two rules:
+ * - deprecated types are rejected on ANY component: they are legacy
+ *   render-only types — old themes may still carry values, but new props must
+ *   not be defined with them.
+ * - on section components, only section-allowed (style) types pass — any other
+ *   type renders an empty placeholder merchants cannot fill, and section-level
+ *   bindings cannot supply a value either, so the prop would be dead weight.
+ * On violation prints the standard { success: false } envelope and exits.
+ */
+async function assertTypeIdsUsable(componentType, typeIds) {
+    if (typeIds.length === 0)
+        return;
+    const types = await fetchLiveEditorTypes();
+    if (!types)
+        return;
+    const matches = typeIds.flatMap((typeId) => {
+        const match = types.find((t) => t.id === typeId);
+        return match ? [match] : [];
+    });
+    const legacy = matches.find((t) => t.deprecated === true);
+    if (legacy) {
+        console.log(JSON.stringify({
+            success: false,
+            error: `Type "${legacy.id}" is a legacy render-only type — values of it may still exist in old themes, but NEW props must not use it. Pick a current style type instead (run "config list-types" to see them).`,
+        }));
+        process.exit(1);
+    }
+    if (componentType !== "section")
+        return;
+    const disallowed = matches.find((t) => t.sectionAllowed === false);
+    if (!disallowed)
+        return;
+    console.log(JSON.stringify({
+        success: false,
+        error: `Type "${disallowed.id}" is not allowed for TYPE props on section components — merchants cannot fill it in the editor (sections only support style types). Run "config list-types --component-type section" to see allowed types, or use a dedicated prop type (e.g. PRODUCT, CATEGORY) for domain data.`,
+    }));
+    process.exit(1);
+}
 async function listTypes(componentType) {
     const { WebSocket } = await import("ws");
     const WS_URL = "ws://localhost:5201";
@@ -1707,7 +2159,8 @@ async function listTypes(componentType) {
                 const message = JSON.parse(data.toString());
                 if (message.type === "types-list") {
                     clearTimeout(timeout);
-                    let types = message.payload.types;
+                    // Legacy render-only types are never offered for new props.
+                    let types = message.payload.types.filter((t) => !t.deprecated);
                     if (componentType === "section") {
                         types = types.filter((t) => t.sectionAllowed);
                     }