meno-astro 0.1.0

package/dist/chunks/chunk-IVGZB6XN.js

@@ -0,0 +1,2921 @@
+import {
+  COMMENT_STATUSES
+} from "./chunk-LEMVUKVG.js";
+import {
+  __esm
+} from "./chunk-ZYQNHI3W.js";
+
+// ../core/lib/shared/constants.ts
+var SERVER_PORT, SERVE_PORT, NODE_TYPE;
+var init_constants = __esm({
+  "../core/lib/shared/constants.ts"() {
+    "use strict";
+    SERVER_PORT = typeof process !== "undefined" && process.env?.PORT ? parseInt(process.env.PORT, 10) : 3e3;
+    SERVE_PORT = typeof process !== "undefined" && process.env?.MENO_SERVE_PORT ? parseInt(process.env.MENO_SERVE_PORT, 10) : 8080;
+    NODE_TYPE = {
+      NODE: "node",
+      COMPONENT: "component",
+      SLOT: "slot",
+      EMBED: "embed",
+      LINK: "link",
+      LOCALE_LIST: "locale-list",
+      LIST: "list"
+    };
+  }
+});
+
+// ../core/lib/shared/validation/schemas.ts
+import { z } from "zod";
+var BasePropTypeSchema, PropTypeSchema, I18nValueObjectSchema, BasePropDefinitionSchema, EnumsConfigSchema, ListItemSchemaSchema, ListPropDefinitionSchema, PropDefinitionSchema, StyleMappingSchema, BooleanMappingSchema, IfConditionSchema, LinkMappingSchema, HtmlMappingSchema, StyleObjectSchema, ResponsiveStyleObjectSchema, StyleValueSchema, InteractiveStyleRuleSchema, InteractiveStylesSchema, SlotMarkerSchema, ComponentNodeSchema, HtmlNodeSchema, ComponentInstanceNodeSchema, EmbedNodeSchema, LinkNodeSchema, LocaleListNodeSchema, ListNodeSchemaBasic, ScriptLoadModeSchema, LibraryPositionSchema, ScriptTypeSchema, JSLibraryConfigSchema, CSSLibraryConfigSchema, LibrariesConfigSchema, StructuredComponentDefinitionSchema, ComponentDefinitionSchema, I18nOrStringSchema, LibraryMergeModeSchema, PageLibrariesConfigSchema, CustomCodeConfigSchema, PageMetaDataBaseSchema, PageMetaDataSchema, LineRangeSchema, JSONPageSchema, PageDataWithComponentSchema, PageDataSchema, CMSFieldTypeSchema, CMSFieldDefinitionSchema, CMSClientDataStrategySchema, CMSClientDataConfigSchema, CMSSchemaSchema, CMSItemSchema, CMSDraftItemSchema, CMSFilterConditionSchema, CMSSortConfigSchema, CMSListQuerySchema, CMSListNodeSchema, PageCmsConfigSchema, PageMetaDataWithCMSSchema;
+var init_schemas = __esm({
+  "../core/lib/shared/validation/schemas.ts"() {
+    "use strict";
+    init_constants();
+    BasePropTypeSchema = z.enum(["string", "select", "boolean", "number", "link", "file", "rich-text", "embed"]);
+    PropTypeSchema = z.enum(["string", "select", "boolean", "number", "link", "file", "rich-text", "embed", "list"]);
+    I18nValueObjectSchema = z.object({
+      _i18n: z.literal(true)
+    }).passthrough();
+    BasePropDefinitionSchema = z.object({
+      type: BasePropTypeSchema,
+      default: z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.object({ href: z.string(), target: z.string().optional() }),
+        I18nValueObjectSchema
+      ]).optional(),
+      options: z.array(z.string()).readonly().optional(),
+      enumName: z.string().optional(),
+      // For 'select' type: reference to project-level enum
+      accept: z.string().optional(),
+      // For 'file' type: MIME pattern like "image/*", "video/*"
+      editor: z.enum(["basic", "extended"]).optional()
+      // For 'rich-text' type: which editor to use
+    }).passthrough();
+    EnumsConfigSchema = z.record(z.string(), z.array(z.string()));
+    ListItemSchemaSchema = z.record(z.string(), BasePropDefinitionSchema);
+    ListPropDefinitionSchema = z.object({
+      type: z.literal("list"),
+      itemSchema: ListItemSchemaSchema,
+      // List-item field values can be any primitive, a link object, an `_i18n`
+      // object (resolved by the SSR pipeline), or null.
+      default: z.array(z.record(z.string(), z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.object({ href: z.string(), target: z.string().optional() }),
+        I18nValueObjectSchema,
+        z.null()
+      ]))).optional()
+    }).passthrough();
+    PropDefinitionSchema = z.union([
+      ListPropDefinitionSchema,
+      BasePropDefinitionSchema
+    ]);
+    StyleMappingSchema = z.object({
+      _mapping: z.literal(true),
+      prop: z.string(),
+      values: z.record(z.string(), z.union([z.string(), z.number()]))
+    }).passthrough();
+    BooleanMappingSchema = z.object({
+      _mapping: z.literal(true),
+      prop: z.string(),
+      values: z.record(z.string(), z.boolean())
+    }).passthrough();
+    IfConditionSchema = z.union([
+      z.boolean(),
+      z.string(),
+      BooleanMappingSchema
+    ]);
+    LinkMappingSchema = z.object({
+      _mapping: z.literal(true),
+      prop: z.string(),
+      values: z.record(z.string(), z.object({
+        href: z.string(),
+        target: z.string().optional()
+      })).optional()
+    }).passthrough();
+    HtmlMappingSchema = z.object({
+      _mapping: z.literal(true),
+      prop: z.string(),
+      values: z.record(z.string(), z.string()).optional()
+    }).passthrough();
+    StyleObjectSchema = z.record(
+      z.string(),
+      z.union([
+        z.string(),
+        z.number(),
+        StyleMappingSchema
+      ])
+    );
+    ResponsiveStyleObjectSchema = z.object({
+      base: StyleObjectSchema.optional(),
+      tablet: StyleObjectSchema.optional(),
+      mobile: StyleObjectSchema.optional()
+    }).passthrough();
+    StyleValueSchema = z.union([
+      StyleObjectSchema,
+      ResponsiveStyleObjectSchema
+    ]);
+    InteractiveStyleRuleSchema = z.object({
+      name: z.string().optional(),
+      prefix: z.string().optional(),
+      postfix: z.string().optional(),
+      style: StyleValueSchema,
+      previewProp: z.string().optional()
+    });
+    InteractiveStylesSchema = z.array(InteractiveStyleRuleSchema);
+    SlotMarkerSchema = z.lazy(() => z.object({
+      type: z.literal(NODE_TYPE.SLOT),
+      default: z.union([
+        z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+        z.string(),
+        I18nValueObjectSchema
+      ]).optional()
+    }).passthrough());
+    HtmlNodeSchema = z.lazy(() => z.object({
+      type: z.literal(NODE_TYPE.NODE),
+      tag: z.string(),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional(),
+      props: z.record(z.string(), z.any()).optional(),
+      // Allow props for backward compatibility
+      children: z.union([
+        z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+        z.string(),
+        I18nValueObjectSchema
+      ]).optional()
+    }).passthrough());
+    ComponentInstanceNodeSchema = z.lazy(() => z.object({
+      type: z.literal(NODE_TYPE.COMPONENT),
+      component: z.string(),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      props: z.record(z.string(), z.any()).optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional(),
+      children: z.union([
+        z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+        z.string(),
+        I18nValueObjectSchema
+      ]).optional()
+    }).passthrough());
+    EmbedNodeSchema = z.lazy(() => z.object({
+      type: z.literal(NODE_TYPE.EMBED),
+      html: z.union([z.string(), HtmlMappingSchema, I18nValueObjectSchema]),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional()
+    }).passthrough());
+    LinkNodeSchema = z.lazy(() => z.object({
+      type: z.literal(NODE_TYPE.LINK),
+      href: z.union([z.string(), LinkMappingSchema, I18nValueObjectSchema]),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional(),
+      children: z.union([
+        z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+        z.string(),
+        I18nValueObjectSchema
+      ]).optional()
+    }).passthrough());
+    LocaleListNodeSchema = z.lazy(() => z.object({
+      type: z.literal(NODE_TYPE.LOCALE_LIST),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      itemStyle: StyleValueSchema.optional(),
+      activeItemStyle: StyleValueSchema.optional(),
+      separatorStyle: StyleValueSchema.optional(),
+      showCurrent: z.boolean().optional(),
+      showSeparator: z.boolean().optional(),
+      showFlag: z.boolean().optional(),
+      flagStyle: StyleValueSchema.optional(),
+      attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional()
+    }).passthrough());
+    ListNodeSchemaBasic = z.lazy(() => z.object({
+      type: z.union([z.literal(NODE_TYPE.LIST), z.literal("cms-list")]),
+      // Support both for migration
+      sourceType: z.enum(["prop", "collection"]).optional(),
+      // defaults to 'prop'
+      source: z.string().optional(),
+      // Source prop name or collection name
+      collection: z.string().optional(),
+      // Legacy field for cms-list migration
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      itemAs: z.string().optional(),
+      // Collection-specific options
+      items: z.union([z.string(), z.array(z.string())]).optional(),
+      filter: z.unknown().optional(),
+      sort: z.unknown().optional(),
+      limit: z.number().optional(),
+      offset: z.number().optional(),
+      excludeCurrentItem: z.boolean().optional(),
+      emitTemplate: z.boolean().optional(),
+      children: z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])).optional()
+    }).passthrough());
+    ComponentNodeSchema = z.union([
+      HtmlNodeSchema,
+      ComponentInstanceNodeSchema,
+      SlotMarkerSchema,
+      EmbedNodeSchema,
+      LinkNodeSchema,
+      LocaleListNodeSchema,
+      ListNodeSchemaBasic
+    ]);
+    ScriptLoadModeSchema = z.enum(["async", "defer"]);
+    LibraryPositionSchema = z.enum(["head", "body-end"]);
+    ScriptTypeSchema = z.enum(["classic", "module"]);
+    JSLibraryConfigSchema = z.object({
+      url: z.string().min(1),
+      mode: ScriptLoadModeSchema.optional(),
+      position: LibraryPositionSchema.optional(),
+      type: ScriptTypeSchema.optional()
+    }).passthrough();
+    CSSLibraryConfigSchema = z.object({
+      url: z.string().min(1),
+      media: z.string().optional(),
+      inline: z.boolean().optional()
+    }).passthrough();
+    LibrariesConfigSchema = z.object({
+      js: z.array(JSLibraryConfigSchema).optional(),
+      css: z.array(CSSLibraryConfigSchema).optional()
+    }).passthrough();
+    StructuredComponentDefinitionSchema = z.object({
+      interface: z.record(z.string(), PropDefinitionSchema).optional(),
+      structure: ComponentNodeSchema.optional(),
+      javascript: z.string().optional(),
+      css: z.string().optional(),
+      category: z.string().optional(),
+      libraries: LibrariesConfigSchema.optional(),
+      acceptsStyles: z.boolean().optional()
+    }).passthrough();
+    ComponentDefinitionSchema = z.union([
+      // New format: { component: {...} }
+      z.object({
+        component: StructuredComponentDefinitionSchema
+      }).passthrough(),
+      // Legacy format: { type, props?, children?, component }
+      z.object({
+        type: z.string(),
+        props: z.record(z.string(), z.any()).optional(),
+        children: z.array(z.any()).optional(),
+        component: StructuredComponentDefinitionSchema
+      }).passthrough()
+    ]);
+    I18nOrStringSchema = z.union([
+      z.string(),
+      z.object({
+        _i18n: z.literal(true)
+      }).passthrough()
+    ]);
+    LibraryMergeModeSchema = z.enum(["extend", "replace"]);
+    PageLibrariesConfigSchema = z.object({
+      js: z.array(JSLibraryConfigSchema).optional(),
+      css: z.array(CSSLibraryConfigSchema).optional(),
+      mode: LibraryMergeModeSchema.optional()
+    }).passthrough();
+    CustomCodeConfigSchema = z.object({
+      head: z.string().optional(),
+      bodyStart: z.string().optional(),
+      bodyEnd: z.string().optional()
+    }).passthrough();
+    PageMetaDataBaseSchema = z.object({
+      title: I18nOrStringSchema.optional(),
+      description: I18nOrStringSchema.optional(),
+      keywords: I18nOrStringSchema.optional(),
+      ogTitle: I18nOrStringSchema.optional(),
+      ogDescription: I18nOrStringSchema.optional(),
+      ogImage: z.string().optional(),
+      ogType: z.string().optional(),
+      slugs: z.record(z.string(), z.string()).optional(),
+      draft: z.boolean().optional(),
+      libraries: PageLibrariesConfigSchema.optional(),
+      customCode: CustomCodeConfigSchema.optional()
+    }).passthrough();
+    PageMetaDataSchema = PageMetaDataBaseSchema;
+    LineRangeSchema = z.object({
+      startLine: z.number(),
+      endLine: z.number()
+    });
+    JSONPageSchema = z.object({
+      components: z.record(z.string(), ComponentDefinitionSchema).optional(),
+      root: ComponentNodeSchema.optional(),
+      meta: PageMetaDataSchema.optional(),
+      _lineMap: z.record(z.string(), LineRangeSchema).optional()
+    }).passthrough().refine((data) => {
+      return data.meta !== void 0 || data.components !== void 0 || data.root !== void 0;
+    }, {
+      message: "JSONPage must have at least one of: meta, components, or root"
+    });
+    PageDataWithComponentSchema = z.object({
+      component: z.object({
+        structure: ComponentNodeSchema.optional(),
+        interface: z.record(z.string(), PropDefinitionSchema).optional(),
+        javascript: z.string().optional(),
+        css: z.string().optional(),
+        acceptsStyles: z.boolean().optional()
+      }).passthrough()
+    }).passthrough();
+    PageDataSchema = z.union([
+      PageDataWithComponentSchema,
+      JSONPageSchema
+    ]);
+    CMSFieldTypeSchema = z.enum([
+      "string",
+      "text",
+      "rich-text",
+      "number",
+      "boolean",
+      "image",
+      "file",
+      "date",
+      "select",
+      "reference"
+    ]);
+    CMSFieldDefinitionSchema = z.object({
+      type: CMSFieldTypeSchema,
+      required: z.boolean().optional(),
+      default: z.unknown().optional(),
+      label: z.string().optional(),
+      description: z.string().optional(),
+      options: z.array(z.string()).optional(),
+      accept: z.string().optional(),
+      collection: z.string().optional(),
+      multiple: z.boolean().optional()
+    }).passthrough();
+    CMSClientDataStrategySchema = z.enum(["auto", "inline", "static"]);
+    CMSClientDataConfigSchema = z.object({
+      enabled: z.boolean(),
+      strategy: CMSClientDataStrategySchema,
+      threshold: z.number().positive().optional(),
+      fields: z.array(z.string()).optional()
+    }).passthrough();
+    CMSSchemaSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+      slugField: z.string(),
+      urlPattern: z.string(),
+      fields: z.record(CMSFieldDefinitionSchema),
+      clientData: CMSClientDataConfigSchema.optional()
+    }).passthrough();
+    CMSItemSchema = z.object({
+      _id: z.string(),
+      _slug: z.string().optional(),
+      _filename: z.string().optional(),
+      _createdAt: z.string().optional()
+    }).passthrough();
+    CMSDraftItemSchema = z.object({
+      _id: z.string().optional(),
+      _slug: z.string().optional(),
+      _filename: z.string().optional(),
+      _createdAt: z.string().optional()
+    }).passthrough();
+    CMSFilterConditionSchema = z.object({
+      field: z.string(),
+      operator: z.enum(["eq", "neq", "gt", "gte", "lt", "lte", "contains", "in"]).optional(),
+      value: z.unknown()
+    });
+    CMSSortConfigSchema = z.object({
+      field: z.string(),
+      order: z.enum(["asc", "desc"]).optional()
+    });
+    CMSListQuerySchema = z.object({
+      collection: z.string(),
+      filter: z.union([
+        CMSFilterConditionSchema,
+        z.array(CMSFilterConditionSchema),
+        z.record(z.unknown())
+      ]).optional(),
+      sort: z.union([CMSSortConfigSchema, z.array(CMSSortConfigSchema)]).optional(),
+      limit: z.number().positive().optional(),
+      offset: z.number().nonnegative().optional()
+    });
+    CMSListNodeSchema = z.object({
+      type: z.literal("cms-list"),
+      collection: z.string(),
+      if: IfConditionSchema.optional(),
+      itemAs: z.string().optional(),
+      items: z.union([z.string(), z.array(z.string())]).optional(),
+      filter: z.union([
+        CMSFilterConditionSchema,
+        z.array(CMSFilterConditionSchema),
+        z.record(z.unknown())
+      ]).optional(),
+      sort: z.union([CMSSortConfigSchema, z.array(CMSSortConfigSchema)]).optional(),
+      limit: z.number().positive().optional(),
+      offset: z.number().nonnegative().optional(),
+      excludeCurrentItem: z.boolean().optional(),
+      children: z.array(z.unknown()).optional()
+    }).passthrough();
+    PageCmsConfigSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+      slugField: z.string(),
+      urlPattern: z.string(),
+      fields: z.record(CMSFieldDefinitionSchema)
+    }).passthrough();
+    PageMetaDataWithCMSSchema = z.object({
+      title: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+      description: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+      keywords: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+      ogTitle: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+      ogDescription: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+      ogImage: z.string().optional(),
+      ogType: z.string().optional(),
+      slugs: z.record(z.string(), z.string()).optional(),
+      source: z.enum(["static", "cms"]).optional(),
+      cms: PageCmsConfigSchema.optional(),
+      draft: z.boolean().optional(),
+      libraries: PageLibrariesConfigSchema.optional(),
+      customCode: CustomCodeConfigSchema.optional()
+    }).passthrough();
+  }
+});
+
+// ../core/lib/shared/registry/ComponentRegistry.ts
+var init_ComponentRegistry = __esm({
+  "../core/lib/shared/registry/ComponentRegistry.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/lib/shared/registry/ClientRegistry.ts
+var init_ClientRegistry = __esm({
+  "../core/lib/shared/registry/ClientRegistry.ts"() {
+    "use strict";
+    init_ComponentRegistry();
+  }
+});
+
+// ../core/lib/shared/registry/SSRRegistry.ts
+var init_SSRRegistry = __esm({
+  "../core/lib/shared/registry/SSRRegistry.ts"() {
+    "use strict";
+    init_ComponentRegistry();
+  }
+});
+
+// ../core/lib/shared/registry/RegistryManager.ts
+var init_RegistryManager = __esm({
+  "../core/lib/shared/registry/RegistryManager.ts"() {
+    "use strict";
+    init_ClientRegistry();
+    init_SSRRegistry();
+  }
+});
+
+// ../core/lib/shared/registry/BaseNodeTypeRegistry.ts
+var BaseNodeTypeRegistry;
+var init_BaseNodeTypeRegistry = __esm({
+  "../core/lib/shared/registry/BaseNodeTypeRegistry.ts"() {
+    "use strict";
+    BaseNodeTypeRegistry = class {
+      registry = /* @__PURE__ */ new Map();
+      listeners = /* @__PURE__ */ new Set();
+      nodeTypeCache = /* @__PURE__ */ new WeakMap();
+      /**
+       * Register a node type definition
+       */
+      register(definition) {
+        if (!definition.type) {
+          throw new Error("Node type definition must have a type");
+        }
+        this.registry.set(definition.type, definition);
+        this.nodeTypeCache = /* @__PURE__ */ new WeakMap();
+        this.notify();
+      }
+      /**
+       * Register multiple node type definitions at once
+       */
+      registerAll(definitions) {
+        for (const definition of definitions) {
+          if (!definition.type) {
+            throw new Error("Node type definition must have a type");
+          }
+          this.registry.set(definition.type, definition);
+        }
+        this.nodeTypeCache = /* @__PURE__ */ new WeakMap();
+        this.notify();
+      }
+      /**
+       * Get a node type definition by type string
+       */
+      get(type) {
+        return this.registry.get(type);
+      }
+      /**
+       * Check if a node type is registered
+       */
+      has(type) {
+        return this.registry.has(type);
+      }
+      /**
+       * Get all registered node types
+       */
+      getAll() {
+        return Array.from(this.registry.values());
+      }
+      /**
+       * Get node types by category
+       */
+      getByCategory(category) {
+        return this.getAll().filter((def) => def.category === category);
+      }
+      /**
+       * Get list of registered type names
+       */
+      getNames() {
+        return Array.from(this.registry.keys());
+      }
+      /**
+       * Find node type definition by node object using type guards
+       * Uses WeakMap caching for performance
+       */
+      findByNode(node) {
+        if (!node || typeof node !== "object") {
+          return void 0;
+        }
+        const cached = this.nodeTypeCache.get(node);
+        if (cached !== void 0) {
+          return cached || void 0;
+        }
+        for (const definition of this.registry.values()) {
+          if (definition.typeGuard(node)) {
+            this.nodeTypeCache.set(node, definition);
+            return definition;
+          }
+        }
+        this.nodeTypeCache.set(node, null);
+        return void 0;
+      }
+      /**
+       * Check if a node matches a specific type
+       * More efficient than findByNode when you know the type
+       */
+      isType(node, type) {
+        const definition = this.registry.get(type);
+        if (!definition) {
+          return false;
+        }
+        return definition.typeGuard(node);
+      }
+      /**
+       * Get node label info for tree display
+       */
+      getNodeLabel(node) {
+        const definition = this.findByNode(node);
+        if (!definition) {
+          return void 0;
+        }
+        return {
+          label: definition.treeDisplay.getLabel(node),
+          icon: definition.treeDisplay.icon
+        };
+      }
+      /**
+       * Get default node for a type
+       */
+      createDefault(type) {
+        const definition = this.registry.get(type);
+        if (!definition) {
+          return void 0;
+        }
+        return definition.defaultFactory();
+      }
+      /**
+       * Remove a node type by type string
+       */
+      remove(type) {
+        if (this.has(type)) {
+          this.registry.delete(type);
+          this.nodeTypeCache = /* @__PURE__ */ new WeakMap();
+          this.notify();
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Clear all registered node types
+       */
+      clear() {
+        this.registry.clear();
+        this.nodeTypeCache = /* @__PURE__ */ new WeakMap();
+        this.notify();
+      }
+      /**
+       * Subscribe to registry changes. Returns an unsubscribe function.
+       */
+      subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+          this.listeners.delete(listener);
+        };
+      }
+      /**
+       * Get the number of registered node types
+       */
+      get size() {
+        return this.registry.size;
+      }
+      notify() {
+        for (const listener of this.listeners) {
+          try {
+            listener();
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../core/lib/shared/registry/ClientNodeTypeRegistry.ts
+var ClientNodeTypeRegistry;
+var init_ClientNodeTypeRegistry = __esm({
+  "../core/lib/shared/registry/ClientNodeTypeRegistry.ts"() {
+    "use strict";
+    init_BaseNodeTypeRegistry();
+    ClientNodeTypeRegistry = class extends BaseNodeTypeRegistry {
+      /**
+       * Render a node using the registered renderer
+       * Returns null if no renderer is found for the node type
+       */
+      renderNode(node, context) {
+        const definition = this.findByNode(node);
+        if (!definition) {
+          return null;
+        }
+        return definition.clientRenderer(node, context);
+      }
+      /**
+       * Check if a node can be rendered by this registry
+       */
+      canRender(node) {
+        return this.findByNode(node) !== void 0;
+      }
+    };
+  }
+});
+
+// ../core/lib/shared/registry/SSRNodeTypeRegistry.ts
+var SSRNodeTypeRegistry;
+var init_SSRNodeTypeRegistry = __esm({
+  "../core/lib/shared/registry/SSRNodeTypeRegistry.ts"() {
+    "use strict";
+    init_BaseNodeTypeRegistry();
+    SSRNodeTypeRegistry = class extends BaseNodeTypeRegistry {
+      /**
+       * Render a node to HTML string using the registered renderer
+       * Returns empty string if no renderer is found for the node type
+       */
+      renderNode(node, context) {
+        const definition = this.findByNode(node);
+        if (!definition) {
+          return "";
+        }
+        return definition.ssrRenderer(node, context);
+      }
+      /**
+       * Check if a node can be rendered by this registry
+       */
+      canRender(node) {
+        return this.findByNode(node) !== void 0;
+      }
+    };
+  }
+});
+
+// ../core/lib/shared/registry/NodeTypeManager.ts
+var NodeTypeManager, globalNodeTypeManager;
+var init_NodeTypeManager = __esm({
+  "../core/lib/shared/registry/NodeTypeManager.ts"() {
+    "use strict";
+    init_ClientNodeTypeRegistry();
+    init_SSRNodeTypeRegistry();
+    NodeTypeManager = class {
+      clientRegistry;
+      ssrRegistry;
+      constructor() {
+        this.clientRegistry = new ClientNodeTypeRegistry();
+        this.ssrRegistry = new SSRNodeTypeRegistry();
+      }
+      /**
+       * Get the client-side registry
+       */
+      getClient() {
+        return this.clientRegistry;
+      }
+      /**
+       * Get the SSR registry
+       */
+      getSSR() {
+        return this.ssrRegistry;
+      }
+      /**
+       * Register a node type in both registries
+       */
+      register(definition) {
+        this.clientRegistry.register(definition);
+        this.ssrRegistry.register(definition);
+      }
+      /**
+       * Register multiple node types in both registries
+       */
+      registerAll(definitions) {
+        this.clientRegistry.registerAll(definitions);
+        this.ssrRegistry.registerAll(definitions);
+      }
+      /**
+       * Check if a node type is registered
+       */
+      has(type) {
+        return this.clientRegistry.has(type);
+      }
+      /**
+       * Get a node type definition
+       */
+      get(type) {
+        return this.clientRegistry.get(type);
+      }
+      /**
+       * Get all registered node types
+       */
+      getAll() {
+        return this.clientRegistry.getAll();
+      }
+      /**
+       * Get list of registered type names
+       */
+      getNames() {
+        return this.clientRegistry.getNames();
+      }
+      /**
+       * Clear both registries
+       */
+      clear() {
+        this.clientRegistry.clear();
+        this.ssrRegistry.clear();
+      }
+    };
+    globalNodeTypeManager = new NodeTypeManager();
+  }
+});
+
+// ../core/lib/shared/registry/defineNodeType.ts
+var init_defineNodeType = __esm({
+  "../core/lib/shared/registry/defineNodeType.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/lib/shared/registry/createNodeType.ts
+function createTypeGuard(typeValue) {
+  return (node) => node !== null && typeof node === "object" && "type" in node && node.type === typeValue;
+}
+function createNodeType(input) {
+  if (!input.type) {
+    throw new Error("Node type definition must have a type");
+  }
+  if (!input.displayName) {
+    throw new Error("Node type definition must have a displayName");
+  }
+  if (!input.schema) {
+    throw new Error("Node type definition must have a schema");
+  }
+  if (!input.clientRenderer) {
+    throw new Error("Node type definition must have a clientRenderer");
+  }
+  if (!input.ssrRenderer) {
+    throw new Error("Node type definition must have an ssrRenderer");
+  }
+  if (!input.treeDisplay) {
+    throw new Error("Node type definition must have treeDisplay");
+  }
+  return {
+    type: input.type,
+    displayName: input.displayName,
+    category: input.category ?? "core",
+    schema: input.schema,
+    // Auto-generated type guard
+    typeGuard: createTypeGuard(input.type),
+    // Auto-generated default factory
+    defaultFactory: () => ({
+      type: input.type,
+      ...input.defaultValues
+    }),
+    treeDisplay: {
+      icon: input.treeDisplay.icon,
+      getLabel: input.treeDisplay.getLabel ?? (() => input.displayName)
+    },
+    clientRenderer: input.clientRenderer,
+    ssrRenderer: input.ssrRenderer,
+    propsEditor: input.propsEditor,
+    editableFields: input.editableFields,
+    capabilities: {
+      ...DEFAULT_CAPABILITIES,
+      ...input.capabilities
+    }
+  };
+}
+var DEFAULT_CAPABILITIES;
+var init_createNodeType = __esm({
+  "../core/lib/shared/registry/createNodeType.ts"() {
+    "use strict";
+    DEFAULT_CAPABILITIES = {
+      canHaveChildren: true,
+      canHaveStyle: true,
+      canHaveAttributes: true,
+      canBeNested: true,
+      requiresProps: []
+    };
+  }
+});
+
+// ../core/lib/shared/registry/fieldPresets.ts
+var urlField, textareaField;
+var init_fieldPresets = __esm({
+  "../core/lib/shared/registry/fieldPresets.ts"() {
+    "use strict";
+    urlField = (config) => ({
+      name: config.name,
+      label: config.label,
+      type: "url",
+      required: config.required,
+      placeholder: config.placeholder ?? "https://...",
+      group: config.group
+    });
+    textareaField = (config) => ({
+      name: config.name,
+      label: config.label,
+      type: "text",
+      required: config.required,
+      placeholder: config.placeholder,
+      group: config.group
+    });
+  }
+});
+
+// ../core/lib/shared/registry/nodeTypes/HtmlNodeType.ts
+import { z as z4 } from "zod";
+import { createElement as h } from "react";
+var ComponentNodeSchemaRef, HtmlNodeSchemaInternal, HtmlNodeType;
+var init_HtmlNodeType = __esm({
+  "../core/lib/shared/registry/nodeTypes/HtmlNodeType.ts"() {
+    "use strict";
+    init_schemas();
+    init_createNodeType();
+    ComponentNodeSchemaRef = z4.lazy(() => z4.any());
+    HtmlNodeSchemaInternal = z4.object({
+      type: z4.literal("node"),
+      tag: z4.string(),
+      label: z4.string().optional(),
+      // Custom label displayed in structure tree
+      if: IfConditionSchema.optional(),
+      // Conditional rendering - skip node when false
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      // Interactive CSS rules (hover, active, etc.)
+      generateElementClass: z4.boolean().optional(),
+      // Generate element class without styles (for custom CSS)
+      attributes: z4.record(z4.string(), z4.union([z4.string(), z4.number(), z4.boolean()])).optional(),
+      props: z4.record(z4.string(), z4.any()).optional(),
+      // Backward compatibility
+      children: z4.union([
+        z4.array(z4.union([ComponentNodeSchemaRef, z4.string()])),
+        z4.string()
+      ]).optional()
+    }).passthrough();
+    HtmlNodeType = createNodeType({
+      type: "node",
+      displayName: "HTML Element",
+      category: "core",
+      schema: HtmlNodeSchemaInternal,
+      defaultValues: {
+        tag: "div",
+        style: { base: {} },
+        children: []
+      },
+      treeDisplay: {
+        icon: "HTML_ELEMENT",
+        getLabel: (node) => node.tag
+      },
+      clientRenderer: (node, context) => {
+        const props = { key: context.key };
+        if (node.tag === "form") {
+          props.onSubmit = (e) => e.preventDefault();
+        }
+        const voidElements = ["img", "br", "hr", "input", "meta", "link", "area", "base", "col", "embed", "param", "source", "track", "wbr"];
+        if (voidElements.includes(node.tag.toLowerCase())) {
+          return h(node.tag, props);
+        }
+        const children = context.buildChildren(
+          node.children,
+          context.elementPath,
+          context.parentComponentName,
+          context.componentContext
+        );
+        return h(node.tag, props, children);
+      },
+      ssrRenderer: (node, context) => {
+        const childrenHTML = context.renderChildren(node.children, context);
+        const voidElements = ["img", "br", "hr", "input", "meta", "link", "area", "base", "col", "embed", "param", "source", "track", "wbr"];
+        if (voidElements.includes(node.tag.toLowerCase())) {
+          return `<${node.tag} />`;
+        }
+        return `<${node.tag}>${childrenHTML}</${node.tag}>`;
+      },
+      capabilities: {
+        canHaveChildren: true,
+        requiresProps: ["tag"]
+      }
+    });
+  }
+});
+
+// ../core/lib/shared/registry/nodeTypes/ComponentInstanceNodeType.ts
+import { z as z5 } from "zod";
+import { createElement as h2 } from "react";
+var ComponentNodeSchemaRef2, ComponentInstanceNodeSchemaInternal, ComponentInstanceNodeType;
+var init_ComponentInstanceNodeType = __esm({
+  "../core/lib/shared/registry/nodeTypes/ComponentInstanceNodeType.ts"() {
+    "use strict";
+    init_schemas();
+    init_createNodeType();
+    ComponentNodeSchemaRef2 = z5.lazy(() => z5.any());
+    ComponentInstanceNodeSchemaInternal = z5.object({
+      type: z5.literal("component"),
+      component: z5.string(),
+      label: z5.string().optional(),
+      // Custom label displayed in structure tree
+      if: IfConditionSchema.optional(),
+      // Conditional rendering - skip node when false
+      props: z5.record(z5.string(), z5.any()).optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      // Interactive CSS rules (hover, active, etc.)
+      generateElementClass: z5.boolean().optional(),
+      // Generate element class without styles (for custom CSS)
+      attributes: z5.record(z5.string(), z5.union([z5.string(), z5.number(), z5.boolean()])).optional(),
+      children: z5.union([
+        z5.array(z5.union([ComponentNodeSchemaRef2, z5.string()])),
+        z5.string()
+      ]).optional()
+    }).passthrough();
+    ComponentInstanceNodeType = createNodeType({
+      type: "component",
+      displayName: "Component",
+      category: "core",
+      schema: ComponentInstanceNodeSchemaInternal,
+      defaultValues: {
+        component: "",
+        props: {},
+        style: { base: {} },
+        children: []
+      },
+      treeDisplay: {
+        icon: "COMPONENT",
+        getLabel: (node) => node.component
+      },
+      clientRenderer: (node, context) => {
+        const definition = context.getComponentDefinition(node.component);
+        if (!definition) {
+          return h2("div", { key: context.key }, `[Unknown component: ${node.component}]`);
+        }
+        return h2("div", { key: context.key }, `[Component: ${node.component}]`);
+      },
+      ssrRenderer: (node, context) => {
+        const definition = context.getComponentDefinition(node.component);
+        if (!definition) {
+          return `<!-- Unknown component: ${context.escapeHtml(node.component)} -->`;
+        }
+        return `<!-- Component: ${context.escapeHtml(node.component)} -->`;
+      },
+      capabilities: {
+        canHaveChildren: true,
+        requiresProps: ["component"]
+      }
+    });
+  }
+});
+
+// ../core/lib/shared/registry/nodeTypes/SlotMarkerType.ts
+import { z as z6 } from "zod";
+var SlotMarkerSchemaInternal, SlotMarkerType;
+var init_SlotMarkerType = __esm({
+  "../core/lib/shared/registry/nodeTypes/SlotMarkerType.ts"() {
+    "use strict";
+    init_createNodeType();
+    SlotMarkerSchemaInternal = z6.object({
+      type: z6.literal("slot"),
+      default: z6.union([
+        z6.array(z6.any()),
+        z6.string()
+      ]).optional()
+    }).passthrough();
+    SlotMarkerType = createNodeType({
+      type: "slot",
+      displayName: "Slot",
+      category: "special",
+      schema: SlotMarkerSchemaInternal,
+      defaultValues: {},
+      treeDisplay: {
+        icon: "SLOT_MARKER",
+        getLabel: () => "slot"
+      },
+      clientRenderer: (_node, _context) => {
+        return null;
+      },
+      ssrRenderer: (_node, _context) => {
+        return "";
+      },
+      capabilities: {
+        canHaveChildren: false,
+        canHaveStyle: false,
+        canHaveAttributes: false,
+        requiresProps: []
+      }
+    });
+  }
+});
+
+// ../core/lib/shared/registry/nodeTypes/EmbedNodeType.ts
+import { z as z7 } from "zod";
+import { createElement as h3 } from "react";
+var EmbedNodeSchemaInternal, EmbedNodeType;
+var init_EmbedNodeType = __esm({
+  "../core/lib/shared/registry/nodeTypes/EmbedNodeType.ts"() {
+    "use strict";
+    init_schemas();
+    init_createNodeType();
+    init_fieldPresets();
+    EmbedNodeSchemaInternal = z7.object({
+      type: z7.literal("embed"),
+      html: z7.union([z7.string(), HtmlMappingSchema]),
+      label: z7.string().optional(),
+      // Custom label displayed in structure tree
+      if: IfConditionSchema.optional(),
+      // Conditional rendering - skip node when false
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      // Interactive CSS rules (hover, active, etc.)
+      generateElementClass: z7.boolean().optional(),
+      // Generate element class without styles (for custom CSS)
+      attributes: z7.record(z7.string(), z7.union([z7.string(), z7.number(), z7.boolean()])).optional()
+    }).passthrough();
+    EmbedNodeType = createNodeType({
+      type: "embed",
+      displayName: "Embed",
+      category: "content",
+      schema: EmbedNodeSchemaInternal,
+      defaultValues: {
+        html: "",
+        style: { base: {} }
+      },
+      treeDisplay: {
+        icon: "HTML_ELEMENT",
+        getLabel: () => "Embed"
+      },
+      editableFields: [
+        textareaField({ name: "html", label: "HTML Content", required: true, placeholder: "<svg>...</svg>" })
+      ],
+      clientRenderer: (node, context) => {
+        const htmlContent = typeof node.html === "string" ? node.html : "";
+        return h3("div", {
+          key: context.key,
+          dangerouslySetInnerHTML: { __html: htmlContent }
+        });
+      },
+      ssrRenderer: (node, _context) => {
+        const htmlContent = typeof node.html === "string" ? node.html : "";
+        return `<div>${htmlContent}</div>`;
+      },
+      capabilities: {
+        canHaveChildren: false,
+        requiresProps: ["html"]
+      }
+    });
+  }
+});
+
+// ../core/lib/shared/registry/nodeTypes/LinkNodeType.ts
+import { z as z8 } from "zod";
+import { createElement as h4 } from "react";
+var ComponentNodeSchemaRef3, LinkNodeSchemaInternal, LinkNodeType;
+var init_LinkNodeType = __esm({
+  "../core/lib/shared/registry/nodeTypes/LinkNodeType.ts"() {
+    "use strict";
+    init_schemas();
+    init_createNodeType();
+    init_fieldPresets();
+    ComponentNodeSchemaRef3 = z8.lazy(() => z8.any());
+    LinkNodeSchemaInternal = z8.object({
+      type: z8.literal("link"),
+      href: z8.union([z8.string(), LinkMappingSchema]),
+      label: z8.string().optional(),
+      // Custom label displayed in structure tree
+      if: IfConditionSchema.optional(),
+      // Conditional rendering - skip node when false
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      // Interactive CSS rules (hover, active, etc.)
+      generateElementClass: z8.boolean().optional(),
+      // Generate element class without styles (for custom CSS)
+      attributes: z8.record(z8.string(), z8.union([z8.string(), z8.number(), z8.boolean()])).optional(),
+      children: z8.union([
+        z8.array(z8.union([ComponentNodeSchemaRef3, z8.string()])),
+        z8.string()
+      ]).optional()
+    }).passthrough();
+    LinkNodeType = createNodeType({
+      type: "link",
+      displayName: "Link",
+      category: "content",
+      schema: LinkNodeSchemaInternal,
+      defaultValues: {
+        href: "#",
+        style: { base: {} },
+        children: []
+      },
+      treeDisplay: {
+        icon: "LINK",
+        getLabel: () => "Link"
+      },
+      editableFields: [
+        urlField({ name: "href", label: "Link URL", required: true })
+      ],
+      clientRenderer: (node, context) => {
+        const children = context.buildChildren(
+          node.children,
+          context.elementPath,
+          context.parentComponentName,
+          context.componentContext
+        );
+        return h4("div", { key: context.key }, children);
+      },
+      ssrRenderer: (node, context) => {
+        const href = typeof node.href === "string" ? node.href : "#";
+        const childrenHTML = context.renderChildren(node.children, context);
+        return `<a href="${context.escapeHtml(href)}" class="olink">${childrenHTML}</a>`;
+      },
+      capabilities: {
+        canHaveChildren: true,
+        requiresProps: ["href"]
+      }
+    });
+  }
+});
+
+// ../core/lib/shared/registry/nodeTypes/LocaleListNodeType.ts
+import { z as z9 } from "zod";
+import { createElement as h5 } from "react";
+var LocaleListNodeSchemaInternal, LocaleListNodeType;
+var init_LocaleListNodeType = __esm({
+  "../core/lib/shared/registry/nodeTypes/LocaleListNodeType.ts"() {
+    "use strict";
+    init_schemas();
+    init_createNodeType();
+    LocaleListNodeSchemaInternal = z9.object({
+      type: z9.literal("locale-list"),
+      label: z9.string().optional(),
+      // Custom label displayed in structure tree
+      if: IfConditionSchema.optional(),
+      // Conditional rendering - skip node when false
+      style: StyleValueSchema.optional(),
+      itemStyle: StyleValueSchema.optional(),
+      activeItemStyle: StyleValueSchema.optional(),
+      separatorStyle: StyleValueSchema.optional(),
+      showCurrent: z9.boolean().optional(),
+      showSeparator: z9.boolean().optional(),
+      showFlag: z9.boolean().optional(),
+      flagStyle: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      // Interactive CSS rules (hover, active, etc.)
+      generateElementClass: z9.boolean().optional(),
+      // Generate element class without styles (for custom CSS)
+      displayType: z9.enum(["code", "name", "nativeName"]).optional(),
+      // How to display locale text
+      attributes: z9.record(z9.string(), z9.union([z9.string(), z9.number(), z9.boolean()])).optional()
+    }).passthrough();
+    LocaleListNodeType = createNodeType({
+      type: "locale-list",
+      displayName: "LocaleList",
+      category: "special",
+      schema: LocaleListNodeSchemaInternal,
+      defaultValues: {
+        style: { base: {} },
+        showCurrent: true,
+        showSeparator: true,
+        showFlag: true,
+        displayType: "nativeName"
+      },
+      treeDisplay: {
+        icon: "HTML_ELEMENT",
+        getLabel: () => "LocaleList"
+      },
+      clientRenderer: (_node, context) => {
+        return h5("div", {
+          key: context.key,
+          "data-locale-list": "true"
+        }, "[Locale List]");
+      },
+      ssrRenderer: (_node, _context) => {
+        return '<div class="locale-list">[Locale List]</div>';
+      },
+      capabilities: {
+        canHaveChildren: false,
+        requiresProps: []
+      }
+    });
+  }
+});
+
+// ../core/lib/shared/registry/nodeTypes/ListNodeType.ts
+import { z as z10 } from "zod";
+import { createElement as h6 } from "react";
+var CMSFilterConditionSchema2, CMSSortConfigSchema2, ListNodeSchemaInternal, ListNodeType;
+var init_ListNodeType = __esm({
+  "../core/lib/shared/registry/nodeTypes/ListNodeType.ts"() {
+    "use strict";
+    init_schemas();
+    init_createNodeType();
+    init_constants();
+    CMSFilterConditionSchema2 = z10.object({
+      field: z10.string(),
+      operator: z10.enum(["eq", "neq", "gt", "gte", "lt", "lte", "contains", "in"]).optional(),
+      value: z10.unknown()
+    });
+    CMSSortConfigSchema2 = z10.union([
+      z10.object({
+        field: z10.string(),
+        order: z10.enum(["asc", "desc"]).optional()
+      }),
+      z10.array(z10.object({
+        field: z10.string(),
+        order: z10.enum(["asc", "desc"]).optional()
+      }))
+    ]);
+    ListNodeSchemaInternal = z10.object({
+      type: z10.literal("list"),
+      /**
+       * Data source type:
+       * - 'prop': Read items from component props (default)
+       * - 'collection': Query items from CMS collection
+       */
+      sourceType: z10.enum(["prop", "collection"]).default("prop"),
+      /**
+       * Source identifier:
+       * - For sourceType 'prop': Prop name (e.g., "items") or template expression (e.g., "{{category.items}}")
+       * - For sourceType 'collection': Collection name (e.g., "posts", "authors")
+       */
+      source: z10.string(),
+      label: z10.string().optional(),
+      // Custom label displayed in structure tree
+      if: IfConditionSchema.optional(),
+      // Conditional rendering - skip node when false
+      /**
+       * Variable name for item in templates.
+       * - For sourceType 'prop': defaults to 'item'
+       * - For sourceType 'collection': defaults to singularized collection name
+       */
+      itemAs: z10.string().optional(),
+      // Collection-only options (ignored when sourceType: 'prop')
+      /** Direct item IDs or template expression for referenced items (e.g., "{{post.authorId}}") */
+      items: z10.union([z10.string(), z10.array(z10.string())]).optional(),
+      /** Filter conditions */
+      filter: z10.union([
+        CMSFilterConditionSchema2,
+        z10.array(CMSFilterConditionSchema2),
+        z10.record(z10.unknown())
+      ]).optional(),
+      /** Sort configuration */
+      sort: CMSSortConfigSchema2.optional(),
+      /** Exclude the current CMS item from the list (useful for "related items" sections) */
+      excludeCurrentItem: z10.boolean().optional(),
+      /**
+       * Emit item template for dynamic client-side rendering.
+       * When true, SSR emits a `<template data-meno-item>` element with unprocessed
+       * {{item.field}} placeholders. MenoFilter uses this to render items beyond
+       * the SSR'd limit dynamically.
+       */
+      emitTemplate: z10.boolean().optional(),
+      // Shared options
+      /** Maximum number of items to return */
+      limit: z10.number().optional(),
+      /** Number of items to skip */
+      offset: z10.number().optional(),
+      /** Children are repeated for each item */
+      children: z10.array(z10.unknown()).optional(),
+      /** @deprecated Legacy property - use source + sourceType instead */
+      collection: z10.union([z10.string(), z10.array(z10.any())]).optional()
+    }).passthrough();
+    ListNodeType = createNodeType({
+      type: NODE_TYPE.LIST,
+      displayName: "List",
+      category: "special",
+      schema: ListNodeSchemaInternal,
+      defaultValues: {
+        sourceType: "prop",
+        source: "{{items}}",
+        itemAs: "item",
+        children: []
+      },
+      treeDisplay: {
+        icon: "ARRAY",
+        getLabel: (node) => {
+          const listNode = node;
+          const sourceType = listNode.sourceType || "prop";
+          const prefix = sourceType === "collection" ? "CMS List" : "List";
+          return listNode.source ? `${prefix}: ${listNode.source}` : prefix;
+        }
+      },
+      clientRenderer: (node, context) => {
+        const listNode = node;
+        const sourceType = listNode.sourceType || "prop";
+        const isCollection = sourceType === "collection";
+        const bgColor = isCollection ? "rgba(139, 92, 246, 0.1)" : "rgba(59, 130, 246, 0.1)";
+        const borderColor = isCollection ? "rgba(139, 92, 246, 0.5)" : "rgba(59, 130, 246, 0.5)";
+        const textColor = isCollection ? "#8b5cf6" : "#3b82f6";
+        const label = isCollection ? "CMS List" : "List";
+        return h6("div", {
+          key: context.key,
+          "data-list": "true",
+          "data-source-type": sourceType,
+          "data-source": listNode.source,
+          style: {
+            padding: "8px 12px",
+            background: bgColor,
+            border: `1px dashed ${borderColor}`,
+            borderRadius: "4px",
+            color: textColor,
+            fontSize: "12px"
+          }
+        }, `[${label}: ${listNode.source || "No source"}]`);
+      },
+      ssrRenderer: (_node, _context) => {
+        return "<!-- list rendered by processList -->";
+      },
+      capabilities: {
+        canHaveChildren: true,
+        requiresProps: ["source"]
+      },
+      editableFields: [
+        {
+          name: "sourceType",
+          label: "Source Type",
+          type: "select",
+          required: false,
+          options: ["prop", "collection"]
+        },
+        {
+          name: "source",
+          label: "Source",
+          type: "string",
+          required: true,
+          placeholder: "e.g., items or posts"
+        },
+        {
+          name: "itemAs",
+          label: "Item Variable",
+          type: "string",
+          required: false,
+          placeholder: "default: item (prop) or singular (collection)"
+        }
+      ]
+    });
+  }
+});
+
+// ../core/lib/shared/registry/nodeTypes/index.ts
+var init_nodeTypes = __esm({
+  "../core/lib/shared/registry/nodeTypes/index.ts"() {
+    "use strict";
+    init_NodeTypeManager();
+    init_HtmlNodeType();
+    init_ComponentInstanceNodeType();
+    init_SlotMarkerType();
+    init_EmbedNodeType();
+    init_LinkNodeType();
+    init_LocaleListNodeType();
+    init_ListNodeType();
+    init_HtmlNodeType();
+    init_ComponentInstanceNodeType();
+    init_SlotMarkerType();
+    init_EmbedNodeType();
+    init_LinkNodeType();
+    init_LocaleListNodeType();
+    init_ListNodeType();
+  }
+});
+
+// ../core/lib/shared/registry/index.ts
+var init_registry = __esm({
+  "../core/lib/shared/registry/index.ts"() {
+    "use strict";
+    init_ComponentRegistry();
+    init_ClientRegistry();
+    init_SSRRegistry();
+    init_RegistryManager();
+    init_BaseNodeTypeRegistry();
+    init_ClientNodeTypeRegistry();
+    init_SSRNodeTypeRegistry();
+    init_NodeTypeManager();
+    init_defineNodeType();
+    init_createNodeType();
+    init_fieldPresets();
+    init_nodeTypes();
+  }
+});
+
+// ../core/lib/shared/i18n.ts
+var DEFAULT_I18N_CONFIG = {
+  defaultLocale: "en",
+  locales: [
+    { code: "en", name: "English", nativeName: "English", langTag: "en-US" }
+  ]
+};
+function isValidLocaleCode(config, code) {
+  return config.locales.some((loc) => loc.code === code);
+}
+function migrateLocaleString(code) {
+  const upperCode = code.toUpperCase();
+  return {
+    code: code.toLowerCase(),
+    name: upperCode,
+    nativeName: upperCode,
+    langTag: `${code.toLowerCase()}-${upperCode}`
+  };
+}
+function isOldLocaleFormat(locales) {
+  return Array.isArray(locales) && locales.length > 0 && typeof locales[0] === "string";
+}
+function migrateI18nConfig(i18n) {
+  if (!i18n || typeof i18n !== "object") {
+    return DEFAULT_I18N_CONFIG;
+  }
+  const config = i18n;
+  const defaultLocale = config.defaultLocale || "en";
+  const locales = config.locales;
+  if (!locales || !Array.isArray(locales)) {
+    return DEFAULT_I18N_CONFIG;
+  }
+  if (isOldLocaleFormat(locales)) {
+    return {
+      defaultLocale,
+      locales: locales.map(migrateLocaleString)
+    };
+  }
+  return {
+    defaultLocale,
+    locales
+  };
+}
+function isI18nValue(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return "_i18n" in value && value._i18n === true;
+}
+function resolveTranslation(value, locale, config) {
+  if (locale in value && value[locale] !== void 0 && locale !== "_i18n") {
+    return value[locale];
+  }
+  if (config.defaultLocale in value && value[config.defaultLocale] !== void 0) {
+    return value[config.defaultLocale];
+  }
+  for (const key of Object.keys(value)) {
+    if (key !== "_i18n" && value[key] !== void 0) {
+      return value[key];
+    }
+  }
+  const hasArrayValue = Object.entries(value).some(
+    ([k, v]) => k !== "_i18n" && Array.isArray(v)
+  );
+  return hasArrayValue ? [] : "";
+}
+function resolveI18nValue(value, locale, config) {
+  if (isI18nValue(value)) {
+    return resolveTranslation(value, locale, config);
+  }
+  return value;
+}
+function extractLocaleFromPath(path, config) {
+  const cleanPath = path.startsWith("/") ? path.slice(1) : path;
+  const segments = cleanPath.split("/");
+  if (segments.length > 0 && isValidLocaleCode(config, segments[0])) {
+    const locale = segments[0];
+    const pathWithoutLocale = "/" + segments.slice(1).join("/");
+    return { locale, pathWithoutLocale: pathWithoutLocale || "/" };
+  }
+  return { locale: null, pathWithoutLocale: path };
+}
+function buildLocalizedPath(path, locale) {
+  const cleanPath = path.startsWith("/") ? path : "/" + path;
+  return `/${locale}${cleanPath === "/" ? "" : cleanPath}`;
+}
+
+// ../core/lib/shared/cmsQueryParser.ts
+function parseSortExpression(expr) {
+  if (!expr.trim()) return void 0;
+  const parts = expr.split(",").map((p) => p.trim()).filter(Boolean);
+  const sorts = parts.map((part) => {
+    const tokens = part.split(/\s+/);
+    const field = tokens[0];
+    const order = tokens[1]?.toLowerCase() === "desc" ? "desc" : "asc";
+    return { field, order };
+  });
+  return sorts.length === 1 ? sorts[0] : sorts;
+}
+function serializeSortExpression(sort) {
+  if (!sort) return "";
+  const sorts = Array.isArray(sort) ? sort : [sort];
+  return sorts.map((s) => `${s.field}${s.order === "desc" ? " desc" : ""}`).join(", ");
+}
+function parseFilterExpression(expr) {
+  if (!expr.trim()) return void 0;
+  const lines = expr.split(/[;\n]/).map((l) => l.trim()).filter(Boolean);
+  const conditions = [];
+  for (const line of lines) {
+    const condition = parseFilterLine(line);
+    if (condition) conditions.push(condition);
+  }
+  if (conditions.length === 0) return void 0;
+  if (conditions.length === 1 && (!conditions[0].operator || conditions[0].operator === "eq")) {
+    return { [conditions[0].field]: conditions[0].value };
+  }
+  return conditions.length === 1 ? conditions[0] : conditions;
+}
+function parseFilterLine(line) {
+  const match = line.match(/^(\w+)\s*(==|!=|<>|>=|<=|=|>|<|contains|~|in|gte|lte|neq|gt|lt|eq)\s*(.+)$/i);
+  if (!match) return null;
+  const [, field, op, rawValue] = match;
+  const operator = normalizeOperator(op);
+  const value = parseValue(rawValue.trim(), operator);
+  if (operator === "eq") {
+    return { field, value };
+  }
+  return { field, operator, value };
+}
+function normalizeOperator(op) {
+  const normalized = op.toLowerCase();
+  const map = {
+    "=": "eq",
+    "==": "eq",
+    "eq": "eq",
+    "!=": "neq",
+    "<>": "neq",
+    "neq": "neq",
+    ">": "gt",
+    "gt": "gt",
+    ">=": "gte",
+    "gte": "gte",
+    "<": "lt",
+    "lt": "lt",
+    "<=": "lte",
+    "lte": "lte",
+    "contains": "contains",
+    "~": "contains",
+    "in": "in"
+  };
+  return map[normalized] || "eq";
+}
+function parseValue(raw, operator) {
+  if (raw.startsWith("{{") && raw.endsWith("}}")) {
+    return raw;
+  }
+  if (operator === "in") {
+    return raw.split(",").map((v) => parseScalarValue(v.trim()));
+  }
+  return parseScalarValue(raw);
+}
+function parseScalarValue(raw) {
+  if (raw.toLowerCase() === "true") return true;
+  if (raw.toLowerCase() === "false") return false;
+  const num = Number(raw);
+  if (!isNaN(num) && raw !== "") return num;
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  return raw;
+}
+function serializeFilterExpression(filter) {
+  if (!filter) return "";
+  if (!Array.isArray(filter) && !isFilterCondition(filter)) {
+    return Object.entries(filter).map(([field, value]) => `${field} = ${serializeValue(value)}`).join("\n");
+  }
+  const conditions = Array.isArray(filter) ? filter : [filter];
+  return conditions.map((c) => {
+    const op = c.operator || "eq";
+    const opStr = operatorToString(op);
+    const valStr = op === "in" && Array.isArray(c.value) ? c.value.map((v) => serializeValue(v)).join(", ") : serializeValue(c.value);
+    return `${c.field} ${opStr} ${valStr}`;
+  }).join("\n");
+}
+function operatorToString(op) {
+  const map = {
+    "eq": "=",
+    "neq": "!=",
+    "gt": ">",
+    "gte": ">=",
+    "lt": "<",
+    "lte": "<=",
+    "contains": "contains",
+    "in": "in"
+  };
+  return map[op] || "=";
+}
+function isFilterCondition(obj) {
+  return typeof obj === "object" && obj !== null && "field" in obj;
+}
+function serializeValue(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("{{") || /^[\w-]+$/.test(value)) return value;
+    return `"${value}"`;
+  }
+  return String(value);
+}
+
+// ../core/lib/shared/index.ts
+init_constants();
+
+// ../core/lib/shared/nodeUtils.ts
+init_constants();
+
+// ../core/lib/shared/breakpoints.ts
+var DEFAULT_BREAKPOINTS = {
+  tablet: { breakpoint: 1024, previewPoint: 768 },
+  mobile: { breakpoint: 540, previewPoint: 375 }
+};
+function getBreakpointValues(config) {
+  const result = {};
+  for (const [name, entry] of Object.entries(config)) {
+    result[name] = entry.breakpoint;
+  }
+  return result;
+}
+
+// ../core/lib/shared/cssProperties.ts
+var CSS_PROPERTIES_DEFINITION = {
+  // Display & Layout
+  display: {
+    values: ["block", "flex", "grid", "inline", "inline-block", "inline-flex", "inline-grid", "none"],
+    type: "select"
+  },
+  position: {
+    values: ["static", "relative", "absolute", "fixed", "sticky"],
+    type: "select"
+  },
+  top: { type: "string" },
+  right: { type: "string" },
+  bottom: { type: "string" },
+  left: { type: "string" },
+  inset: { type: "string" },
+  zIndex: { type: "number" },
+  // Dimensions
+  width: { type: "string" },
+  height: { type: "string" },
+  minWidth: { type: "string" },
+  maxWidth: { type: "string" },
+  minHeight: { type: "string" },
+  maxHeight: { type: "string" },
+  aspectRatio: { type: "string" },
+  // Spacing
+  margin: { type: "string" },
+  marginTop: { type: "string" },
+  marginRight: { type: "string" },
+  marginBottom: { type: "string" },
+  marginLeft: { type: "string" },
+  padding: { type: "string" },
+  paddingTop: { type: "string" },
+  paddingRight: { type: "string" },
+  paddingBottom: { type: "string" },
+  paddingLeft: { type: "string" },
+  gap: { type: "string" },
+  rowGap: { type: "string" },
+  columnGap: { type: "string" },
+  // Borders
+  border: { type: "string" },
+  borderWidth: { type: "string" },
+  borderStyle: {
+    values: ["solid", "dashed", "dotted", "double", "groove", "ridge", "inset", "outset", "none"],
+    type: "select"
+  },
+  borderColor: { type: "string" },
+  borderTop: { type: "string" },
+  borderRight: { type: "string" },
+  borderBottom: { type: "string" },
+  borderLeft: { type: "string" },
+  borderRadius: { type: "string" },
+  borderTopLeftRadius: { type: "string" },
+  borderTopRightRadius: { type: "string" },
+  borderBottomLeftRadius: { type: "string" },
+  borderBottomRightRadius: { type: "string" },
+  // Background & Colors
+  background: { type: "string" },
+  backgroundColor: { type: "string" },
+  backgroundImage: { type: "string" },
+  backgroundSize: {
+    values: ["auto", "cover", "contain"],
+    type: "select"
+  },
+  backgroundPosition: {
+    values: ["top", "bottom", "left", "right", "center"],
+    type: "select"
+  },
+  backgroundRepeat: {
+    values: ["repeat", "repeat-x", "repeat-y", "no-repeat"],
+    type: "select"
+  },
+  backgroundAttachment: {
+    values: ["scroll", "fixed", "local"],
+    type: "select"
+  },
+  backgroundOrigin: {
+    values: ["border-box", "padding-box", "content-box"],
+    type: "select"
+  },
+  backgroundBlendMode: {
+    values: ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity"],
+    type: "select"
+  },
+  // Gradient-text recipe (`background: linear-gradient(...); background-clip:
+  // text; -webkit-background-clip: text; -webkit-text-fill-color: transparent`).
+  // The `Webkit*` capitalization is intentional — utilityClassMapper's
+  // camel→kebab emitter only prepends `-` when the first letter is uppercase,
+  // so `WebkitBackgroundClip` round-trips back to `-webkit-background-clip`.
+  backgroundClip: {
+    values: ["border-box", "padding-box", "content-box", "text"],
+    type: "select"
+  },
+  WebkitBackgroundClip: {
+    values: ["border-box", "padding-box", "content-box", "text"],
+    type: "select"
+  },
+  WebkitTextFillColor: { type: "string" },
+  WebkitTextStroke: { type: "string" },
+  WebkitTextStrokeWidth: { type: "string" },
+  WebkitTextStrokeColor: { type: "string" },
+  color: { type: "string" },
+  opacity: { type: "number" },
+  // Flexbox
+  flex: { type: "string" },
+  flexDirection: {
+    values: ["row", "column", "row-reverse", "column-reverse"],
+    type: "select"
+  },
+  flexWrap: {
+    values: ["nowrap", "wrap", "wrap-reverse"],
+    type: "select"
+  },
+  flexFlow: { type: "string" },
+  justifyContent: {
+    values: ["flex-start", "flex-end", "center", "space-between", "space-around", "space-evenly"],
+    type: "select"
+  },
+  alignItems: {
+    values: ["flex-start", "flex-end", "center", "stretch", "baseline"],
+    type: "select"
+  },
+  alignContent: {
+    values: ["flex-start", "flex-end", "center", "space-between", "space-around", "stretch"],
+    type: "select"
+  },
+  alignSelf: {
+    values: ["auto", "flex-start", "flex-end", "center", "stretch", "baseline"],
+    type: "select"
+  },
+  flexGrow: { type: "number" },
+  flexShrink: { type: "number" },
+  flexBasis: { type: "string" },
+  order: { type: "number" },
+  // Grid
+  grid: { type: "string" },
+  gridTemplateColumns: { type: "string" },
+  gridTemplateRows: { type: "string" },
+  gridTemplateAreas: { type: "string" },
+  gridGap: { type: "string" },
+  gridColumn: { type: "string" },
+  gridRow: { type: "string" },
+  gridArea: { type: "string" },
+  gridAutoFlow: {
+    values: ["row", "column", "row dense", "column dense"],
+    type: "select"
+  },
+  gridAutoColumns: { type: "string" },
+  gridAutoRows: { type: "string" },
+  justifyItems: {
+    values: ["start", "end", "center", "stretch"],
+    type: "select"
+  },
+  justifySelf: {
+    values: ["auto", "start", "end", "center", "stretch"],
+    type: "select"
+  },
+  placeContent: { type: "string" },
+  placeItems: { type: "string" },
+  placeSelf: { type: "string" },
+  // Text & Font
+  fontSize: { type: "string" },
+  fontWeight: {
+    values: ["100", "200", "300", "400", "500", "600", "700", "800", "900", "normal", "bold"],
+    type: "select"
+  },
+  fontFamily: { type: "string" },
+  fontStyle: {
+    values: ["normal", "italic", "oblique"],
+    type: "select"
+  },
+  lineHeight: { type: "string" },
+  textAlign: {
+    values: ["left", "right", "center", "justify", "start", "end"],
+    type: "select"
+  },
+  textDecoration: {
+    values: ["none", "underline", "overline", "line-through"],
+    type: "select"
+  },
+  textDecorationLine: {
+    values: ["none", "underline", "overline", "line-through"],
+    type: "select"
+  },
+  textDecorationStyle: {
+    values: ["solid", "double", "dotted", "dashed", "wavy"],
+    type: "select"
+  },
+  textDecorationColor: { type: "string" },
+  textDecorationThickness: { type: "string" },
+  textUnderlineOffset: { type: "string" },
+  textUnderlinePosition: { type: "string" },
+  textTransform: {
+    values: ["none", "capitalize", "uppercase", "lowercase"],
+    type: "select"
+  },
+  textRendering: {
+    values: ["auto", "optimizeSpeed", "optimizeLegibility", "geometricPrecision"],
+    type: "select"
+  },
+  fontVariant: { type: "string" },
+  fontStretch: { type: "string" },
+  fontFeatureSettings: { type: "string" },
+  fontVariationSettings: { type: "string" },
+  fontKerning: {
+    values: ["auto", "normal", "none"],
+    type: "select"
+  },
+  WebkitFontSmoothing: {
+    values: ["auto", "none", "antialiased", "subpixel-antialiased"],
+    type: "select"
+  },
+  MozOsxFontSmoothing: {
+    values: ["auto", "grayscale"],
+    type: "select"
+  },
+  hyphens: {
+    values: ["none", "manual", "auto"],
+    type: "select"
+  },
+  WebkitHyphens: {
+    values: ["none", "manual", "auto"],
+    type: "select"
+  },
+  writingMode: {
+    values: ["horizontal-tb", "vertical-rl", "vertical-lr"],
+    type: "select"
+  },
+  direction: {
+    values: ["ltr", "rtl"],
+    type: "select"
+  },
+  tabSize: { type: "string" },
+  wordWrap: {
+    values: ["normal", "break-word"],
+    type: "select"
+  },
+  letterSpacing: { type: "string" },
+  wordSpacing: { type: "string" },
+  wordBreak: {
+    values: ["normal", "break-all", "keep-all", "break-word"],
+    type: "select"
+  },
+  overflowWrap: {
+    values: ["normal", "break-word", "anywhere"],
+    type: "select"
+  },
+  textWrap: {
+    values: ["wrap", "nowrap", "balance", "pretty", "stable"],
+    type: "select"
+  },
+  textIndent: { type: "string" },
+  verticalAlign: {
+    values: ["baseline", "top", "middle", "bottom", "text-top", "text-bottom", "sub", "super"],
+    type: "select"
+  },
+  // Box Shadow & Effects
+  boxShadow: { type: "string" },
+  textShadow: { type: "string" },
+  filter: { type: "string" },
+  backdropFilter: { type: "string" },
+  WebkitBackdropFilter: { type: "string" },
+  transform: { type: "string" },
+  transformOrigin: { type: "string" },
+  transformStyle: {
+    values: ["flat", "preserve-3d"],
+    type: "select"
+  },
+  perspective: { type: "string" },
+  perspectiveOrigin: { type: "string" },
+  transition: { type: "string" },
+  transitionProperty: { type: "string" },
+  transitionDuration: { type: "string" },
+  transitionTimingFunction: { type: "string" },
+  transitionDelay: { type: "string" },
+  animation: { type: "string" },
+  backfaceVisibility: {
+    values: ["visible", "hidden"],
+    type: "select"
+  },
+  mixBlendMode: {
+    values: ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity"],
+    type: "select"
+  },
+  isolation: {
+    values: ["auto", "isolate"],
+    type: "select"
+  },
+  willChange: { type: "string" },
+  imageRendering: {
+    values: ["auto", "crisp-edges", "pixelated", "smooth"],
+    type: "select"
+  },
+  clipPath: { type: "string" },
+  WebkitClipPath: { type: "string" },
+  // Mask family — gradient/SVG masks. Emit both the standard and `-webkit-`
+  // form because Safari still needs the prefix.
+  maskImage: { type: "string" },
+  WebkitMaskImage: { type: "string" },
+  maskSize: { type: "string" },
+  WebkitMaskSize: { type: "string" },
+  maskPosition: { type: "string" },
+  WebkitMaskPosition: { type: "string" },
+  maskRepeat: { type: "string" },
+  WebkitMaskRepeat: { type: "string" },
+  maskOrigin: { type: "string" },
+  WebkitMaskOrigin: { type: "string" },
+  maskClip: { type: "string" },
+  WebkitMaskClip: { type: "string" },
+  maskComposite: { type: "string" },
+  WebkitMaskComposite: { type: "string" },
+  maskMode: { type: "string" },
+  maskType: {
+    values: ["luminance", "alpha"],
+    type: "select"
+  },
+  // Overflow & Content
+  overflow: {
+    values: ["visible", "hidden", "scroll", "auto"],
+    type: "select"
+  },
+  overflowX: {
+    values: ["visible", "hidden", "scroll", "auto"],
+    type: "select"
+  },
+  overflowY: {
+    values: ["visible", "hidden", "scroll", "auto"],
+    type: "select"
+  },
+  whiteSpace: {
+    values: ["normal", "nowrap", "pre", "pre-wrap", "pre-line"],
+    type: "select"
+  },
+  textOverflow: {
+    values: ["clip", "ellipsis"],
+    type: "select"
+  },
+  visibility: {
+    values: ["visible", "hidden", "collapse"],
+    type: "select"
+  },
+  content: { type: "string" },
+  // Cursor & Interaction
+  cursor: {
+    values: ["auto", "default", "pointer", "wait", "text", "move", "not-allowed", "help"],
+    type: "select"
+  },
+  pointerEvents: {
+    values: ["auto", "none"],
+    type: "select"
+  },
+  userSelect: {
+    values: ["auto", "none", "text", "all"],
+    type: "select"
+  },
+  WebkitUserSelect: {
+    values: ["auto", "none", "text", "all"],
+    type: "select"
+  },
+  MozUserSelect: {
+    values: ["auto", "none", "text", "all"],
+    type: "select"
+  },
+  caretColor: { type: "string" },
+  appearance: {
+    values: ["none", "auto", "menulist-button", "textfield"],
+    type: "select"
+  },
+  WebkitAppearance: {
+    values: ["none", "auto", "menulist-button", "textfield"],
+    type: "select"
+  },
+  MozAppearance: {
+    values: ["none", "auto", "menulist-button", "textfield"],
+    type: "select"
+  },
+  // Outline
+  outline: { type: "string" },
+  outlineWidth: { type: "string" },
+  outlineStyle: {
+    values: ["none", "solid", "dashed", "dotted", "double", "groove", "ridge", "inset", "outset"],
+    type: "select"
+  },
+  outlineColor: { type: "string" },
+  outlineOffset: { type: "string" },
+  // Lists
+  listStyle: { type: "string" },
+  listStyleType: {
+    values: ["none", "disc", "circle", "square", "decimal", "decimal-leading-zero", "lower-roman", "upper-roman", "lower-alpha", "upper-alpha"],
+    type: "select"
+  },
+  listStylePosition: {
+    values: ["inside", "outside"],
+    type: "select"
+  },
+  // Miscellaneous
+  float: {
+    values: ["left", "right", "none"],
+    type: "select"
+  },
+  clear: {
+    values: ["left", "right", "both", "none"],
+    type: "select"
+  },
+  boxSizing: {
+    values: ["content-box", "border-box"],
+    type: "select"
+  },
+  objectFit: {
+    values: ["fill", "contain", "cover", "scale-down"],
+    type: "select"
+  },
+  objectPosition: {
+    values: ["top", "bottom", "left", "right", "center"],
+    type: "select"
+  },
+  resize: {
+    values: ["none", "both", "horizontal", "vertical"],
+    type: "select"
+  },
+  scrollBehavior: {
+    values: ["auto", "smooth"],
+    type: "select"
+  },
+  scrollSnapType: { type: "string" },
+  scrollSnapAlign: {
+    values: ["none", "start", "end", "center"],
+    type: "select"
+  },
+  scrollSnapStop: {
+    values: ["normal", "always"],
+    type: "select"
+  },
+  scrollMarginTop: { type: "string" },
+  scrollMarginRight: { type: "string" },
+  scrollMarginBottom: { type: "string" },
+  scrollMarginLeft: { type: "string" },
+  scrollPaddingTop: { type: "string" },
+  scrollPaddingRight: { type: "string" },
+  scrollPaddingBottom: { type: "string" },
+  scrollPaddingLeft: { type: "string" },
+  overscrollBehavior: {
+    values: ["auto", "contain", "none"],
+    type: "select"
+  },
+  overscrollBehaviorX: {
+    values: ["auto", "contain", "none"],
+    type: "select"
+  },
+  overscrollBehaviorY: {
+    values: ["auto", "contain", "none"],
+    type: "select"
+  },
+  // CSS Containment — container queries depend on these.
+  containerType: {
+    values: ["normal", "size", "inline-size"],
+    type: "select"
+  },
+  containerName: { type: "string" },
+  accentColor: { type: "string" },
+  // SVG
+  stroke: { type: "string" },
+  strokeWidth: { type: "string" },
+  strokeDasharray: { type: "string" },
+  strokeDashoffset: { type: "string" },
+  strokeLinecap: {
+    values: ["butt", "round", "square"],
+    type: "select"
+  },
+  strokeLinejoin: {
+    values: ["miter", "round", "bevel"],
+    type: "select"
+  },
+  strokeOpacity: { type: "number" },
+  fill: { type: "string" },
+  fillOpacity: { type: "number" },
+  fillRule: {
+    values: ["nonzero", "evenodd"],
+    type: "select"
+  }
+};
+var CSS_PROPERTIES = Object.keys(CSS_PROPERTIES_DEFINITION);
+var VISUAL_MODE_PROPERTIES = {
+  "Layout": ["display"],
+  "Grid": ["gridTemplateColumns"],
+  "Flexbox": ["flexDirection", "flexWrap", "justifyContent", "alignItems", "gap", "flexGrow", "flexShrink", "flexBasis"],
+  "Spacing": ["margin", "marginTop", "marginRight", "marginBottom", "marginLeft", "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft"],
+  "Size": ["width", "height", "minWidth", "minHeight", "maxWidth", "maxHeight"],
+  "Position": ["position", "top", "right", "bottom", "left", "zIndex"],
+  "Typography": ["fontFamily", "fontWeight", "fontSize", "lineHeight", "color", "letterSpacing", "textAlign", "textTransform", "textDecoration"],
+  "Background": ["backgroundColor", "backgroundImage", "backgroundSize", "backgroundPosition", "backgroundRepeat", "opacity"],
+  "Borders": ["borderRadius", "borderWidth", "borderStyle", "borderColor"],
+  "Effects": ["boxShadow", "transform", "transition", "filter"],
+  "Overflow": ["overflow", "whiteSpace"],
+  "Interaction": ["cursor", "pointerEvents"]
+};
+var VISUAL_MODE_PROPERTIES_SET = new Set(
+  Object.values(VISUAL_MODE_PROPERTIES).flat()
+);
+
+// ../core/lib/shared/utilityClassConfig.ts
+var propertyMap = {
+  // Padding
+  padding: "p",
+  paddingTop: "pt",
+  paddingRight: "pr",
+  paddingBottom: "pb",
+  paddingLeft: "pl",
+  paddingInline: "px",
+  paddingBlock: "py",
+  // Margin
+  margin: "m",
+  marginTop: "mt",
+  marginRight: "mr",
+  marginBottom: "mb",
+  marginLeft: "ml",
+  marginInline: "mx",
+  marginBlock: "my",
+  // Display & Layout
+  display: "d",
+  flexDirection: "fd",
+  justifyContent: "jc",
+  alignItems: "ai",
+  alignContent: "ac",
+  flex: "flex",
+  flexWrap: "fw",
+  gap: "g",
+  rowGap: "rg",
+  columnGap: "cg",
+  // Sizing
+  width: "w",
+  height: "h",
+  maxWidth: "mw",
+  maxHeight: "mh",
+  minWidth: "miw",
+  minHeight: "mih",
+  aspectRatio: "ar",
+  // Colors & Background
+  backgroundColor: "bgc",
+  background: "bg",
+  backgroundImage: "bgi",
+  color: "c",
+  // Borders & Radius
+  border: "b",
+  borderRadius: "br",
+  borderTop: "bt",
+  borderRight: "border-r",
+  borderBottom: "bb",
+  borderLeft: "bl",
+  borderTopLeftRadius: "brtl",
+  borderTopRightRadius: "brtr",
+  borderBottomLeftRadius: "brbl",
+  borderBottomRightRadius: "brbr",
+  borderColor: "bc",
+  // Text
+  fontSize: "fs",
+  fontWeight: "fe",
+  fontFamily: "ff",
+  textAlign: "ta",
+  textDecoration: "td",
+  textTransform: "tt",
+  lineHeight: "lh",
+  letterSpacing: "ls",
+  wordBreak: "wb",
+  overflowWrap: "ow",
+  textIndent: "ti",
+  verticalAlign: "va",
+  whiteSpace: "whs",
+  // Lists
+  listStyle: "lst",
+  listStyleType: "lstt",
+  listStylePosition: "lstp",
+  // Transform & Effects
+  opacity: "o",
+  transform: "tm",
+  transformOrigin: "tmo",
+  boxShadow: "bsh",
+  textShadow: "ts",
+  filter: "flt",
+  backdropFilter: "bdf",
+  backfaceVisibility: "bfv",
+  mixBlendMode: "mbm",
+  clipPath: "cp",
+  // Positioning
+  position: "pos",
+  top: "top",
+  right: "r",
+  bottom: "bo",
+  left: "l",
+  inset: "ins",
+  zIndex: "z",
+  // Grid Layout
+  gridTemplateColumns: "gtc",
+  gridTemplateRows: "gtr",
+  gridTemplateAreas: "gta",
+  gridGap: "gg",
+  gridAutoFlow: "gaf",
+  gridColumn: "gc",
+  gridRow: "gr",
+  gridArea: "ga",
+  gridAutoRows: "gar",
+  gridAutoColumns: "gac",
+  justifyItems: "ji",
+  justifySelf: "jse",
+  placeContent: "plc",
+  placeItems: "pli",
+  placeSelf: "pls",
+  // Flexbox extras
+  flexGrow: "fg",
+  flexShrink: "fsh",
+  flexBasis: "fb",
+  order: "ord",
+  alignSelf: "as",
+  // Outline
+  outline: "ol",
+  outlineWidth: "olw",
+  outlineStyle: "ols",
+  outlineColor: "olc",
+  outlineOffset: "olo",
+  // Other
+  overflow: "ov",
+  overflowX: "ovx",
+  overflowY: "ovy",
+  cursor: "cu",
+  pointerEvents: "pe",
+  userSelect: "us",
+  transition: "tn",
+  objectFit: "objf",
+  objectPosition: "objp",
+  boxSizing: "bsz",
+  visibility: "vis",
+  resize: "rsz",
+  scrollBehavior: "scb",
+  accentColor: "acc"
+};
+var prefixToCSSProperty = {
+  // Spacing
+  p: "padding",
+  pt: "padding-top",
+  pr: "padding-right",
+  pb: "padding-bottom",
+  pl: "padding-left",
+  px: "padding",
+  py: "padding",
+  m: "margin",
+  mt: "margin-top",
+  mr: "margin-right",
+  mb: "margin-bottom",
+  ml: "margin-left",
+  mx: "margin",
+  my: "margin",
+  g: "gap",
+  rg: "row-gap",
+  cg: "column-gap",
+  // Sizing
+  w: "width",
+  h: "height",
+  mw: "max-width",
+  mh: "max-height",
+  miw: "min-width",
+  mih: "min-height",
+  ar: "aspect-ratio",
+  // Colors & Background
+  bgc: "background-color",
+  bg: "background",
+  bgi: "background-image",
+  c: "color",
+  bc: "border-color",
+  // Borders
+  b: "border",
+  br: "border-radius",
+  brtl: "border-top-left-radius",
+  brtr: "border-top-right-radius",
+  brbl: "border-bottom-left-radius",
+  brbr: "border-bottom-right-radius",
+  bt: "border-top",
+  bb: "border-bottom",
+  bl: "border-left",
+  "border-r": "border-right",
+  // Text
+  fs: "font-size",
+  fe: "font-weight",
+  ff: "font-family",
+  ta: "text-align",
+  td: "text-decoration",
+  tt: "text-transform",
+  lh: "line-height",
+  ls: "letter-spacing",
+  wb: "word-break",
+  ow: "overflow-wrap",
+  ti: "text-indent",
+  va: "vertical-align",
+  whs: "white-space",
+  // Lists
+  lst: "list-style",
+  lstt: "list-style-type",
+  lstp: "list-style-position",
+  // Display
+  d: "display",
+  // Flexbox
+  fd: "flex-direction",
+  jc: "justify-content",
+  ai: "align-items",
+  ac: "align-content",
+  as: "align-self",
+  flex: "flex",
+  fw: "flex-wrap",
+  fg: "flex-grow",
+  fsh: "flex-shrink",
+  fb: "flex-basis",
+  ord: "order",
+  // Grid
+  gtc: "grid-template-columns",
+  gtr: "grid-template-rows",
+  gta: "grid-template-areas",
+  gg: "grid-gap",
+  gaf: "grid-auto-flow",
+  gc: "grid-column",
+  gr: "grid-row",
+  ga: "grid-area",
+  gar: "grid-auto-rows",
+  gac: "grid-auto-columns",
+  ji: "justify-items",
+  jse: "justify-self",
+  plc: "place-content",
+  pli: "place-items",
+  pls: "place-self",
+  // Effects
+  o: "opacity",
+  tm: "transform",
+  tmo: "transform-origin",
+  bsh: "box-shadow",
+  ts: "text-shadow",
+  flt: "filter",
+  bdf: "backdrop-filter",
+  bfv: "backface-visibility",
+  mbm: "mix-blend-mode",
+  cp: "clip-path",
+  // Positioning
+  pos: "position",
+  top: "top",
+  r: "right",
+  bo: "bottom",
+  l: "left",
+  ins: "inset",
+  z: "z-index",
+  // Outline
+  ol: "outline",
+  olw: "outline-width",
+  ols: "outline-style",
+  olc: "outline-color",
+  olo: "outline-offset",
+  // Other
+  ov: "overflow",
+  ovx: "overflow-x",
+  ovy: "overflow-y",
+  cu: "cursor",
+  pe: "pointer-events",
+  us: "user-select",
+  tn: "transition",
+  objf: "object-fit",
+  objp: "object-position",
+  bsz: "box-sizing",
+  vis: "visibility",
+  rsz: "resize",
+  scb: "scroll-behavior",
+  acc: "accent-color"
+};
+
+// ../core/lib/shared/responsiveScaling.ts
+var DEFAULT_FLUID_RANGE = { min: 320, max: 1440 };
+var DEFAULT_SITE_MARGIN = { min: 16, max: 32 };
+function getScaleCategory(property) {
+  const propertyStr = property;
+  if (property === "fontSize") return "fontSize";
+  if (propertyStr.startsWith("padding")) return "padding";
+  if (propertyStr.startsWith("margin")) return "margin";
+  if (property === "gap" || property === "rowGap" || property === "columnGap") return "gap";
+  if (propertyStr === "borderRadius" || propertyStr.startsWith("border") && propertyStr.includes("Radius")) return "borderRadius";
+  if (property === "width" || property === "height" || property === "maxWidth" || property === "maxHeight" || property === "minWidth" || property === "minHeight") return "size";
+  return null;
+}
+function parseValue2(valueStr) {
+  const match = valueStr.trim().match(/^(-?[\d.]+)(px|rem|em|%|pt)$/);
+  if (!match) return null;
+  return {
+    value: parseFloat(match[1]),
+    unit: match[2]
+  };
+}
+function calculateResponsiveValue(baseValue, baseReference, scale) {
+  if (Math.abs(baseValue) <= baseReference) {
+    return Math.round(baseValue);
+  }
+  const scaled = baseValue + (baseValue - baseReference) * (scale - 1);
+  return Math.round(scaled);
+}
+function getScaleMultiplier(scales, property, breakpoint) {
+  const category = getScaleCategory(property);
+  if (!category || !scales[category]) return null;
+  const scaleConfig = scales[category];
+  return scaleConfig?.[breakpoint] ?? null;
+}
+function parseMultiValue(valueStr) {
+  const normalized = valueStr.replace(/(?<=\w)-(?=\d|auto|inherit|initial|unset)/g, " ");
+  return normalized.trim().split(/\s+/).filter((v) => v.length > 0);
+}
+function scaleValue(valueStr, baseReference, scale) {
+  const parsed = parseValue2(valueStr);
+  if (!parsed) return null;
+  if (parsed.unit === "%" || parsed.unit === "em") {
+    return valueStr.trim();
+  }
+  const scaledValue = calculateResponsiveValue(parsed.value, baseReference, scale);
+  return `${scaledValue}${parsed.unit}`;
+}
+function scalePropertyValue(valueStr, baseReference, scale) {
+  const parts = parseMultiValue(valueStr);
+  if (parts.length === 0) return null;
+  const scaledParts = parts.map((part) => {
+    const scaled = scaleValue(part, baseReference, scale);
+    if (scaled !== null) {
+      return scaled;
+    }
+    return part;
+  });
+  return scaledParts.join(" ");
+}
+function getSmallestBreakpointName(breakpoints) {
+  if (!breakpoints) return null;
+  const entries = Object.entries(breakpoints);
+  if (entries.length === 0) return null;
+  let smallestName = entries[0][0];
+  let smallestWidth = entries[0][1].breakpoint;
+  for (const [name, cfg] of entries) {
+    if (cfg.breakpoint < smallestWidth) {
+      smallestWidth = cfg.breakpoint;
+      smallestName = name;
+    }
+  }
+  return smallestName;
+}
+function buildFluidClamp(baseValue, unit, scale, vpMin, vpMax, baseReference = 16) {
+  const max = baseValue;
+  const min = calculateResponsiveValue(baseValue, baseReference, scale);
+  if (min === max || vpMax === vpMin) {
+    return `${formatNumber(max)}${unit}`;
+  }
+  const unitToPx = unit === "rem" ? 16 : 1;
+  const minPx = min * unitToPx;
+  const maxPx = max * unitToPx;
+  const slopePx = (maxPx - minPx) / (vpMax - vpMin);
+  const interceptPx = minPx - slopePx * vpMin;
+  const interceptInUnit = interceptPx / unitToPx;
+  const slopeVw = slopePx * 100;
+  return `clamp(${formatNumber(min)}${unit}, ${formatNumber(interceptInUnit)}${unit} + ${formatNumber(slopeVw)}vw, ${formatNumber(max)}${unit})`;
+}
+function formatNumber(n) {
+  if (Number.isInteger(n)) return String(n);
+  return Number(n.toFixed(4)).toString();
+}
+function buildFluidPropertyValue(valueStr, scale, vpMin, vpMax, baseReference = 16) {
+  const parts = parseMultiValue(valueStr);
+  if (parts.length === 0) return null;
+  let anyScaled = false;
+  const out = parts.map((part) => {
+    const parsed = parseValue2(part);
+    if (!parsed) return part;
+    if (parsed.unit === "%" || parsed.unit === "em") return part;
+    anyScaled = true;
+    return buildFluidClamp(parsed.value, parsed.unit, scale, vpMin, vpMax, baseReference);
+  });
+  return anyScaled ? out.join(" ") : null;
+}
+var DEFAULT_RESPONSIVE_SCALES = {
+  enabled: false,
+  mode: "breakpoints",
+  baseReference: 16,
+  fluidRange: { ...DEFAULT_FLUID_RANGE },
+  siteMargin: { ...DEFAULT_SITE_MARGIN },
+  fontSize: {
+    tablet: 0.88,
+    mobile: 0.75
+  },
+  padding: {
+    tablet: 0.75,
+    mobile: 0.5
+  },
+  margin: {
+    tablet: 0.7,
+    mobile: 0.45
+  },
+  gap: {
+    tablet: 0.65,
+    mobile: 0.4
+  },
+  borderRadius: {
+    tablet: 0.85,
+    mobile: 0.7
+  },
+  size: {
+    tablet: 0.9,
+    mobile: 0.75
+  }
+};
+
+// ../core/lib/shared/pxToRem.ts
+var PX_REGEX = /(-?\d*\.?\d+)px/g;
+function convertPxToRem(cssValue, baseFontSize) {
+  return cssValue.replace(PX_REGEX, (_, num) => {
+    const px = parseFloat(num);
+    if (px === 0) return "0";
+    const rem = px / baseFontSize;
+    const rounded = parseFloat(rem.toFixed(4));
+    return `${rounded}rem`;
+  });
+}
+var PX_KEEP_PROPERTIES = /* @__PURE__ */ new Set([
+  "border-width",
+  "border-top-width",
+  "border-right-width",
+  "border-bottom-width",
+  "border-left-width",
+  "outline-width",
+  "outline-offset",
+  "border",
+  "box-shadow",
+  "text-shadow"
+]);
+function shouldConvertProperty(cssProperty) {
+  return !PX_KEEP_PROPERTIES.has(cssProperty);
+}
+function applyRemConversion(declarations, remConfig) {
+  if (!remConfig?.enabled) return declarations;
+  return declarations.split(";").map((decl) => {
+    const trimmed = decl.trim();
+    if (!trimmed) return "";
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) return trimmed;
+    const property = trimmed.substring(0, colonIndex).trim();
+    const value = trimmed.substring(colonIndex + 1).trim();
+    if (shouldConvertProperty(property)) {
+      return `${property}: ${convertPxToRem(value, remConfig.baseFontSize)}`;
+    }
+    return trimmed;
+  }).filter(Boolean).join("; ");
+}
+
+// ../core/lib/shared/cssGeneration.ts
+var SORTED_PREFIXES = Object.keys(prefixToCSSProperty).sort((a, b) => b.length - a.length);
+var cssPropertyOrderMap = (() => {
+  const map = /* @__PURE__ */ new Map();
+  const props = Object.keys(propertyMap);
+  for (let i = 0; i < props.length; i++) {
+    const kebab = props[i].replace(/([A-Z])/g, "-$1").toLowerCase();
+    map.set(kebab, i);
+  }
+  return map;
+})();
+function getResponsiveMode(scales) {
+  return scales?.mode ?? "breakpoints";
+}
+function applyFluidToStyle(style, responsiveScales, breakpoints) {
+  const range = responsiveScales.fluidRange ?? DEFAULT_FLUID_RANGE;
+  const baseRef = responsiveScales.baseReference ?? 16;
+  const smallest = getSmallestBreakpointName(breakpoints);
+  if (!smallest) return style;
+  const out = {};
+  for (const [prop, value] of Object.entries(style)) {
+    if (typeof value === "object" && value !== null && "_mapping" in value) {
+      out[prop] = value;
+      continue;
+    }
+    if (value == null || value === "") {
+      out[prop] = value;
+      continue;
+    }
+    const scale = getScaleMultiplier(
+      responsiveScales,
+      prop,
+      smallest
+    );
+    if (scale == null || scale === 1) {
+      out[prop] = value;
+      continue;
+    }
+    const fluidValue = buildFluidPropertyValue(
+      String(value),
+      scale,
+      range.min,
+      range.max,
+      baseRef
+    );
+    out[prop] = fluidValue ?? value;
+  }
+  return out;
+}
+var CONTAINER_RESERVED_VALUES = /* @__PURE__ */ new Set(["auto", "inherit", "initial", "unset", ""]);
+function applyContainerPattern(style, fluidActive) {
+  if (!fluidActive) return style;
+  const w = style.width;
+  const mw = style.maxWidth;
+  if (w == null || mw == null) return style;
+  if (typeof w !== "string" || typeof mw !== "string") return style;
+  if (w !== mw) return style;
+  if (CONTAINER_RESERVED_VALUES.has(w.trim())) return style;
+  return {
+    ...style,
+    width: "calc(100% - var(--site-margin) * 2)",
+    marginLeft: "auto",
+    marginRight: "auto"
+  };
+}
+function isResponsiveStyle(style) {
+  return typeof style === "object" && style !== null && ("base" in style || "tablet" in style || "mobile" in style);
+}
+function styleObjectToCSS(style) {
+  const declarations = [];
+  for (const [prop, value] of Object.entries(style)) {
+    if (typeof value === "object" && value !== null && "_mapping" in value) {
+      continue;
+    }
+    const cssProperty = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+    let cssValue = String(value);
+    if ((prop === "backgroundColor" || prop === "color" || prop === "borderColor") && !cssValue.startsWith("#") && !cssValue.startsWith("rgb") && !cssValue.startsWith("var(") && !cssValue.includes("(")) {
+      cssValue = `var(--${cssValue})`;
+    }
+    declarations.push(`${cssProperty}: ${cssValue}`);
+  }
+  return declarations.join("; ");
+}
+function generateInteractiveCSS(elementClass, interactiveStyles, breakpoints = DEFAULT_BREAKPOINTS, remConfig, responsiveScales) {
+  const css = [];
+  const breakpointValues = getBreakpointValues(breakpoints);
+  const scalingEnabled = responsiveScales?.enabled === true;
+  const mode = getResponsiveMode(responsiveScales);
+  const fluidActive = scalingEnabled && mode === "fluid";
+  for (const rule of interactiveStyles) {
+    const { prefix, postfix, style } = rule;
+    const fullSelector = `${prefix || ""}.${elementClass}${postfix || ""}`;
+    const sortedBreakpoints = Object.entries(breakpointValues).sort(
+      ([, a], [, b]) => b - a
+    );
+    if (isResponsiveStyle(style)) {
+      const responsive = style;
+      if (responsive.base && Object.keys(responsive.base).length > 0) {
+        let baseStyle = responsive.base;
+        if (fluidActive) {
+          baseStyle = applyContainerPattern(baseStyle, true);
+          baseStyle = applyFluidToStyle(baseStyle, responsiveScales, breakpoints);
+        }
+        const properties = applyRemConversion(styleObjectToCSS(baseStyle), remConfig);
+        if (properties) {
+          css.push(`${fullSelector} { ${properties}; }`);
+        }
+      }
+      for (const [breakpointName, breakpointValue] of sortedBreakpoints) {
+        const explicit = responsive[breakpointName];
+        let merged = null;
+        if (explicit && Object.keys(explicit).length > 0) {
+          merged = fluidActive ? applyContainerPattern({ ...explicit }, true) : { ...explicit };
+        }
+        if (scalingEnabled && !fluidActive && responsive.base) {
+          const scaled = scaleStyleForBreakpoint(
+            responsive.base,
+            responsiveScales,
+            breakpointName,
+            new Set(Object.keys(explicit ?? {}))
+          );
+          if (Object.keys(scaled).length > 0) {
+            merged = { ...merged ?? {}, ...scaled };
+          }
+        }
+        if (merged && Object.keys(merged).length > 0) {
+          const properties = applyRemConversion(styleObjectToCSS(merged), remConfig);
+          if (properties) {
+            css.push(
+              `@media (max-width: ${breakpointValue}px) { ${fullSelector} { ${properties}; } }`
+            );
+          }
+        }
+      }
+    } else {
+      const flatStyle = style;
+      if (Object.keys(flatStyle).length > 0) {
+        let baseFlat = flatStyle;
+        if (fluidActive) {
+          baseFlat = applyContainerPattern(baseFlat, true);
+          baseFlat = applyFluidToStyle(baseFlat, responsiveScales, breakpoints);
+        }
+        const properties = applyRemConversion(styleObjectToCSS(baseFlat), remConfig);
+        if (properties) {
+          css.push(`${fullSelector} { ${properties}; }`);
+        }
+        if (scalingEnabled && !fluidActive) {
+          for (const [breakpointName, breakpointValue] of sortedBreakpoints) {
+            const scaled = scaleStyleForBreakpoint(
+              flatStyle,
+              responsiveScales,
+              breakpointName,
+              /* @__PURE__ */ new Set()
+            );
+            if (Object.keys(scaled).length === 0) continue;
+            const scaledProps = applyRemConversion(styleObjectToCSS(scaled), remConfig);
+            if (!scaledProps) continue;
+            css.push(
+              `@media (max-width: ${breakpointValue}px) { ${fullSelector} { ${scaledProps}; } }`
+            );
+          }
+        }
+      }
+    }
+  }
+  return css.join("\n");
+}
+function scaleStyleForBreakpoint(baseStyle, responsiveScales, breakpointName, skipProperties) {
+  const result = {};
+  const baseRef = responsiveScales.baseReference ?? 16;
+  for (const [property, value] of Object.entries(baseStyle)) {
+    if (skipProperties.has(property)) continue;
+    if (typeof value === "object" && value !== null && "_mapping" in value) continue;
+    if (value == null) continue;
+    const strValue = String(value);
+    if (strValue === "") continue;
+    const scale = getScaleMultiplier(
+      responsiveScales,
+      property,
+      breakpointName
+    );
+    if (scale == null) continue;
+    const scaledValue = scalePropertyValue(strValue, baseRef, scale);
+    if (scaledValue == null || scaledValue === strValue) continue;
+    result[property] = scaledValue;
+  }
+  return result;
+}
+
+// ../core/lib/shared/utilityClassMapper.ts
+var propertyOrder = Object.keys(propertyMap);
+
+// ../core/lib/shared/elementClassName.ts
+function shortHash(input) {
+  let hash = 5381;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) + hash ^ input.charCodeAt(i);
+  }
+  return Math.abs(hash).toString(36).slice(-5);
+}
+
+// ../core/lib/shared/validation/index.ts
+init_schemas();
+
+// ../core/lib/shared/validation/validators.ts
+init_schemas();
+
+// ../core/lib/shared/validation/cmsValidators.ts
+import { z as z2 } from "zod";
+var CMS_COLLECTION_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
+var CMSCollectionIdSchema = z2.string().min(1, "Collection ID is required").regex(CMS_COLLECTION_ID_REGEX, "Collection ID must contain only letters, numbers, underscores, and hyphens");
+
+// ../core/lib/shared/validation/commentValidators.ts
+import { z as z3 } from "zod";
+var CommentStatusSchema = z3.enum(COMMENT_STATUSES);
+var CommentAuthorSchema = z3.object({
+  login: z3.string().min(1),
+  name: z3.string().optional(),
+  avatarUrl: z3.string().optional()
+});
+var CommentNodeIdentitySchema = z3.object({
+  kind: z3.enum(["component", "node"]),
+  name: z3.string().min(1),
+  label: z3.string().optional()
+});
+var CommentAnchorSchema = z3.object({
+  nodePath: z3.array(z3.number().int().nonnegative()),
+  nodeIdentity: CommentNodeIdentitySchema,
+  offsetXPercent: z3.number().min(0).max(1),
+  offsetYPercent: z3.number().min(0).max(1),
+  breakpoint: z3.string().optional()
+});
+var CommentThreadEntrySchema = z3.object({
+  id: z3.string().min(1),
+  author: CommentAuthorSchema,
+  createdAt: z3.string().min(1),
+  text: z3.string(),
+  statusChange: CommentStatusSchema.nullable()
+});
+var CommentSchema = z3.object({
+  _id: z3.string().min(1),
+  _filename: z3.string().min(1),
+  _pagePath: z3.string().min(1),
+  _seq: z3.number().int().nonnegative(),
+  _createdAt: z3.string().min(1),
+  _updatedAt: z3.string().min(1),
+  _commitSha: z3.string().nullable(),
+  anchor: CommentAnchorSchema,
+  status: CommentStatusSchema,
+  thread: z3.array(CommentThreadEntrySchema).min(1)
+});
+
+// ../core/lib/shared/index.ts
+init_registry();
+
+// ../core/lib/shared/expressionEvaluator.ts
+import jsep from "jsep";
+
+// ../core/lib/shared/globalTemplateContext.ts
+var defaultValues = {
+  isEditorMode: false
+};
+var globalContext = { ...defaultValues };
+
+// ../core/lib/shared/interactiveStyleMappings.ts
+function isStyleMapping(value) {
+  return typeof value === "object" && value !== null && "_mapping" in value && value._mapping === true;
+}
+
+// lib/server/loadI18nConfig.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function loadI18nConfig(projectRoot) {
+  try {
+    const cfgPath = join(projectRoot, "project.config.json");
+    if (!existsSync(cfgPath)) return DEFAULT_I18N_CONFIG;
+    const raw = readFileSync(cfgPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return migrateI18nConfig(parsed.i18n);
+  } catch {
+    return DEFAULT_I18N_CONFIG;
+  }
+}
+
+export {
+  DEFAULT_BREAKPOINTS,
+  generateInteractiveCSS,
+  shortHash,
+  DEFAULT_I18N_CONFIG,
+  isI18nValue,
+  resolveI18nValue,
+  extractLocaleFromPath,
+  buildLocalizedPath,
+  isStyleMapping,
+  parseSortExpression,
+  serializeSortExpression,
+  parseFilterExpression,
+  serializeFilterExpression,
+  loadI18nConfig
+};
+//# sourceMappingURL=chunk-IVGZB6XN.js.map