meno-core 1.0.53 → 1.1.0

package/lib/shared/itemTemplateUtils.test.ts

@@ -356,17 +356,11 @@ describe('itemTemplateUtils', () => {
 
     it('should process nested arrays', () => {
       const props = {
-        outer: [
-          ['{{item.title}}', 'static'],
-          ['{{item.url}}'],
-        ]
+        outer: [['{{item.title}}', 'static'], ['{{item.url}}']],
       };
       const result = processItemPropsTemplate(props, baseContext);
       expect(result).toEqual({
-        outer: [
-          ['Test Title', 'static'],
-          ['/test-url'],
-        ]
+        outer: [['Test Title', 'static'], ['/test-url']],
       });
     });
 
@@ -375,24 +369,24 @@ describe('itemTemplateUtils', () => {
         items: [
           { label: '{{item.title}}', href: '{{item.url}}' },
           { label: 'Static', href: '/static' },
-        ]
+        ],
       };
       const result = processItemPropsTemplate(props, baseContext);
       expect(result).toEqual({
         items: [
           { label: 'Test Title', href: '/test-url' },
           { label: 'Static', href: '/static' },
-        ]
+        ],
       });
     });
 
     it('should handle mixed array content', () => {
       const props = {
-        tags: ['{{item.title}}', 42, true, null, { nested: '{{item.url}}' }]
+        tags: ['{{item.title}}', 42, true, null, { nested: '{{item.url}}' }],
       };
       const result = processItemPropsTemplate(props, baseContext);
       expect(result).toEqual({
-        tags: ['Test Title', 42, true, null, { nested: '/test-url' }]
+        tags: ['Test Title', 42, true, null, { nested: '/test-url' }],
       });
     });
 
