meno-core 1.0.53 → 1.0.54

package/lib/shared/netlifyLocale404.ts

@@ -0,0 +1,110 @@
+/**
+ * Locale-scoped Netlify 404 rules + the managed netlify.toml block that carries them.
+ *
+ * Why: a multi-locale static build emits a localized 404 per non-default locale
+ * (`dist/pl/404/index.html`), but a static host serves exactly ONE catch-all 404
+ * page unless told otherwise — so `/pl/<missing>` would get the default-locale
+ * `404.html`. These rules scope the 404 per locale prefix.
+ *
+ * Shared by every netlify.toml producer — meno-astro's `convertProject` scaffold,
+ * the JSON→Astro export (`build-astro.ts`), the CLI new-project scaffold — and by
+ * the studio save-config route, which re-syncs the managed block when the locale
+ * set changes AFTER the file was first written (so a project that adds a locale
+ * later still gets its rules). It lives in meno-core because the dependency
+ * direction is astro→core: meno-core must never import from meno-astro.
+ */
+
+import type { I18nConfig } from './types';
+
+/**
+ * First line of the managed block. Everything between the markers (inclusive) is
+ * generated and may be rewritten wholesale by `syncNetlifyLocale404Block`; user
+ * content outside the markers is never touched.
+ */
+export const NETLIFY_LOCALE_404_BEGIN = '# BEGIN meno locale-404 redirects (generated — do not edit between markers)';
+
+/** Last line of the managed block. */
+export const NETLIFY_LOCALE_404_END = '# END meno locale-404 redirects';
+
+/**
+ * Locale-scoped 404 rules for a netlify.toml — one `[[redirects]]` block per
+ * non-default locale (`''` for single-locale configs):
+ *
+ *   [[redirects]]
+ *     from = "/pl/*"
+ *     to = "/pl/404/index.html"
+ *     status = 404
+ *
+ * Netlify semantics (verified against Netlify's "redirect options" docs, the
+ * documented "localized custom 404" pattern): a redirect with `status = 404` and no
+ * `force` is a NON-SHADOWING rewrite — a request that matches an existing file is
+ * served normally (real `/pl/...` pages always win), and only an unmatched `/pl/*`
+ * URL serves the `to` file's CONTENT with an HTTP 404 status (the URL stays put; no
+ * 3xx). Everything the rules don't cover falls through to Netlify's root convention:
+ * a top-level `404.html` (which Astro builds from `src/pages/404.astro`) is served
+ * automatically for any other unmatched URL — no explicit catch-all rule needed.
+ *
+ * Locale codes are sanity-checked (`/^[A-Za-z0-9_-]+$/`): a malformed code would
+ * corrupt the TOML / redirect syntax, and such a locale cannot produce a route anyway.
+ *
+ * Pure (config in, TOML fragment out) so it is directly unit-testable; callers own
+ * the existence gates (404 page present, netlify.toml ownership). Most callers
+ * should go through `syncNetlifyLocale404Block`, which wraps the rules in the
+ * managed marker block so later config saves can update them in place.
+ */
+export function netlifyLocale404Redirects(config: I18nConfig): string {
+  if (!config.locales || config.locales.length <= 1) return '';
+  const codes = config.locales
+    .map((l) => l.code)
+    .filter((code) => code !== config.defaultLocale && /^[A-Za-z0-9_-]+$/.test(code));
+  if (codes.length === 0) return '';
+  const header =
+    "\n# Locale-scoped 404s — an unmatched /<locale>/* URL serves that locale's own\n" +
+    '# prerendered 404 page WITH a 404 status (non-shadowing: real pages still win).\n' +
+    '# Unmatched URLs outside these prefixes fall through to the default /404.html.\n';
+  const rules = codes
+    .map((code) => `[[redirects]]\n  from = "/${code}/*"\n  to = "/${code}/404/index.html"\n  status = 404\n`)
+    .join('\n');
+  return header + rules;
+}
+
+/**
+ * Insert / refresh / remove the managed locale-404 block in netlify.toml content.
+ * Pure (string in, string out) — callers own reading/writing the file.
+ *
+ *  - Rules applicable (multi-locale config AND `has404`) + no block yet → the block
+ *    is APPENDED (a trailing newline is added to the existing content first if it
+ *    lacks one).
+ *  - Rules applicable + block present → the block's contents are REPLACED in place
+ *    (idempotent: re-syncing identical state is a no-op).
+ *  - Rules no longer applicable (single-locale, or no 404 page) + block present →
+ *    the whole block is REMOVED; everything outside the markers stays byte-identical.
+ *  - Nothing applicable + no block → the content is returned unchanged.
+ *
+ * A corrupted block (BEGIN marker without its END) is left untouched — rewriting up
+ * to an unknown boundary could eat user content, and a hand-damaged block is the
+ * user taking ownership.
+ */
+export function syncNetlifyLocale404Block(content: string, config: I18nConfig, has404: boolean): string {
+  const rules = has404 ? netlifyLocale404Redirects(config) : '';
+  // `rules` starts with '\n' (terminating the BEGIN line) and ends with '\n'
+  // (putting END at line start), so the block is exactly BEGIN…rules…END lines.
+  const block = rules ? `${NETLIFY_LOCALE_404_BEGIN}${rules}${NETLIFY_LOCALE_404_END}\n` : '';
+
+  const beginIdx = content.indexOf(NETLIFY_LOCALE_404_BEGIN);
+  if (beginIdx === -1) {
+    if (!block) return content;
+    const base = content === '' || content.endsWith('\n') ? content : `${content}\n`;
+    return base + block;
+  }
+
+  const endMarkerIdx = content.indexOf(NETLIFY_LOCALE_404_END, beginIdx);
+  if (endMarkerIdx === -1) return content; // corrupted block — refuse to guess its extent
+
+  let endIdx = endMarkerIdx + NETLIFY_LOCALE_404_END.length;
+  if (content[endIdx] === '\n') endIdx += 1; // the END line's own newline belongs to the block
+
+  const before = content.slice(0, beginIdx);
+  const after = content.slice(endIdx);
+  return before + block + after;
+}

