meno-core 1.0.53 → 1.1.0

package/lib/shared/errors.ts

@@ -31,7 +31,7 @@ export function createError(
   code: string,
   message: string,
   context?: Record<string, unknown>,
-  cause?: Error
+  cause?: Error,
 ): AppError {
   return { category, code, message, context, cause };
 }
@@ -40,11 +40,5 @@ export function createError(
  * Type guard for AppError
  */
 export function isAppError(error: unknown): error is AppError {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    'category' in error &&
-    'code' in error &&
-    'message' in error
-  );
+  return typeof error === 'object' && error !== null && 'category' in error && 'code' in error && 'message' in error;
 }

package/lib/shared/expressionEvaluator.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Expression Evaluator Tests
+ *
+ * The headline concern here is the SSOT (single-source-of-truth) invariant between
+ * `evaluateNode`'s switch and `SUPPORTED_NODE_TYPES`. `isSupportedTemplateExpression`
+ * (used by the .astro codec to decide modelable {{binding}} vs verbatim _code) trusts
+ * `SUPPORTED_NODE_TYPES` to mirror exactly the node types `evaluateNode` can actually
+ * evaluate. If they drift, the failure is silent — either evaluatable code gets emitted
+ * as verbatim _code, or un-evaluatable code gets coerced into a fake {{binding}} that
+ * shows up literally in SSR output. These tests force a contributor who touches one side
+ * to touch the other.
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { safeEvaluate, isSupportedTemplateExpression, SUPPORTED_NODE_TYPES } from './expressionEvaluator';
+
+/**
+ * The complete set of jsep node types `evaluateNode` has a `case` for AND returns a
+ * value from (i.e. does NOT throw). This list is intentionally hardcoded: adding a new
+ * `case` to evaluateNode without adding it here (or vice-versa) must fail the exact-set
+ * assertion below, forcing the SSOT to be kept in lockstep.
+ *
+ * Note: `LogicalExpression` is handled defensively in the same switch case as
+ * `BinaryExpression`, but jsep classifies `&&`/`||` as `BinaryExpression` by default, so
+ * it is never produced from a parsed string — hence it has no representative expression.
+ */
+const EXPECTED_SUPPORTED_NODE_TYPES = [
+  'Identifier',
+  'Literal',
+  'MemberExpression',
+  'BinaryExpression',
+  'LogicalExpression',
+  'ConditionalExpression',
+  'UnaryExpression',
+  'ArrayExpression',
+].sort();
+
+/**
+ * A representative, parseable expression for every supported node type jsep can actually
+ * emit, paired with the value `evaluateNode` should return for it given `CONTEXT`. Each
+ * entry double-proves the SSOT: the expression both (a) is reported supported by
+ * `isSupportedTemplateExpression`, and (b) is actually evaluated (not thrown) by
+ * `safeEvaluate` — so a type listed in SUPPORTED_NODE_TYPES but missing from the switch
+ * would surface as a wrong/undefined evaluation result here.
+ */
+const CONTEXT = { a: 2, b: 3, flag: true, name: 'Meno', obj: { x: 7 }, key: 'x' };
+const REPRESENTATIVE: Array<{ nodeType: string; expr: string; expected: unknown }> = [
+  { nodeType: 'Identifier', expr: 'name', expected: 'Meno' },
+  { nodeType: 'Literal', expr: '42', expected: 42 },
+  { nodeType: 'MemberExpression', expr: 'obj.x', expected: 7 },
+  { nodeType: 'MemberExpression(computed)', expr: 'obj[key]', expected: 7 },
+  { nodeType: 'BinaryExpression', expr: 'a + b', expected: 5 },
+  { nodeType: 'BinaryExpression(&&)', expr: 'flag && name', expected: 'Meno' },
+  { nodeType: 'BinaryExpression(||)', expr: 'a || b', expected: 2 },
+  { nodeType: 'ConditionalExpression', expr: 'flag ? a : b', expected: 2 },
+  { nodeType: 'UnaryExpression', expr: '!flag', expected: false },
+  { nodeType: 'ArrayExpression', expr: '[a, b]', expected: [2, 3] },
+];
+
+/** Node types the evaluator deliberately refuses (its switch throws for these). */
+const UNSUPPORTED_EXPRESSIONS: Array<{ nodeType: string; expr: string }> = [
+  { nodeType: 'CallExpression', expr: 'obj.x.toFixed(2)' },
+  { nodeType: 'Compound', expr: 'a, b' },
+];
+
+describe('expressionEvaluator SSOT invariant', () => {
+  test('SUPPORTED_NODE_TYPES exactly equals the expected hardcoded set', () => {
+    // If this fails, evaluateNode's switch and SUPPORTED_NODE_TYPES have drifted —
+    // update the switch, SUPPORTED_NODE_TYPES, AND this test's expected list together.
+    expect([...SUPPORTED_NODE_TYPES].sort()).toEqual(EXPECTED_SUPPORTED_NODE_TYPES);
+  });
+
+  test('every representative supported expression is reported supported AND evaluated', () => {
+    for (const { nodeType: _nodeType, expr, expected } of REPRESENTATIVE) {
+      // (a) the codec predicate must accept it
+      expect(isSupportedTemplateExpression(expr)).toBe(true);
+      // (b) the evaluator must actually handle it (not throw -> undefined fallback)
+      expect(safeEvaluate(expr, CONTEXT)).toEqual(expected as never);
+    }
+  });
+
+  test('every representative node type (jsep-producible) is present in SUPPORTED_NODE_TYPES', () => {
+    // Maps the labelled representatives back to their base jsep node type and asserts
+    // membership — closes the "added a case to the switch but forgot the set" gap for
+    // any type that has been given a representative expression.
+    const producibleBaseTypes = new Set(REPRESENTATIVE.map((r) => r.nodeType.replace(/\(.*\)$/, '')));
+    for (const baseType of producibleBaseTypes) {
+      expect(SUPPORTED_NODE_TYPES.has(baseType)).toBe(true);
+    }
+  });
+});
+
+describe('isSupportedTemplateExpression', () => {
+  test('returns false for function/method calls (verbatim _code territory)', () => {
+    for (const { expr } of UNSUPPORTED_EXPRESSIONS) {
+      expect(isSupportedTemplateExpression(expr)).toBe(false);
+    }
+  });
+
+  test('returns false for empty / whitespace / syntactically invalid expressions', () => {
+    expect(isSupportedTemplateExpression('')).toBe(false);
+    expect(isSupportedTemplateExpression('   ')).toBe(false);
+    expect(isSupportedTemplateExpression('a +')).toBe(false);
+  });
+
+  test('rejects an expression nesting an unsupported call deep inside a supported tree', () => {
+    // The recursive walk must catch unsupported nodes that are not at the root.
+    expect(isSupportedTemplateExpression('a + obj.x.toFixed(2)')).toBe(false);
+    expect(isSupportedTemplateExpression('flag ? name : obj.x.toString()')).toBe(false);
+  });
+});
+
+describe('safeEvaluate', () => {
+  test('returns undefined (no throw) for unsupported expressions', () => {
+    for (const { expr } of UNSUPPORTED_EXPRESSIONS) {
+      expect(safeEvaluate(expr, CONTEXT)).toBeUndefined();
+    }
+  });
+});
+
+describe('optional chaining (?.) and nullish coalescing (??)', () => {
+  const CTX = { user: { email: 'a@b.com' }, missing: undefined as unknown, zero: 0, empty: '' };
+
+  test('?. short-circuits to undefined when the object is null/undefined (not a throw)', () => {
+    expect(safeEvaluate('user?.email', CTX)).toBe('a@b.com');
+    expect(safeEvaluate('missing?.email', CTX)).toBeUndefined();
+    expect(safeEvaluate('missing?.email?.length', CTX)).toBeUndefined();
+  });
+
+  test('?? falls through only on null/undefined, not other falsy values', () => {
+    expect(safeEvaluate("missing ?? 'fallback'", CTX)).toBe('fallback');
+    expect(safeEvaluate("zero ?? 'fallback'", CTX)).toBe(0); // 0 is NOT nullish
+    expect(safeEvaluate("empty ?? 'fallback'", CTX)).toBe(''); // '' is NOT nullish
+  });
+
+  test("the real-world promoted shape `user?.name ?? ''` evaluates correctly (no longer a pretend binding)", () => {
+    expect(safeEvaluate("user?.email ?? 'none'", CTX)).toBe('a@b.com');
+    expect(safeEvaluate("missing?.email ?? 'none'", CTX)).toBe('none');
+  });
+
+  test('both are reported supported (and now actually evaluable, closing the soundness gap)', () => {
+    expect(isSupportedTemplateExpression('user?.email')).toBe(true);
+    expect(isSupportedTemplateExpression("missing?.email ?? ''")).toBe(true);
+  });
+});