@@ -770,16 +764,16 @@ describe('itemTemplateUtils', () => {
       ];
       const results = addItemUrls(items, schema);
       expect(results).toHaveLength(3);
-      expect(results[0]._url).toBe('/blog/first-post');
-      expect(results[1]._url).toBe('/blog/second-post');
-      expect(results[2]._url).toBe('/blog/third-post');
+      expect(results[0]!._url).toBe('/blog/first-post');
+      expect(results[1]!._url).toBe('/blog/second-post');
+      expect(results[2]!._url).toBe('/blog/third-post');
     });
 
     it('should not mutate original items', () => {
       const items: CMSItem[] = [{ _id: '1', slug: 'test' }];
       const results = addItemUrls(items, schema);
-      expect(items[0]._url).toBeUndefined();
-      expect(results[0]._url).toBe('/blog/test');
+      expect(items[0]!._url).toBeUndefined();
+      expect(results[0]!._url).toBe('/blog/test');
     });
 
     it('should handle empty array', () => {

package/lib/shared/itemTemplateUtils.ts

@@ -21,7 +21,6 @@
 
 import type { ItemContext, TemplateContext, CMSItem, CMSSchema } from './types/cms';
 import type { ValueResolver, I18nConfig } from './types/components';
-import { isRichTextMarker, richTextMarkerToHtml } from './propResolver';
 import { safeEvaluate, isComplexExpression } from './expressionEvaluator';
 import { getGlobalTemplateContext } from './globalTemplateContext';
 import { isI18nValue, resolveI18nValue, DEFAULT_I18N_CONFIG } from './i18n';
@@ -85,7 +84,11 @@ function formatTemplateValue(value: unknown, resolveValue?: ValueResolver): stri
     return '';
   }
   // Handle rich-text markers
-  if (typeof value === 'object' && '__richtext__' in value && typeof (value as unknown as { html: string }).html === 'string') {
+  if (
+    typeof value === 'object' &&
+    '__richtext__' in value &&
+    typeof (value as unknown as { html: string }).html === 'string'
+  ) {
     return (value as unknown as { html: string }).html;
   }
   return String(value);
@@ -120,10 +123,10 @@ function buildEvalContext(ctx: ItemContext | TemplateContext): Record<string, un
 export function processItemTemplate(
   text: string,
   ctx: ItemContext | TemplateContext,
-  resolveValue?: ValueResolver
+  resolveValue?: ValueResolver,
 ): string {
   // Process all {{...}} patterns
-  let result = text.replace(/\{\{([^}]+)\}\}/g, (match, expression) => {
+  const result = text.replace(/\{\{([^}]+)\}\}/g, (match, expression) => {
     const trimmed = expression.trim();
 
     // Check if this is a complex expression (has operators like ?, :, <, >, etc.)
@@ -172,11 +175,7 @@ export function processItemTemplate(
  * Process named context templates like {{post.title}}, {{postIndex}}, etc.
  * Supports multiple named contexts for nested lists (e.g., post + author).
  */
-function processNamedTemplates(
-  text: string,
-  ctx: TemplateContext,
-  resolveValue?: ValueResolver
-): string {
+function _processNamedTemplates(text: string, ctx: TemplateContext, resolveValue?: ValueResolver): string {
   let result = text;
 
   // Process {{varName.field}} patterns
@@ -211,13 +210,14 @@ function processNamedTemplates(
 function resolveCompleteTemplateRaw(
   template: string,
   ctx: ItemContext | TemplateContext,
-  resolveValue?: ValueResolver
+  resolveValue?: ValueResolver,
 ): unknown {
   // Only handle single complete template expressions like {{varName.field}}
   const match = template.match(/^\{\{(\w+)\.([^}]+)\}\}$/);
   if (!match) return undefined;
 
-  const [, varName, fieldPath] = match;
+  const varName = match[1] ?? '';
+  const fieldPath = match[2] ?? '';
 
   // Check for complex expressions (ternary, comparisons, etc.) - not raw-resolvable
   const trimmedField = fieldPath.trim();
@@ -250,7 +250,7 @@ function resolveCompleteTemplateRaw(
 export function processItemPropsTemplate(
   props: Record<string, unknown>,
   ctx: ItemContext | TemplateContext,
-  resolveValue?: ValueResolver
+  resolveValue?: ValueResolver,
 ): Record<string, unknown> {
   const result: Record<string, unknown> = {};
 
@@ -267,7 +267,7 @@ export function processItemPropsTemplate(
       }
     } else if (Array.isArray(value)) {
       // Process arrays - recursively handle each element
-      result[key] = value.map(item => {
+      result[key] = value.map((item) => {
         if (typeof item === 'string' && hasItemTemplates(item)) {
           return processItemTemplate(item, ctx, resolveValue);
         } else if (item && typeof item === 'object' && !Array.isArray(item)) {
@@ -300,10 +300,7 @@ export function processItemPropsTemplate(
  * resolveItemsTemplate("{{post.tagIds}}", { post: { tagIds: ["tag-1", "tag-2"] } })
  * // Returns: ["tag-1", "tag-2"]
  */
-export function resolveItemsTemplate(
-  template: string,
-  ctx: TemplateContext
-): string | string[] | undefined {
+export function resolveItemsTemplate(template: string, ctx: TemplateContext): string | string[] | undefined {
   // Match single template expression: {{varName.field}}
   const match = template.match(/^\{\{(\w+)\.([^}]+)\}\}$/);
   if (!match) {
@@ -311,7 +308,8 @@ export function resolveItemsTemplate(
     return template;
   }
 
-  const [, varName, fieldPath] = match;
+  const varName = match[1] ?? '';
+  const fieldPath = match[2] ?? '';
   const item = ctx[varName];
   if (!item || typeof item !== 'object') {
     return undefined;
@@ -324,7 +322,7 @@ export function resolveItemsTemplate(
 
   // Return as string or string array
   if (Array.isArray(value)) {
-    return value.map(v => String(v));
+    return value.map((v) => String(v));
   }
   return String(value);
 }
@@ -338,15 +336,13 @@ export function resolveItemsTemplate(
  * resolveTemplateRawValue("{{article.link}}", { article: { link: { href: "/about", target: "_blank" } } })
  * // Returns: { href: "/about", target: "_blank" }
  */
-export function resolveTemplateRawValue(
-  template: string,
-  ctx: TemplateContext
-): unknown {
+export function resolveTemplateRawValue(template: string, ctx: TemplateContext): unknown {
   // Match single template expression: {{varName.field}}
   const match = template.match(/^\{\{(\w+)\.([^}]+)\}\}$/);
   if (!match) return undefined;
 
-  const [, varName, fieldPath] = match;
+  const varName = match[1] ?? '';
+  const fieldPath = match[2] ?? '';
   const item = ctx[varName];
   if (!item || typeof item !== 'object') return undefined;
 
@@ -368,7 +364,7 @@ export function buildTemplateContext(
   item: CMSItem,
   index: number,
   total: number,
-  parentContext?: TemplateContext
+  parentContext?: TemplateContext,
 ): TemplateContext {
   const isFirst = index === 0;
   const isLast = index === total - 1;
@@ -422,7 +418,7 @@ export function buildItemUrl(
   item: CMSItem,
   slugField: string,
   locale?: string,
-  i18nConfig?: I18nConfig
+  i18nConfig?: I18nConfig,
 ): string {
   // Get slug from the schema-defined slugField, fall back to _filename, _slug, or _id
   let slug = item[slugField] ?? item._filename ?? item._slug ?? item._id;
@@ -447,12 +443,9 @@ export function buildItemUrl(
  * @param i18nConfig - Optional i18n configuration
  * @returns A new item object with _url computed field added
  */
-export function addItemUrl(
-  item: CMSItem,
-  schema: CMSSchema,
-  locale?: string,
-  i18nConfig?: I18nConfig
-): CMSItem {
+export function addItemUrl(item: CMSItem, schema: CMSSchema, locale?: string, i18nConfig?: I18nConfig): CMSItem {
+  // A data-only collection (no urlPattern/slugField) has no per-item URL — leave it off.
+  if (!schema.urlPattern || !schema.slugField) return item;
   return {
     ...item,
     _url: buildItemUrl(schema.urlPattern, item, schema.slugField, locale, i18nConfig),
@@ -468,11 +461,6 @@ export function addItemUrl(
  * @param i18nConfig - Optional i18n configuration
  * @returns Array of items with _url computed field added
  */
-export function addItemUrls(
-  items: CMSItem[],
-  schema: CMSSchema,
-  locale?: string,
-  i18nConfig?: I18nConfig
-): CMSItem[] {
-  return items.map(item => addItemUrl(item, schema, locale, i18nConfig));
+export function addItemUrls(items: CMSItem[], schema: CMSSchema, locale?: string, i18nConfig?: I18nConfig): CMSItem[] {
+  return items.map((item) => addItemUrl(item, schema, locale, i18nConfig));
 }

package/lib/shared/jsonRepair.ts

@@ -33,7 +33,7 @@ export function parseJsonError(error: unknown, content: string): JsonParseErrorI
   // Try to extract position from message
   const posMatch = msg.match(/at position (\d+)/i);
   if (posMatch) {
-    const pos = parseInt(posMatch[1], 10);
+    const pos = parseInt(posMatch[1] ?? '', 10);
     const { line, column } = offsetToLineColumn(content, pos);
     return { message: msg, line, column };
   }
@@ -45,8 +45,8 @@ export function parseJsonError(error: unknown, content: string): JsonParseErrorI
   if (lineMatch) {
     return {
       message: msg,
-      line: parseInt(lineMatch[1], 10),
-      column: colMatch ? parseInt(colMatch[1], 10) : 1,
+      line: parseInt(lineMatch[1] ?? '', 10),
+      column: colMatch ? parseInt(colMatch[1] ?? '', 10) : 1,
     };
   }
 
@@ -73,7 +73,7 @@ export function attemptJsonRepair(content: string): JsonRepairResult {
   try {
     const data = JSON.parse(content);
     return { success: true, repaired: false, data };
-  } catch (firstError) {
+  } catch (_firstError) {
     // Continue to repair attempts
   }
 
@@ -108,27 +108,33 @@ export function attemptJsonRepair(content: string): JsonRepairResult {
     let repairLine = 0;
 
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
+      const line = lines[i] ?? '';
       const trimmed = line.trimEnd();
-      const nextLine = i + 1 < lines.length ? lines[i + 1] : null;
+      const nextLine = i + 1 < lines.length ? (lines[i + 1] ?? null) : null;
 
       if (nextLine !== null) {
         const nextTrimmed = nextLine.trimStart();
         // Check if current line ends with a value (not comma, not opening bracket, not colon)
         // and next line starts with a key or value
         const needsComma =
-          /["\d\w\]}\-]$/.test(trimmed) &&
+          /["\d\w\]}-]$/.test(trimmed) &&
           !trimmed.endsWith(',') &&
           !trimmed.endsWith('{') &&
           !trimmed.endsWith('[') &&
           !trimmed.endsWith(':') &&
-          (nextTrimmed.startsWith('"') || nextTrimmed.startsWith('{') || nextTrimmed.startsWith('[') || /^\d/.test(nextTrimmed) || nextTrimmed === 'true' || nextTrimmed === 'false' || nextTrimmed === 'null');
+          (nextTrimmed.startsWith('"') ||
+            nextTrimmed.startsWith('{') ||
+            nextTrimmed.startsWith('[') ||
+            /^\d/.test(nextTrimmed) ||
+            nextTrimmed === 'true' ||
+            nextTrimmed === 'false' ||
+            nextTrimmed === 'null');
 
         if (needsComma) {
-          fixed += trimmed + ',\n';
+          fixed += `${trimmed},\n`;
           if (repairLine === 0) repairLine = i + 1;
         } else {
-          fixed += line + '\n';
+          fixed += `${line}\n`;
         }
       } else {
         fixed += line;

package/lib/shared/libraryLoader.test.ts

@@ -6,12 +6,7 @@ import {
   generateLibraryTags,
   extractLibraryOrigins,
 } from './libraryLoader';
-import type {
-  JSLibraryConfig,
-  CSSLibraryConfig,
-  LibrariesConfig,
-  PageLibrariesConfig,
-} from './types/libraries';
+import type { JSLibraryConfig, CSSLibraryConfig, LibrariesConfig, PageLibrariesConfig } from './types/libraries';
 
 describe('libraryLoader', () => {
   // ---------------------------------------------------------------------------
@@ -73,12 +68,8 @@ describe('libraryLoader', () => {
         css: [{ url: 'https://cdn.example.com/replacement.css' }],
       };
       const result = mergeLibraries(globalLibs, page);
-      expect(result.js).toEqual([
-        { url: 'https://cdn.example.com/replacement.js' },
-      ]);
-      expect(result.css).toEqual([
-        { url: 'https://cdn.example.com/replacement.css' },
-      ]);
+      expect(result.js).toEqual([{ url: 'https://cdn.example.com/replacement.js' }]);
+      expect(result.css).toEqual([{ url: 'https://cdn.example.com/replacement.css' }]);
     });
 
     test('replace mode: defaults to empty arrays when page.js and page.css are missing', () => {
@@ -129,12 +120,12 @@ describe('libraryLoader', () => {
         css: [{ url: 'https://cdn.example.com/b.css', media: 'screen' }],
       };
       const result = mergeLibraries(global, page);
-      expect(result.js![0].mode).toBe('async');
-      expect(result.js![0].position).toBe('head');
-      expect(result.js![1].mode).toBe('defer');
-      expect(result.js![1].position).toBe('body-end');
-      expect(result.css![0].media).toBe('print');
-      expect(result.css![1].media).toBe('screen');
+      expect(result.js![0]!.mode).toBe('async');
+      expect(result.js![0]!.position).toBe('head');
+      expect(result.js![1]!.mode).toBe('defer');
+      expect(result.js![1]!.position).toBe('body-end');
+      expect(result.css![0]!.media).toBe('print');
+      expect(result.css![1]!.media).toBe('screen');
     });
   });
 
@@ -218,9 +209,7 @@ describe('libraryLoader', () => {
     test('includes media attribute when provided', () => {
       const lib: CSSLibraryConfig = { url: 'https://cdn.example.com/print.css', media: 'print' };
       const tag = generateStylesheetTag(lib);
-      expect(tag).toBe(
-        '<link rel="stylesheet" href="https://cdn.example.com/print.css" media="print">'
-      );
+      expect(tag).toBe('<link rel="stylesheet" href="https://cdn.example.com/print.css" media="print">');
     });
 
     test('handles complex media query', () => {
@@ -278,9 +267,7 @@ describe('libraryLoader', () => {
         js: [],
       };
       const tags = generateLibraryTags(libs);
-      expect(tags.headCSS).toBe(
-        '<link rel="stylesheet" href="https://cdn.example.com/style.css">'
-      );
+      expect(tags.headCSS).toBe('<link rel="stylesheet" href="https://cdn.example.com/style.css">');
       expect(tags.headJS).toBe('');
       expect(tags.bodyEndJS).toBe('');
     });
@@ -291,9 +278,7 @@ describe('libraryLoader', () => {
         css: [],
       };
       const tags = generateLibraryTags(libs);
-      expect(tags.bodyEndJS).toBe(
-        '<script src="https://cdn.example.com/lib.js" defer></script>'
-      );
+      expect(tags.bodyEndJS).toBe('<script src="https://cdn.example.com/lib.js" defer></script>');
       expect(tags.headJS).toBe('');
       expect(tags.headCSS).toBe('');
     });
@@ -304,9 +289,7 @@ describe('libraryLoader', () => {
         css: [],
       };
       const tags = generateLibraryTags(libs);
-      expect(tags.headJS).toBe(
-        '<script src="https://cdn.example.com/head.js" defer></script>'
-      );
+      expect(tags.headJS).toBe('<script src="https://cdn.example.com/head.js" defer></script>');
       expect(tags.bodyEndJS).toBe('');
     });
 
@@ -316,9 +299,7 @@ describe('libraryLoader', () => {
         css: [],
       };
       const tags = generateLibraryTags(libs);
-      expect(tags.bodyEndJS).toBe(
-        '<script src="https://cdn.example.com/foot.js" defer></script>'
-      );
+      expect(tags.bodyEndJS).toBe('<script src="https://cdn.example.com/foot.js" defer></script>');
       expect(tags.headJS).toBe('');
     });
 
@@ -340,31 +321,25 @@ describe('libraryLoader', () => {
 
     test('multiple CSS libs joined with newline and indentation', () => {
       const libs: LibrariesConfig = {
-        css: [
-          { url: 'https://cdn.example.com/a.css' },
-          { url: 'https://cdn.example.com/b.css' },
-        ],
+        css: [{ url: 'https://cdn.example.com/a.css' }, { url: 'https://cdn.example.com/b.css' }],
         js: [],
       };
       const tags = generateLibraryTags(libs);
       expect(tags.headCSS).toBe(
         '<link rel="stylesheet" href="https://cdn.example.com/a.css">\n  ' +
-        '<link rel="stylesheet" href="https://cdn.example.com/b.css">'
+          '<link rel="stylesheet" href="https://cdn.example.com/b.css">',
       );
     });
 
     test('multiple JS libs joined with newline and indentation', () => {
       const libs: LibrariesConfig = {
-        js: [
-          { url: 'https://cdn.example.com/a.js' },
-          { url: 'https://cdn.example.com/b.js' },
-        ],
+        js: [{ url: 'https://cdn.example.com/a.js' }, { url: 'https://cdn.example.com/b.js' }],
         css: [],
       };
       const tags = generateLibraryTags(libs);
       expect(tags.bodyEndJS).toBe(
         '<script src="https://cdn.example.com/a.js" defer></script>\n  ' +
-        '<script src="https://cdn.example.com/b.js" defer></script>'
+          '<script src="https://cdn.example.com/b.js" defer></script>',
       );
     });
 
@@ -446,10 +421,7 @@ describe('libraryLoader', () => {
 
     test('deduplicates origins from same domain', () => {
       const libs: LibrariesConfig = {
-        js: [
-          { url: 'https://cdn.jsdelivr.net/npm/lib-a.js' },
-          { url: 'https://cdn.jsdelivr.net/npm/lib-b.js' },
-        ],
+        js: [{ url: 'https://cdn.jsdelivr.net/npm/lib-a.js' }, { url: 'https://cdn.jsdelivr.net/npm/lib-b.js' }],
         css: [],
       };
       const { scriptOrigins } = extractLibraryOrigins(libs);
@@ -482,14 +454,8 @@ describe('libraryLoader', () => {
 
     test('handles multiple different domains', () => {
       const libs: LibrariesConfig = {
-        js: [
-          { url: 'https://cdn.jsdelivr.net/npm/lib.js' },
-          { url: 'https://unpkg.com/other-lib.js' },
-        ],
-        css: [
-          { url: 'https://fonts.googleapis.com/css' },
-          { url: 'https://cdn.jsdelivr.net/npm/style.css' },
-        ],
+        js: [{ url: 'https://cdn.jsdelivr.net/npm/lib.js' }, { url: 'https://unpkg.com/other-lib.js' }],
+        css: [{ url: 'https://fonts.googleapis.com/css' }, { url: 'https://cdn.jsdelivr.net/npm/style.css' }],
       };
       const { scriptOrigins, styleOrigins } = extractLibraryOrigins(libs);
       expect(scriptOrigins.size).toBe(2);

package/lib/shared/libraryLoader.ts

@@ -3,23 +3,14 @@
  * Generates HTML tags for external JS/CSS libraries
  */
 
-import type {
-  JSLibraryConfig,
-  CSSLibraryConfig,
-  LibrariesConfig,
-  PageLibrariesConfig,
-} from './types/libraries';
+import type { JSLibraryConfig, CSSLibraryConfig, LibrariesConfig, PageLibrariesConfig } from './types/libraries';
 import type { ComponentDefinition } from './types/components';
 
 /**
  * Escape HTML special characters in attribute values
  */
 function escapeAttr(str: string): string {
-  return str
-    .replace(/&/g, '&')
-    .replace(/"/g, '"')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;');
+  return str.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
 
 /**
@@ -28,10 +19,7 @@ function escapeAttr(str: string): string {
  * @param page Page-level libraries from page meta
  * @returns Merged library configuration
  */
-export function mergeLibraries(
-  global: LibrariesConfig,
-  page?: PageLibrariesConfig
-): LibrariesConfig {
+export function mergeLibraries(global: LibrariesConfig, page?: PageLibrariesConfig): LibrariesConfig {
   if (!page) {
     return global;
   }
@@ -86,10 +74,7 @@ export function generateInlineStyleTag(content: string, media?: string): string
  * @returns HTML link tag string
  */
 export function generateStylesheetTag(lib: CSSLibraryConfig): string {
-  const attrs: string[] = [
-    'rel="stylesheet"',
-    `href="${escapeAttr(lib.url)}"`,
-  ];
+  const attrs: string[] = ['rel="stylesheet"', `href="${escapeAttr(lib.url)}"`];
 
   if (lib.media) {
     attrs.push(`media="${escapeAttr(lib.media)}"`);
@@ -157,7 +142,7 @@ export function generateLibraryTags(libs: LibrariesConfig, inlineContents?: Map<
  */
 export function collectComponentLibraries(
   globalComponents: Record<string, ComponentDefinition> = {},
-  pageComponents: Record<string, ComponentDefinition> = {}
+  pageComponents: Record<string, ComponentDefinition> = {},
 ): LibrariesConfig {
   const seenJS = new Set<string>();
   const seenCSS = new Set<string>();
@@ -230,13 +215,13 @@ export function extractLibraryOrigins(libs: LibrariesConfig): LibraryOrigins {
  */
 export function filterLibrariesByContext(
   libs: LibrariesConfig,
-  context: 'editor' | 'build' | 'preview'
+  context: 'editor' | 'build' | 'preview',
 ): LibrariesConfig {
   if (context === 'preview') return libs;
   const key = context === 'editor' ? 'disableEditor' : 'disableBuild';
   return {
     js: libs.js,
-    css: (libs.css || []).filter(css => !css[key]),
+    css: (libs.css || []).filter((css) => !css[key]),
   };
 }
 

package/lib/shared/linkUtils.ts

@@ -7,7 +7,7 @@
  * Normalize a URL path for comparison (strip trailing slash, query string, hash)
  */
 export function normalizePath(path: string): string {
-  let normalized = path.split('?')[0].split('#')[0];
+  let normalized = (path.split('?')[0] ?? '').split('#')[0] ?? '';
   if (normalized.length > 1 && normalized.endsWith('/')) {
     normalized = normalized.slice(0, -1);
   }

package/lib/shared/logger.test.ts

@@ -0,0 +1,66 @@
+import { test, expect, describe, afterEach, mock } from 'bun:test';
+import { createLogger, setLogLevel, getLogLevel, setLogSink, type LogRecord } from './logger';
+
+afterEach(() => {
+  setLogSink(null);
+  setLogLevel('debug');
+});
+
+describe('logger — level gating', () => {
+  test('suppresses levels below the active threshold', () => {
+    const records: LogRecord[] = [];
+    setLogSink((r) => records.push(r));
+    setLogLevel('warn');
+    const log = createLogger('Test');
+    log.debug('d');
+    log.info('i');
+    log.warn('w');
+    log.error('e');
+    expect(records.map((r) => r.level)).toEqual(['warn', 'error']);
+  });
+
+  test('silent suppresses everything', () => {
+    const records: LogRecord[] = [];
+    setLogSink((r) => records.push(r));
+    setLogLevel('silent');
+    const log = createLogger();
+    log.error('nope');
+    expect(records).toHaveLength(0);
+  });
+});
+
+describe('logger — scope + sink', () => {
+  test('forwards scope, message, and args to the sink', () => {
+    const records: LogRecord[] = [];
+    setLogSink((r) => records.push(r));
+    setLogLevel('debug');
+    createLogger('Area').info('hello', 1, { a: 2 });
+    expect(records).toHaveLength(1);
+    expect(records[0]).toMatchObject({ level: 'info', scope: 'Area', message: 'hello', args: [1, { a: 2 }] });
+    expect(typeof records[0]!.timestamp).toBe('number');
+  });
+
+  test('child nests the scope', () => {
+    const records: LogRecord[] = [];
+    setLogSink((r) => records.push(r));
+    createLogger('Parent').child('Child').warn('x');
+    expect(records[0]!.scope).toBe('Parent:Child');
+  });
+
+  test('routes to the matching console method', () => {
+    const spy = mock(() => {});
+    const orig = console.warn;
+    console.warn = spy as unknown as typeof console.warn;
+    try {
+      createLogger('S').warn('msg');
+    } finally {
+      console.warn = orig;
+    }
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  test('getLogLevel reflects setLogLevel', () => {
+    setLogLevel('info');
+    expect(getLogLevel()).toBe('info');
+  });
+});