package/lib/shared/nodeUtils.test.ts

@@ -24,7 +24,15 @@ import {
   isEmptyContainer,
 } from './nodeUtils';
 import { NODE_TYPE } from './constants';
-import type { ComponentNode, ComponentInstanceNode, HtmlNode, SlotMarker, EmbedNode, LinkNode, LocaleListNode } from './types';
+import type {
+  ComponentNode,
+  ComponentInstanceNode,
+  HtmlNode,
+  SlotMarker,
+  EmbedNode,
+  LinkNode,
+  LocaleListNode,
+} from './types';
 import { registerBuiltInNodeTypes } from './registry';
 
 describe('nodeUtils', () => {
@@ -126,11 +134,11 @@ describe('nodeUtils', () => {
       const node: ComponentInstanceNode = {
         type: NODE_TYPE.COMPONENT,
         component: 'Button',
-        props: { text: 'Click me' }
+        props: { text: 'Click me' },
       };
       expect(extractNodeProperties(node)).toEqual({
         componentName: 'Button',
-        props: { text: 'Click me' }
+        props: { text: 'Click me' },
       });
     });
 
@@ -138,7 +146,7 @@ describe('nodeUtils', () => {
       const node: HtmlNode = { type: NODE_TYPE.NODE, tag: 'div' };
       expect(extractNodeProperties(node)).toEqual({
         tag: 'div',
-        props: {}
+        props: {},
       });
     });
 
@@ -328,7 +336,7 @@ describe('nodeUtils', () => {
       const mapping = {
         _mapping: true,
         prop: 'visible',
-        values: { 'true': true, 'false': false }
+        values: { true: true, false: false },
       };
       expect(isBooleanMapping(mapping)).toBe(true);
     });
@@ -368,8 +376,8 @@ describe('nodeUtils', () => {
         if: {
           _mapping: true,
           prop: 'showBanner',
-          values: { 'true': true, 'false': false }
-        }
+          values: { true: true, false: false },
+        },
       } as any;
 
       expect(evaluateNodeIf(node, { showBanner: 'true' })).toBe(true);
@@ -383,8 +391,8 @@ describe('nodeUtils', () => {
         if: {
           _mapping: true,
           prop: 'status',
-          values: { 'active': true, 'inactive': false }
-        }
+          values: { active: true, inactive: false },
+        },
       } as any;
 
       // 'unknown' is not in the values map
@@ -398,8 +406,8 @@ describe('nodeUtils', () => {
         if: {
           _mapping: true,
           prop: 'visible',
-          values: { 'true': true, 'false': false }
-        }
+          values: { true: true, false: false },
+        },
       } as any;
 
       expect(evaluateNodeIf(node)).toBe(true);
@@ -409,7 +417,7 @@ describe('nodeUtils', () => {
       const node = {
         type: NODE_TYPE.NODE,
         tag: 'div',
-        if: '{{showBanner}}'
+        if: '{{showBanner}}',
       } as any;
 
       // String templates can't be resolved without context, default to true
@@ -420,7 +428,7 @@ describe('nodeUtils', () => {
       const node: ComponentInstanceNode = {
         type: NODE_TYPE.COMPONENT,
         component: 'Banner',
-        if: false
+        if: false,
       } as any;
       expect(evaluateNodeIf(node)).toBe(false);
     });
@@ -429,7 +437,7 @@ describe('nodeUtils', () => {
       const node: EmbedNode = {
         type: NODE_TYPE.EMBED,
         html: '<svg></svg>',
-        if: false
+        if: false,
       } as any;
       expect(evaluateNodeIf(node)).toBe(false);
     });
@@ -438,7 +446,7 @@ describe('nodeUtils', () => {
       const node: LinkNode = {
         type: NODE_TYPE.LINK,
         href: '/page',
-        if: true
+        if: true,
       } as any;
       expect(evaluateNodeIf(node)).toBe(true);
     });
@@ -515,7 +523,7 @@ describe('nodeUtils', () => {
       const node: HtmlNode = {
         type: NODE_TYPE.NODE,
         tag: 'div',
-        children: [{ type: NODE_TYPE.NODE, tag: 'span' }]
+        children: [{ type: NODE_TYPE.NODE, tag: 'span' }],
       };
       expect(isEmptyContainer(node)).toBe(false);
     });

package/lib/shared/nodeUtils.ts

@@ -3,7 +3,17 @@
  * Provides helper functions for working with ComponentNode types
  */
 
-import type { ComponentNode, ComponentInstanceNode, HtmlNode, SlotMarker, EmbedNode, LinkNode, LocaleListNode, ComponentDefinition, StructuredComponentDefinition } from './types';
+import type {
+  ComponentNode,
+  ComponentInstanceNode,
+  HtmlNode,
+  SlotMarker,
+  EmbedNode,
+  LinkNode,
+  LocaleListNode,
+  ComponentDefinition,
+  StructuredComponentDefinition,
+} from './types';
 import type { ListNode } from './registry/nodeTypes/ListNodeType';
 
 // For backward compatibility during migration
@@ -15,8 +25,20 @@ import { NODE_TYPE } from './constants';
  * These are self-closing tags like <img />, <br />, <input />, etc.
  */
 export const VOID_ELEMENTS = new Set([
-  'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
-  'link', 'meta', 'param', 'source', 'track', 'wbr'
+  'area',
+  'base',
+  'br',
+  'col',
+  'embed',
+  'hr',
+  'img',
+  'input',
+  'link',
+  'meta',
+  'param',
+  'source',
+  'track',
+  'wbr',
 ]);
 
 /**
@@ -112,13 +134,13 @@ export function extractNodeProperties(node: ComponentNode): {
   if (isComponentNode(node)) {
     return {
       componentName: node.component,
-      props: node.props || {}
+      props: node.props || {},
     };
   }
   if (isHtmlNode(node)) {
     return {
       tag: node.tag,
-      props: {}
+      props: {},
     };
   }
   return { props: {} };
@@ -129,7 +151,7 @@ export function extractNodeProperties(node: ComponentNode): {
  * This is a heuristic based on naming conventions:
  * - Components typically start with uppercase (e.g., "Card", "Button")
  * - HTML elements are lowercase (e.g., "div", "span")
- * 
+ *
  * Note: This is not foolproof, but works for most cases.
  * For accurate detection, use component registry lookup.
  */
@@ -220,10 +242,17 @@ export function isListNode(node: unknown): node is ListNode {
 /**
  * Validate that a node type is valid
  */
-export function isValidNodeType(type: string): type is typeof NODE_TYPE[keyof typeof NODE_TYPE] {
-  return type === NODE_TYPE.NODE || type === NODE_TYPE.COMPONENT || type === NODE_TYPE.SLOT ||
-    type === NODE_TYPE.EMBED || type === NODE_TYPE.LINK || type === NODE_TYPE.LOCALE_LIST ||
-    type === NODE_TYPE.LIST || type === 'cms-list'; // 'cms-list' supported for migration
+export function isValidNodeType(type: string): type is (typeof NODE_TYPE)[keyof typeof NODE_TYPE] {
+  return (
+    type === NODE_TYPE.NODE ||
+    type === NODE_TYPE.COMPONENT ||
+    type === NODE_TYPE.SLOT ||
+    type === NODE_TYPE.EMBED ||
+    type === NODE_TYPE.LINK ||
+    type === NODE_TYPE.LOCALE_LIST ||
+    type === NODE_TYPE.LIST ||
+    type === 'cms-list'
+  ); // 'cms-list' supported for migration
 }
 
 /**
@@ -258,7 +287,12 @@ export function hasIf(node: ComponentNode): node is ComponentNode & { if: IfCond
  * Check if a node is marked as slot content
  */
 export function isSlotContent(node: unknown): boolean {
-  return node != null && typeof node === 'object' && '_isSlotContent' in node && (node as Record<string, unknown>)._isSlotContent === true;
+  return (
+    node != null &&
+    typeof node === 'object' &&
+    '_isSlotContent' in node &&
+    (node as Record<string, unknown>)._isSlotContent === true
+  );
 }
 
 /**
@@ -389,10 +423,7 @@ export function isBooleanMapping(value: unknown): value is BooleanMapping {
  *   { visible: 'true' }
  * ) // true
  */
-export function evaluateNodeIf(
-  node: ComponentNode,
-  props?: Record<string, unknown>
-): boolean {
+export function evaluateNodeIf(node: ComponentNode, props?: Record<string, unknown>): boolean {
   const ifValue = hasIf(node) ? node.if : undefined;
 
   // No if property = render (default true)
@@ -441,7 +472,7 @@ export function evaluateNodeIf(
  * @returns The same node with _isSlotContent: true added to all object nodes
  */
 export function markAsSlotContent<T extends ComponentNode | ComponentNode[] | string | number | null | undefined>(
-  node: T
+  node: T,
 ): T {
   if (!node || typeof node !== 'object') return node;
 
@@ -455,8 +486,8 @@ export function markAsSlotContent<T extends ComponentNode | ComponentNode[] | st
   // Recursively mark children
   if ('children' in node && node.children) {
     if (Array.isArray(node.children)) {
-      node.children = node.children.map(child =>
-        typeof child === 'object' && child !== null ? markAsSlotContent(child) : child
+      node.children = node.children.map((child) =>
+        typeof child === 'object' && child !== null ? markAsSlotContent(child) : child,
       ) as typeof node.children;
     } else if (typeof node.children === 'object') {
       markAsSlotContent(node.children as ComponentNode);
@@ -465,4 +496,3 @@ export function markAsSlotContent<T extends ComponentNode | ComponentNode[] | st
 
   return node;
 }
-

package/lib/shared/pathArrayUtils.test.ts

@@ -5,7 +5,7 @@
 
 import { describe, it, expect } from 'bun:test';
 import {
-  Path,
+  type Path,
   ROOT_STRING,
   ROOT_0_STRING,
   CHILDREN_SEPARATOR,
@@ -312,4 +312,3 @@ describe('Path Array Utilities - Phase 1 Foundation', () => {
     });
   });
 });
-

package/lib/shared/pathArrayUtils.ts

@@ -2,7 +2,7 @@
  * Array-based path utilities
  * Paths are represented as number arrays internally: [0,0,1] instead of "root_0_children_0_children_1"
  * Root is represented as [0] (or empty array [] depending on context)
- * 
+ *
  * This file maintains backward compatibility while using the new modular path system.
  * All path utilities are re-exported from the organized path modules.
  */

package/lib/shared/pathSecurity.ts

@@ -11,7 +11,7 @@ import { resolve, sep } from 'path';
 export class PathTraversalError extends Error {
   constructor(
     public readonly requestedPath: string,
-    public readonly rootPath: string
+    public readonly rootPath: string,
   ) {
     super(`Path traversal detected: "${requestedPath}" escapes root "${rootPath}"`);
     this.name = 'PathTraversalError';

package/lib/shared/pathUtils.test.ts

@@ -94,7 +94,9 @@ describe('pathUtils', () => {
     });
 
     test('should handle deeply nested paths', () => {
-      expect(domPathToTreePath('root_children_0_children_1_children_2')).toBe('root_0_children_0_children_1_children_2');
+      expect(domPathToTreePath('root_children_0_children_1_children_2')).toBe(
+        'root_0_children_0_children_1_children_2',
+      );
     });
   });
 
@@ -115,11 +117,7 @@ describe('pathUtils', () => {
     });
 
     test('should handle deeply nested paths', () => {
-      expect(buildParentPaths([0, 0, 1, 2])).toEqual([
-        'root_0',
-        'root_0_children_0',
-        'root_0_children_0_children_1',
-      ]);
+      expect(buildParentPaths([0, 0, 1, 2])).toEqual(['root_0', 'root_0_children_0', 'root_0_children_0_children_1']);
     });
   });
 

package/lib/shared/pathUtils.ts

@@ -4,9 +4,9 @@
  */
 
 import type { Path } from './paths';
-import { 
-  stringToPath, 
-  pathToLegacyString, 
+import {
+  stringToPath,
+  pathToLegacyString,
   getParentPath as getParentPathArray,
   buildParentPaths as buildParentPathsArray,
   pathsEqual,
@@ -14,59 +14,59 @@ import {
   ROOT_STRING,
   domPathStringToTreePath,
   treePathToDomPathString,
-  isAncestorPath
+  isAncestorPath,
 } from './paths';
 
 /**
  * Convert a page path to static HTML file path
- * 
+ *
  * @example
  * getStaticFilePath("/") -> "./dist/index.html"
  * getStaticFilePath("/about") -> "./dist/about.html"
  * getStaticFilePath("/blog/post-1") -> "./dist/blog-post-1.html"
  */
-export function getStaticFilePath(pagePath: string, distDir: string = "./dist"): string {
-  if (pagePath === "/") {
+export function getStaticFilePath(pagePath: string, distDir: string = './dist'): string {
+  if (pagePath === '/') {
     return `${distDir}/index.html`;
   }
-  
+
   // Convert /about -> about.html
   // Convert /blog/post-1 -> blog-post-1.html (flat structure)
-  const pathParts = pagePath.substring(1).split("/");
-  const fileName = pathParts.join("-") + ".html";
-  
+  const pathParts = pagePath.substring(1).split('/');
+  const fileName = pathParts.join('-') + '.html';
+
   return `${distDir}/${fileName}`;
 }
 
 /**
  * Convert a page path to a page name (for file system)
- * 
+ *
  * @example
  * pathToPageName("/") -> "index"
  * pathToPageName("/about") -> "about"
  */
 export function pathToPageName(pagePath: string): string {
-  return pagePath === "/" ? "index" : pagePath.substring(1);
+  return pagePath === '/' ? 'index' : pagePath.substring(1);
 }
 
 /**
  * Convert a page name to a page path
- * 
+ *
  * @example
  * pageNameToPath("index") -> "/"
  * pageNameToPath("about") -> "/about"
  */
 export function pageNameToPath(pageName: string): string {
-  return pageName === "index" ? "/" : `/${pageName}`;
+  return pageName === 'index' ? '/' : `/${pageName}`;
 }
 
 /**
  * Convert tree path to DOM path
  * The tree adds a synthetic "root" container, so "root_0" in the tree corresponds to "root" in the DOM
  * Also accepts array paths: [0] -> "root", [0,0] -> "root_children_0"
- * 
+ *
  * Uses array operations internally for conversion.
- * 
+ *
  * @example
  * treePathToDomPath("root_0") -> "root"
  * treePathToDomPath("root_0_children_0") -> "root_children_0"
@@ -83,9 +83,9 @@ export function treePathToDomPath(treePath: Path | string): string {
  * Convert DOM path back to tree path
  * The tree adds a synthetic "root" container, so "root" in the DOM corresponds to "root_0" in the tree
  * Returns legacy string format for backward compatibility
- * 
+ *
  * Uses array operations internally for conversion.
- * 
+ *
  * @example
  * domPathToTreePath("root") -> "root_0"
  * domPathToTreePath("root_children_0") -> "root_0_children_0"
@@ -100,18 +100,18 @@ export function domPathToTreePath(domPath: string): string {
  * Build parent paths for expanding tree nodes
  * Returns all parent path segments for a given tree path
  * Also accepts array paths
- * 
+ *
  * @example
  * buildParentPaths("root_0_children_0_children_1") -> ["root_0", "root_0_children_0"]
  * buildParentPaths([0,0,1]) -> ["root_0", "root_0_children_0"]
  */
 export function buildParentPaths(treePath: Path | string): string[] {
   const pathArray = typeof treePath === 'string' ? stringToPath(treePath) : treePath;
-  
+
   if (isRootPathArray(pathArray)) {
     return [];
   }
-  
+
   const parentArrays = buildParentPathsArray(pathArray);
   return parentArrays.map(pathToLegacyString);
 }
@@ -134,43 +134,40 @@ export function getParentPathFromChildPath(childPath: Path | string): string {
  * Convert component instance path to component structure path
  * When editing a component, elements clicked inside the component instance on the page
  * need to be converted to their paths within the component structure.
- * 
+ *
  * Uses array operations internally for path manipulation.
- * 
+ *
  * @example
  * componentInstancePath: "root_children_0" (component instance on page)
  * instancePath: "root_children_0_children_1" (element inside instance)
  * Returns: "root_children_1" (component structure path)
- * 
+ *
  * @param instancePath - Path of element within component instance on page (DOM path string)
  * @param componentInstancePath - Path of the component instance root on the page (DOM path string)
  * @returns Component structure path (always starts with "root")
  */
-export function componentInstancePathToStructurePath(
-  instancePath: string,
-  componentInstancePath: string
-): string {
+export function componentInstancePathToStructurePath(instancePath: string, componentInstancePath: string): string {
   // Convert DOM paths to arrays for manipulation
   const instancePathArray = domPathStringToTreePath(instancePath);
   const componentInstancePathArray = domPathStringToTreePath(componentInstancePath);
-  
+
   // Check if instancePath is inside componentInstancePath using array operations
   if (!isAncestorPath(componentInstancePathArray, instancePathArray)) {
     // Not inside component instance - return as-is (shouldn't happen, but handle gracefully)
     return instancePath;
   }
-  
+
   // Extract relative path using array operations
   // componentInstancePathArray: [0, 0] -> instancePathArray: [0, 0, 1]
   // relative: [1] -> convert to DOM path: "root_children_1"
   const relativePathArray = instancePathArray.slice(componentInstancePathArray.length);
-  
+
   // Convert relative path array back to DOM path string
   // If relative is empty, return root
   if (relativePathArray.length === 0) {
     return ROOT_STRING;
   }
-  
+
   // Build component structure path: root + relative path
   return treePathToDomPathString(relativePathArray);
 }
@@ -179,34 +176,31 @@ export function componentInstancePathToStructurePath(
  * Convert component structure path to component instance path
  * When selecting an element in the component structure tree, convert it to
  * the path within the component instance on the page.
- * 
+ *
  * Uses array operations internally for path manipulation.
- * 
+ *
  * @example
  * componentInstancePath: "root_children_0" (component instance on page)
  * structurePath: "root_children_1" (element in component structure)
  * Returns: "root_children_0_children_1" (path within instance on page)
- * 
+ *
  * @param structurePath - Path within component structure (starts with "root", DOM path string)
  * @param componentInstancePath - Path of the component instance root on the page (DOM path string)
  * @returns Path within component instance on page (DOM path string)
  */
-export function componentStructurePathToInstancePath(
-  structurePath: string,
-  componentInstancePath: string
-): string {
+export function componentStructurePathToInstancePath(structurePath: string, componentInstancePath: string): string {
   // Convert DOM paths to arrays for manipulation
   const structurePathArray = domPathStringToTreePath(structurePath);
   const componentInstancePathArray = domPathStringToTreePath(componentInstancePath);
-  
+
   // Extract relative path from structure path (skip root [0])
   // structurePathArray: [0, 1] -> relative: [1]
   const relativePathArray = structurePathArray.slice(1);
-  
+
   // Combine component instance path with relative path using array operations
   // componentInstancePathArray: [0, 0] + relativePathArray: [1] -> [0, 0, 1]
   const instancePathArray: Path = [...componentInstancePathArray, ...relativePathArray];
-  
+
   // Convert back to DOM path string
   return treePathToDomPathString(instancePathArray);
 }
@@ -214,9 +208,9 @@ export function componentStructurePathToInstancePath(
 /**
  * Convert path for component editing context
  * When editing a component, converts component instance paths to component structure paths
- * 
+ *
  * Uses array operations internally for path manipulation.
- * 
+ *
  * @param path - Path array from canvas
  * @param isEditingComponent - Whether we're editing a component
  * @param componentInstancePath - Path of component instance on page (if editing component, Path array)
@@ -225,7 +219,7 @@ export function componentStructurePathToInstancePath(
 export function convertPathForComponentContext(
   path: Path,
   isEditingComponent: boolean,
-  componentInstancePath: Path | null
+  componentInstancePath: Path | null,
 ): Path {
   if (isEditingComponent && componentInstancePath) {
     // Check if path is inside componentInstancePath using array operations
@@ -233,12 +227,12 @@ export function convertPathForComponentContext(
       // Extract relative path: componentInstancePath: [0, 0] -> path: [0, 0, 1]
       // relative: [1] -> component structure path: [0, 1]
       const relativePath = path.slice(componentInstancePath.length);
-      
+
       // Build component structure path: [0] + relative path
       return [0, ...relativePath];
     }
   }
-  
+
   // Regular page editing - return path as-is
   return path;
 }