package/lib/shared/expressionEvaluator.ts

@@ -6,8 +6,8 @@
  * Supports: ternary, binary, logical, unary operators, member access, arrays
  */
 
-import jsep from 'jsep';
 import type { Expression } from 'jsep';
+import jsep from 'jsep';
 
 /**
  * Safely evaluates a jsep AST node against a context object
@@ -61,6 +61,15 @@ function evaluateNode(node: Expression, context: Record<string, unknown>): unkno
         const left = evaluateNode(binaryNode.left, context);
         return left ? left : evaluateNode(binaryNode.right, context);
       }
+      // Nullish coalescing: only fall through on null/undefined (NOT other falsy values).
+      // jsep parses `??` as a BinaryExpression (already a supported node type); without this
+      // case the operator switch below would throw and `a ?? b` would silently evaluate to
+      // undefined. Combined with the MemberExpression null-guard above, `a?.b ?? c` evaluates
+      // correctly — so these are real editable bindings, not pretend ones.
+      if (binaryNode.operator === '??') {
+        const left = evaluateNode(binaryNode.left, context);
+        return left === null || left === undefined ? evaluateNode(binaryNode.right, context) : left;
+      }
 
       // Evaluate both sides for non-logical operators
       const left = evaluateNode(binaryNode.left, context);
@@ -73,18 +82,32 @@ function evaluateNode(node: Expression, context: Record<string, unknown>): unkno
             return String(left ?? '') + String(right ?? '');
           }
           return (left as number) + (right as number);
-        case '-': return (left as number) - (right as number);
-        case '*': return (left as number) * (right as number);
-        case '/': return (left as number) / (right as number);
-        case '%': return (left as number) % (right as number);
-        case '===': return left === right;
-        case '!==': return left !== right;
-        case '==': return left == right;
-        case '!=': return left != right;
-        case '<': return (left as number) < (right as number);
-        case '>': return (left as number) > (right as number);
-        case '<=': return (left as number) <= (right as number);
-        case '>=': return (left as number) >= (right as number);
+        case '-':
+          return (left as number) - (right as number);
+        case '*':
+          return (left as number) * (right as number);
+        case '/':
+          return (left as number) / (right as number);
+        case '%':
+          return (left as number) % (right as number);
+        case '===':
+          return left === right;
+        case '!==':
+          return left !== right;
+        case '==':
+          // biome-ignore lint/suspicious/noDoubleEquals: loose equality IS the semantics of the `==` operator in template expressions
+          return left == right;
+        case '!=':
+          // biome-ignore lint/suspicious/noDoubleEquals: loose inequality IS the semantics of the `!=` operator in template expressions
+          return left != right;
+        case '<':
+          return (left as number) < (right as number);
+        case '>':
+          return (left as number) > (right as number);
+        case '<=':
+          return (left as number) <= (right as number);
+        case '>=':
+          return (left as number) >= (right as number);
         default:
           throw new Error(`Unsupported operator: ${binaryNode.operator}`);
       }
@@ -94,9 +117,7 @@ function evaluateNode(node: Expression, context: Record<string, unknown>): unkno
       // Ternary: condition ? consequent : alternate
       const condNode = node as jsep.ConditionalExpression;
       const test = evaluateNode(condNode.test, context);
-      return test
-        ? evaluateNode(condNode.consequent, context)
-        : evaluateNode(condNode.alternate, context);
+      return test ? evaluateNode(condNode.consequent, context) : evaluateNode(condNode.alternate, context);
     }
 
     case 'UnaryExpression': {
@@ -105,9 +126,12 @@ function evaluateNode(node: Expression, context: Record<string, unknown>): unkno
       const arg = evaluateNode(unaryNode.argument, context);
 
       switch (unaryNode.operator) {
-        case '!': return !arg;
-        case '-': return -(arg as number);
-        case '+': return +(arg as number);
+        case '!':
+          return !arg;
+        case '-':
+          return -(arg as number);
+        case '+':
+          return +(arg as number);
         default:
           throw new Error(`Unsupported unary operator: ${unaryNode.operator}`);
       }
@@ -116,9 +140,7 @@ function evaluateNode(node: Expression, context: Record<string, unknown>): unkno
     case 'ArrayExpression': {
       // Array literals: [1, 2, 3]
       const arrayNode = node as jsep.ArrayExpression;
-      return arrayNode.elements.map(el =>
-        el ? evaluateNode(el, context) : undefined
-      );
+      return arrayNode.elements.map((el) => (el ? evaluateNode(el, context) : undefined));
     }
 
     case 'CallExpression': {
@@ -160,8 +182,14 @@ export function isComplexExpression(expression: string): boolean {
   return /[?:+\-*/%<>=!&|]/.test(expression);
 }
 
-/** jsep node types `evaluateNode` (above) can evaluate — the rest throw at runtime. */
-const SUPPORTED_NODE_TYPES = new Set([
+/**
+ * jsep node types `evaluateNode` (above) can evaluate — the rest throw at runtime.
+ *
+ * SSOT: this set MUST stay in lockstep with the `case` labels in `evaluateNode`'s
+ * switch. Drift is silent (lost code or literal `{{…}}` in SSR output), so the
+ * invariant is pinned by expressionEvaluator.test.ts — update both together.
+ */
+export const SUPPORTED_NODE_TYPES = new Set([
   'Identifier',
   'Literal',
   'MemberExpression',

package/lib/shared/fontLoader.test.ts

@@ -1,7 +1,7 @@
-import { describe, test, expect, afterAll } from 'bun:test';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync } from 'fs';
-import { tmpdir } from 'os';
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { join } from 'node:path';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { setProjectRoot, getProjectRoot } from '../server/projectContext';
 
 // Save original project root to restore after tests
@@ -13,10 +13,23 @@ const testDir = join(tmpdir(), `fontLoader-test-${Date.now()}`);
 mkdirSync(testDir, { recursive: true });
 setProjectRoot(testDir);
 
+// fontLoader keeps a module-level config cache that survives across test
+// files in a single `bun test` process. Earlier files (e.g. anything pulling
+// in the SSR htmlGenerator) may already have populated it with `{ fonts: [] }`,
+// which would make loadProjectConfig() return that stale cache instead of
+// reading our test config. Reset on both ends so this file neither inherits
+// nor leaks cached config.
+beforeAll(() => {
+  resetFontConfig();
+});
+
 // Restore original project root after all tests in this file
 afterAll(() => {
   setProjectRoot(originalProjectRoot);
-  try { rmSync(testDir, { recursive: true, force: true }); } catch {}
+  resetFontConfig();
+  try {
+    rmSync(testDir, { recursive: true, force: true });
+  } catch {}
 });
 
 // Helper to write a project.config.json in the test directory
@@ -24,7 +37,7 @@ function writeConfig(config: Record<string, unknown>): void {
   writeFileSync(join(testDir, 'project.config.json'), JSON.stringify(config));
 }
 
-function removeConfig(): void {
+function _removeConfig(): void {
   try {
     rmSync(join(testDir, 'project.config.json'));
   } catch {
@@ -99,6 +112,7 @@ import {
   generateFontCSS,
   generateFontPreloadTags,
   getFontFamilies,
+  resetFontConfig,
 } from './fontLoader';
 
 describe('fontLoader', () => {
@@ -215,7 +229,7 @@ describe('fontLoader', () => {
   test('generateFontCSS omits font-display when not specified', () => {
     const css = generateFontCSS();
     // The Roboto bold entry has no fontDisplay
-    const robotoBlock = css.split('\n\n').find(b => b.includes('roboto-bold.ttf'))!;
+    const robotoBlock = css.split('\n\n').find((b) => b.includes('roboto-bold.ttf'))!;
     expect(robotoBlock).toBeDefined();
     expect(robotoBlock).not.toContain('font-display');
   });
@@ -277,7 +291,7 @@ describe('fontLoader', () => {
 
   test('generateFontPreloadTags defaults to font/ttf for unknown extension', () => {
     const tags = generateFontPreloadTags();
-    const mysteryTag = tags.split('\n  ').find(t => t.includes('mystery.xyz'))!;
+    const mysteryTag = tags.split('\n  ').find((t) => t.includes('mystery.xyz'))!;
     expect(mysteryTag).toContain('type="font/ttf"');
   });
 
@@ -297,7 +311,7 @@ describe('fontLoader', () => {
   test('generateFontPreloadTags produces correct link tag format', () => {
     const tags = generateFontPreloadTags();
     expect(tags).toContain(
-      '<link rel="preload" href="/fonts/inter-variable.woff2" as="font" type="font/woff2" crossorigin>'
+      '<link rel="preload" href="/fonts/inter-variable.woff2" as="font" type="font/woff2" crossorigin>',
     );
   });
 
@@ -305,7 +319,7 @@ describe('fontLoader', () => {
 
   test('getFontFamilies expands variable weight range in 100 increments', () => {
     const families = getFontFamilies();
-    expect(families['Inter']).toEqual([100, 200, 300, 400, 500, 600, 700, 800, 900]);
+    expect(families.Inter).toEqual([100, 200, 300, 400, 500, 600, 700, 800, 900]);
   });
 
   test('getFontFamilies extracts family name from path', () => {
@@ -316,24 +330,24 @@ describe('fontLoader', () => {
   test('getFontFamilies groups weights and deduplicates across static and variable', () => {
     const families = getFontFamilies();
     // Roboto: 700 (bold static), 400 (regular static), 300-500 variable (400 deduped)
-    expect(families['Roboto']).toContain(700);
-    expect(families['Roboto']).toContain(400);
-    expect(families['Roboto']).toContain(300);
-    expect(families['Roboto']).toContain(500);
+    expect(families.Roboto).toContain(700);
+    expect(families.Roboto).toContain(400);
+    expect(families.Roboto).toContain(300);
+    expect(families.Roboto).toContain(500);
     // No duplicates
-    const unique = [...new Set(families['Roboto'])];
-    expect(families['Roboto'].length).toBe(unique.length);
+    const unique = [...new Set(families.Roboto)];
+    expect(families.Roboto!.length).toBe(unique.length);
   });
 
   test('getFontFamilies uses default weight 400 when not specified', () => {
     const families = getFontFamilies();
-    expect(families['Playfair']).toEqual([400]);
+    expect(families.Playfair).toEqual([400]);
   });
 
   test('getFontFamilies handles single-weight variable font', () => {
     const families = getFontFamilies();
     // Mono: weight=400, weightMax=400 -> [400]
-    expect(families['Mono']).toEqual([400]);
+    expect(families.Mono).toEqual([400]);
   });
 
   test('getFontFamilies handles extracted name for unknown extension', () => {

package/lib/shared/fontLoader.ts

@@ -54,8 +54,8 @@ export function getFontFamilies(): Record<string, number[]> {
   const fonts = config.fonts || [];
   const familiesMap: Record<string, number[]> = {};
 
-  fonts.forEach((font: any) => {
-    const fontPath: string = font.path || font.src;
+  fonts.forEach((font: { path?: string; src?: string; family?: string; weight?: number; weightMax?: number }) => {
+    const fontPath: string = font.path || font.src || '';
     if (!fontPath) return;
     const family = font.family || extractFamilyName(fontPath);
     const weight = font.weight ?? 400;

package/lib/shared/friendlyError.ts

@@ -83,7 +83,7 @@ const RULES: Rule[] = [
     test: /Cannot find module|Failed to resolve module|Failed to load module|Error loading dynamically imported module/i,
     build: () => ({
       title: "A required file couldn't be loaded",
-      friendlyMessage: 'An import or module reference couldn\'t be found.',
+      friendlyMessage: "An import or module reference couldn't be found.",
       hint: 'Check the import path.',
     }),
   },
@@ -114,8 +114,7 @@ export function toFriendlyError(input: unknown): FriendlyError {
 
   return {
     title: 'This section ran into a problem',
-    friendlyMessage:
-      'Something went wrong while rendering this part of the page. The rest of the page is fine.',
+    friendlyMessage: 'Something went wrong while rendering this part of the page. The rest of the page is fine.',
     raw,
   };
 }

package/lib/shared/gradientUtils.test.ts

@@ -1,9 +1,5 @@
 import { describe, test, expect } from 'bun:test';
-import {
-  isGradientValue,
-  parseGradient,
-  buildGradientCss,
-} from './gradientUtils';
+import { isGradientValue, parseGradient, buildGradientCss } from './gradientUtils';
 
 describe('isGradientValue', () => {
   test('identifies gradient values', () => {
@@ -51,8 +47,8 @@ describe('parseGradient', () => {
     const result = parseGradient('linear-gradient(180deg, red, blue)');
     expect(result).not.toBeNull();
     expect(result!.stops.length).toBe(2);
-    expect(result!.stops[0].position).toBe(0);
-    expect(result!.stops[1].position).toBe(100);
+    expect(result!.stops[0]!.position).toBe(0);
+    expect(result!.stops[1]!.position).toBe(100);
   });
 
   test('parses radial gradient with circle', () => {

package/lib/shared/gradientUtils.ts

@@ -22,9 +22,7 @@ const CONIC_RE = /^conic-gradient\((.+)\)$/i;
 export function isGradientValue(value: string): boolean {
   if (!value) return false;
   const v = value.trim().toLowerCase();
-  return v.startsWith('linear-gradient(') ||
-    v.startsWith('radial-gradient(') ||
-    v.startsWith('conic-gradient(');
+  return v.startsWith('linear-gradient(') || v.startsWith('radial-gradient(') || v.startsWith('conic-gradient(');
 }
 
 /** Parse a CSS gradient string into a GradientConfig */
@@ -35,17 +33,24 @@ export function parseGradient(cssValue: string): GradientConfig | null {
   let match: RegExpMatchArray | null;
   let type: GradientConfig['type'];
 
-  if ((match = v.match(LINEAR_RE))) {
+  const linearMatch = v.match(LINEAR_RE);
+  const radialMatch = linearMatch ? null : v.match(RADIAL_RE);
+  const conicMatch = linearMatch || radialMatch ? null : v.match(CONIC_RE);
+
+  if (linearMatch) {
+    match = linearMatch;
     type = 'linear';
-  } else if ((match = v.match(RADIAL_RE))) {
+  } else if (radialMatch) {
+    match = radialMatch;
     type = 'radial';
-  } else if ((match = v.match(CONIC_RE))) {
+  } else if (conicMatch) {
+    match = conicMatch;
     type = 'conic';
   } else {
     return null;
   }
 
-  const inner = match[1];
+  const inner = match[1] ?? '';
   const parts = splitGradientArgs(inner);
 
   let angle = type === 'linear' ? 180 : 0;
@@ -80,7 +85,7 @@ export function parseGradient(cssValue: string): GradientConfig | null {
     if (first) {
       const fromAngle = first.match(/^from\s+(\d+(?:\.\d+)?)deg/i);
       if (fromAngle) {
-        angle = parseFloat(fromAngle[1]);
+        angle = parseFloat(fromAngle[1] ?? '');
         stopsStartIndex = 1;
       }
     }
@@ -94,9 +99,7 @@ export function parseGradient(cssValue: string): GradientConfig | null {
 
 /** Build a CSS gradient string from a GradientConfig */
 export function buildGradientCss(config: GradientConfig): string {
-  const stopStrings = config.stops.map(
-    s => `${s.color} ${Math.round(s.position)}%`
-  );
+  const stopStrings = config.stops.map((s) => `${s.color} ${Math.round(s.position)}%`);
 
   switch (config.type) {
     case 'linear': {
@@ -137,7 +140,7 @@ function splitGradientArgs(inner: string): string[] {
 
 function parseAngle(part: string): number | null {
   const m = part.match(/^(-?\d+(?:\.\d+)?)deg$/i);
-  return m ? parseFloat(m[1]) : null;
+  return m ? parseFloat(m[1] ?? '') : null;
 }
 
 function directionToAngle(direction: string): number {
@@ -160,7 +163,7 @@ function parseStops(parts: string[]): GradientStop[] {
   const total = parts.length;
 
   for (let i = 0; i < total; i++) {
-    const part = parts[i].trim();
+    const part = parts[i]?.trim();
     if (!part) continue;
 
     // Match color and optional position percentage
@@ -170,7 +173,7 @@ function parseStops(parts: string[]): GradientStop[] {
 
     if (posMatch) {
       color = part.slice(0, posMatch.index!).trim();
-      position = parseFloat(posMatch[1]);
+      position = parseFloat(posMatch[1] ?? '');
     } else {
       color = part;
       // Auto-distribute position

package/lib/shared/hrefRefs.test.ts

@@ -56,8 +56,8 @@ describe('rewriteHrefRefs', () => {
       ],
     };
     expect(rewriteHrefRefs(tree, '/about', '/about-us')).toBe(true);
-    expect(tree.children[0].href).toBe('/about-us');
-    expect((tree.children[1].children![0] as any).href).toBe('/about-us/team');
+    expect(tree.children[0]!.href).toBe('/about-us');
+    expect((tree.children[1]!.children![0] as any).href).toBe('/about-us/team');
   });
 
   test('walks prop trees (component nodes with object props)', () => {

package/lib/shared/hrefRefs.ts

@@ -16,11 +16,7 @@
 
 function rewriteHref(value: string, oldHref: string, newHref: string): string | null {
   if (value === oldHref) return newHref;
-  if (
-    value.startsWith(oldHref + '/') ||
-    value.startsWith(oldHref + '?') ||
-    value.startsWith(oldHref + '#')
-  ) {
+  if (value.startsWith(`${oldHref}/`) || value.startsWith(`${oldHref}?`) || value.startsWith(`${oldHref}#`)) {
     return newHref + value.substring(oldHref.length);
   }
   return null;
@@ -34,11 +30,7 @@ function rewriteHref(value: string, oldHref: string, newHref: string): string |
  * Walks `children` recursively (array or single object) and any object-valued
  * field on the node (covers component-prop-trees, nested structure, etc.).
  */
-export function rewriteHrefRefs(
-  node: unknown,
-  oldHref: string,
-  newHref: string,
-): boolean {
+export function rewriteHrefRefs(node: unknown, oldHref: string, newHref: string): boolean {
   if (!node || typeof node !== 'object') return false;
   if (!oldHref || oldHref === newHref) return false;
 

package/lib/shared/i18n.test.ts

@@ -32,7 +32,7 @@ describe('i18n', () => {
 
     test('should have English locale configured', () => {
       expect(DEFAULT_I18N_CONFIG.locales).toHaveLength(1);
-      expect(DEFAULT_I18N_CONFIG.locales[0].code).toBe('en');
+      expect(DEFAULT_I18N_CONFIG.locales[0]!.code).toBe('en');
     });
   });
 
@@ -83,8 +83,8 @@ describe('i18n', () => {
       const migrated = migrateI18nConfig(oldConfig);
       expect(migrated.defaultLocale).toBe('en');
       expect(migrated.locales).toHaveLength(3);
-      expect(migrated.locales[0].code).toBe('en');
-      expect(migrated.locales[1].code).toBe('pl');
+      expect(migrated.locales[0]!.code).toBe('en');
+      expect(migrated.locales[1]!.code).toBe('pl');
     });
 
     test('should preserve new format config', () => {
@@ -199,7 +199,7 @@ describe('i18n', () => {
     test('should return empty array if no translation available for list i18n', () => {
       const listValue = {
         _i18n: true,
-        en: [],  // Add empty array to make it a list i18n
+        en: [], // Add empty array to make it a list i18n
       } as I18nValue;
       // Remove the empty array to test empty fallback detection
       delete (listValue as any).en;