diff --git a/e2e/cli-e2e/tests/__snapshots__/collect.e2e.test.ts.snap b/e2e/cli-e2e/tests/__snapshots__/collect.e2e.test.ts.snap
index 0755bd2a6..c2dfcd5a0 100644
--- a/e2e/cli-e2e/tests/__snapshots__/collect.e2e.test.ts.snap
+++ b/e2e/cli-e2e/tests/__snapshots__/collect.e2e.test.ts.snap
@@ -1798,6 +1798,7 @@ exports[`CLI collect > should run Lighthouse plugin that runs lighthouse CLI and
         },
       ],
       "icon": "lighthouse",
+      "packageName": "@code-pushup/lighthouse-plugin",
       "slug": "lighthouse",
       "title": "Lighthouse",
     },
diff --git a/packages/core/src/lib/implementation/report-to-gql.ts b/packages/core/src/lib/implementation/report-to-gql.ts
index 083704cbd..1a83fd6e3 100644
--- a/packages/core/src/lib/implementation/report-to-gql.ts
+++ b/packages/core/src/lib/implementation/report-to-gql.ts
@@ -125,10 +125,10 @@ export function tableToGQL(table: Table): PortalTable {
     }),
     rows: table.rows.map((row): PortalTableCell[] =>
       Array.isArray(row)
-        ? row.map(content => ({ content: content.toString() }))
+        ? row.map(content => ({ content: content?.toString() ?? '' }))
         : Object.entries(row).map(([key, content]) => ({
             key,
-            content: content.toString(),
+            content: content?.toString() ?? '',
           })),
     ),
   };
diff --git a/packages/models/src/index.ts b/packages/models/src/index.ts
index 6b5ed216e..f6775425a 100644
--- a/packages/models/src/index.ts
+++ b/packages/models/src/index.ts
@@ -1,6 +1,6 @@
 export {
-  PrimitiveValue,
-  primitiveValueSchema,
+  TableCellValue,
+  tableCellValueSchema,
 } from './lib/implementation/schemas';
 
 export { Audit, auditSchema } from './lib/audit';
diff --git a/packages/models/src/lib/implementation/schemas.ts b/packages/models/src/lib/implementation/schemas.ts
index fb8a81a80..30e09375e 100644
--- a/packages/models/src/lib/implementation/schemas.ts
+++ b/packages/models/src/lib/implementation/schemas.ts
@@ -7,8 +7,10 @@ import {
 } from './limits';
 import { filenameRegex, slugRegex } from './utils';
 
-export const primitiveValueSchema = z.union([z.string(), z.number()]);
-export type PrimitiveValue = z.infer<typeof primitiveValueSchema>;
+export const tableCellValueSchema = z
+  .union([z.string(), z.number(), z.boolean(), z.null()])
+  .default(null);
+export type TableCellValue = z.infer<typeof tableCellValueSchema>;
 
 /**
  * Schema for execution meta date
diff --git a/packages/models/src/lib/implementation/schemas.unit.test.ts b/packages/models/src/lib/implementation/schemas.unit.test.ts
index c30f1d251..3e74b89b5 100644
--- a/packages/models/src/lib/implementation/schemas.unit.test.ts
+++ b/packages/models/src/lib/implementation/schemas.unit.test.ts
@@ -1,15 +1,15 @@
 import { describe, expect, it } from 'vitest';
-import { PrimitiveValue, primitiveValueSchema, weightSchema } from './schemas';
+import { TableCellValue, tableCellValueSchema, weightSchema } from './schemas';
 
 describe('primitiveValueSchema', () => {
   it('should accept a valid union', () => {
-    const value: PrimitiveValue = 'test';
-    expect(() => primitiveValueSchema.parse(value)).not.toThrow();
+    const value: TableCellValue = 'test';
+    expect(() => tableCellValueSchema.parse(value)).not.toThrow();
   });
 
   it('should throw for a invalid union', () => {
     const value = new Date();
-    expect(() => primitiveValueSchema.parse(value)).toThrow('invalid_union');
+    expect(() => tableCellValueSchema.parse(value)).toThrow('invalid_union');
   });
 });
 
diff --git a/packages/models/src/lib/table.ts b/packages/models/src/lib/table.ts
index 447d19b00..ff166e2c0 100644
--- a/packages/models/src/lib/table.ts
+++ b/packages/models/src/lib/table.ts
@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { primitiveValueSchema } from './implementation/schemas';
+import { tableCellValueSchema } from './implementation/schemas';
 
 export const tableAlignmentSchema = z.enum(['left', 'center', 'right'], {
   description: 'Cell alignment',
@@ -16,12 +16,12 @@ export const tableColumnObjectSchema = z.object({
 });
 export type TableColumnObject = z.infer<typeof tableColumnObjectSchema>;
 
-export const tableRowObjectSchema = z.record(primitiveValueSchema, {
+export const tableRowObjectSchema = z.record(tableCellValueSchema, {
   description: 'Object row',
 });
 export type TableRowObject = z.infer<typeof tableRowObjectSchema>;
 
-export const tableRowPrimitiveSchema = z.array(primitiveValueSchema, {
+export const tableRowPrimitiveSchema = z.array(tableCellValueSchema, {
   description: 'Primitive row',
 });
 export type TableRowPrimitive = z.infer<typeof tableRowPrimitiveSchema>;
diff --git a/packages/models/src/lib/table.unit.test.ts b/packages/models/src/lib/table.unit.test.ts
index b6000949c..1dc803ab3 100644
--- a/packages/models/src/lib/table.unit.test.ts
+++ b/packages/models/src/lib/table.unit.test.ts
@@ -74,8 +74,15 @@ describe('tableRowObjectSchema', () => {
     expect(() => tableRowObjectSchema.parse(row)).not.toThrow();
   });
 
-  it('should throw for a invalid object', () => {
+  it('should default undefined object values to null', () => {
     const row = { prop: undefined };
+    expect(tableRowObjectSchema.parse(row)).toStrictEqual({
+      prop: null,
+    });
+  });
+
+  it('should throw for a invalid object', () => {
+    const row = { prop: [] };
     expect(() => tableRowObjectSchema.parse(row)).toThrow('invalid_union');
   });
 });
diff --git a/packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts b/packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts
index f33cd20eb..e71f68942 100644
--- a/packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts
+++ b/packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts
@@ -1,4 +1,5 @@
 import type { PluginConfig } from '@code-pushup/models';
+import { name, version } from '../../package.json';
 import { LIGHTHOUSE_PLUGIN_SLUG } from './constants';
 import { normalizeFlags } from './normalize-flags';
 import {
@@ -28,6 +29,8 @@ export function lighthousePlugin(
 
   return {
     slug: LIGHTHOUSE_PLUGIN_SLUG,
+    packageName: name,
+    version,
     title: 'Lighthouse',
     icon: 'lighthouse',
     audits,
diff --git a/packages/plugin-lighthouse/src/lib/runner/details/details.ts b/packages/plugin-lighthouse/src/lib/runner/details/details.ts
new file mode 100644
index 000000000..eabc3001b
--- /dev/null
+++ b/packages/plugin-lighthouse/src/lib/runner/details/details.ts
@@ -0,0 +1,81 @@
+import chalk from 'chalk';
+import type { FormattedIcu } from 'lighthouse';
+import type Details from 'lighthouse/types/lhr/audit-details';
+import { Result } from 'lighthouse/types/lhr/audit-result';
+import { AuditDetails, Table, tableSchema } from '@code-pushup/models';
+import { ui } from '@code-pushup/utils';
+import { PLUGIN_SLUG } from '../constants';
+import { parseTableToAuditDetailsTable } from './table.type';
+
+export function toAuditDetails<T extends FormattedIcu<Details>>(
+  details: T | undefined,
+): AuditDetails | undefined {
+  if (details == null) {
+    return undefined;
+  }
+
+  const { type } = details;
+
+  if (type !== 'table') {
+    return undefined;
+  }
+
+  const rawTable: Table | undefined = parseTableToAuditDetailsTable(details);
+
+  if (rawTable != null) {
+    const result = tableSchema().safeParse(rawTable);
+    if (result.success) {
+      return {
+        table: result.data,
+      };
+    }
+
+    throw new Error(
+      `Parsing details ${chalk.bold(
+        type,
+      )} failed: \nRaw data:\n ${JSON.stringify(
+        rawTable,
+        null,
+        2,
+      )}\n${result.error.toString()}`,
+    );
+  }
+
+  return undefined;
+}
+
+// @TODO implement all details
+export const unsupportedDetailTypes = new Set([
+  'opportunity',
+  'debugdata',
+  'treemap-data',
+  'screenshot',
+  'filmstrip',
+  'criticalrequestchain',
+]);
+
+export function logUnsupportedDetails(
+  lhrAudits: Result[],
+  { displayCount = 3 }: { displayCount?: number } = {},
+) {
+  const slugsWithDetailParsingErrors = [
+    ...new Set(
+      lhrAudits
+        .filter(({ details }) =>
+          unsupportedDetailTypes.has(details?.type as string),
+        )
+        .map(({ details }) => details?.type),
+    ),
+  ];
+  if (slugsWithDetailParsingErrors.length > 0) {
+    const postFix = (count: number) =>
+      count > displayCount ? ` and ${count - displayCount} more.` : '';
+    ui().logger.debug(
+      `${chalk.yellow('⚠')} Plugin ${chalk.bold(
+        PLUGIN_SLUG,
+      )} skipped parsing of unsupported audit details: ${chalk.bold(
+        slugsWithDetailParsingErrors.slice(0, displayCount).join(', '),
+      )}${postFix(slugsWithDetailParsingErrors.length)}`,
+    );
+  }
+}
diff --git a/packages/plugin-lighthouse/src/lib/runner/details/details.unit.test.ts b/packages/plugin-lighthouse/src/lib/runner/details/details.unit.test.ts
new file mode 100644
index 000000000..c4e00bc80
--- /dev/null
+++ b/packages/plugin-lighthouse/src/lib/runner/details/details.unit.test.ts
@@ -0,0 +1,194 @@
+import chalk from 'chalk';
+import type { FormattedIcu } from 'lighthouse';
+import type Details from 'lighthouse/types/lhr/audit-details';
+import type { Result } from 'lighthouse/types/lhr/audit-result';
+import { describe, expect, it } from 'vitest';
+import { getLogMessages } from '@code-pushup/test-utils';
+import { ui } from '@code-pushup/utils';
+import { logUnsupportedDetails, toAuditDetails } from './details';
+
+describe('logUnsupportedDetails', () => {
+  it('should log unsupported entries', () => {
+    logUnsupportedDetails([
+      { details: { type: 'screenshot' } },
+    ] as unknown as Result[]);
+    expect(getLogMessages(ui().logger)).toHaveLength(1);
+    expect(getLogMessages(ui().logger).at(0)).toBe(
+      `[ cyan(debug) ] ${chalk.yellow('⚠')} Plugin ${chalk.bold(
+        'lighthouse',
+      )} skipped parsing of unsupported audit details: ${chalk.bold(
+        'screenshot',
+      )}`,
+    );
+  });
+
+  it('should log only 3 details of unsupported entries', () => {
+    logUnsupportedDetails([
+      { details: { type: 'table' } },
+      { details: { type: 'filmstrip' } },
+      { details: { type: 'screenshot' } },
+      { details: { type: 'opportunity' } },
+      { details: { type: 'debugdata' } },
+      { details: { type: 'treemap-data' } },
+      { details: { type: 'criticalrequestchain' } },
+    ] as unknown as Result[]);
+    expect(getLogMessages(ui().logger)).toHaveLength(1);
+    expect(getLogMessages(ui().logger).at(0)).toBe(
+      `[ cyan(debug) ] ${chalk.yellow('⚠')} Plugin ${chalk.bold(
+        'lighthouse',
+      )} skipped parsing of unsupported audit details: ${chalk.bold(
+        'filmstrip, screenshot, opportunity',
+      )} and 3 more.`,
+    );
+  });
+});
+
+describe('toAuditDetails', () => {
+  it('should return undefined for missing details', () => {
+    const outputs = toAuditDetails(undefined);
+    expect(outputs).toBeUndefined();
+  });
+
+  it('should return undefined for unsupported type', () => {
+    const outputs = toAuditDetails({ type: 'debugdata' });
+    expect(outputs).toBeUndefined();
+  });
+
+  it('should return undefined for supported type with empty table', () => {
+    const outputs = toAuditDetails({
+      type: 'table',
+      items: [],
+    } as unknown as FormattedIcu<Details>);
+    expect(outputs).toBeUndefined();
+  });
+
+  it('should render audit details of type table', () => {
+    const outputs = toAuditDetails({
+      type: 'table',
+      headings: [
+        {
+          key: 'name',
+          valueType: 'text',
+          label: 'Name',
+        },
+        {
+          key: 'duration',
+          valueType: 'ms',
+          label: 'Duration',
+        },
+      ],
+      items: [
+        {
+          name: 'Zone',
+          duration: 0.634,
+        },
+        {
+          name: 'Zone:ZoneAwarePromise',
+          duration: 0.783,
+        },
+      ],
+    });
+
+    expect(outputs).toStrictEqual({
+      table: {
+        columns: [
+          {
+            key: 'name',
+            label: 'Name',
+            align: 'left',
+          },
+          {
+            key: 'duration',
+            label: 'Duration',
+            align: 'left',
+          },
+        ],
+        rows: [
+          {
+            name: 'Zone',
+            duration: '0.634 ms',
+          },
+          {
+            name: 'Zone:ZoneAwarePromise',
+            duration: '0.783 ms',
+          },
+        ],
+      },
+    });
+  });
+
+  it('should inform that debugdata detail type is not supported yet', () => {
+    const outputs = toAuditDetails({
+      type: 'debugdata',
+      items: [
+        {
+          cumulativeLayoutShiftMainFrame: 0.000_350_978_852_728_593_95,
+        },
+      ],
+    });
+
+    // @TODO add check that cliui.logger is called. Resolve TODO after PR #487 is merged.
+
+    expect(outputs).toBeUndefined();
+  });
+
+  it('should inform that filmstrip detail type is not supported yet', () => {
+    const outputs = toAuditDetails({
+      type: 'filmstrip',
+      scale: 3000,
+      items: [
+        {
+          timing: 375,
+          timestamp: 106_245_424_545,
+          data: 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwY...',
+        },
+      ],
+    });
+
+    expect(outputs).toBeUndefined();
+  });
+
+  it('should inform that screenshot detail type is not supported yet', () => {
+    const outputs = toAuditDetails({
+      type: 'screenshot',
+      timing: 541,
+      timestamp: 106_245_590_644,
+      data: 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD//2Q==',
+    });
+
+    expect(outputs).toBeUndefined();
+  });
+
+  it('should inform that treemap-data detail type is not supported yet', () => {
+    const outputs = toAuditDetails({
+      type: 'treemap-data',
+      nodes: [],
+    });
+
+    expect(outputs).toBeUndefined();
+  });
+
+  it('should inform that criticalrequestchain detail type is not supported yet', () => {
+    const outputs = toAuditDetails({
+      type: 'criticalrequestchain',
+      chains: {
+        EED301D300C9A7B634A444E0C6019FC1: {
+          request: {
+            url: 'https://example.com/',
+            startTime: 106_245.050_727,
+            endTime: 106_245.559_225,
+            responseReceivedTime: 106_245.559_001,
+            transferSize: 849,
+          },
+        },
+      },
+      longestChain: {
+        duration: 508.498_000_010_848_05,
+        length: 1,
+        transferSize: 849,
+      },
+    });
+
+    expect(outputs).toBeUndefined();
+  });
+});
diff --git a/packages/plugin-lighthouse/src/lib/runner/details/item-value.ts b/packages/plugin-lighthouse/src/lib/runner/details/item-value.ts
new file mode 100644
index 000000000..40d26f024
--- /dev/null
+++ b/packages/plugin-lighthouse/src/lib/runner/details/item-value.ts
@@ -0,0 +1,168 @@
+import chalk from 'chalk';
+import type { IcuMessage } from 'lighthouse';
+import type Details from 'lighthouse/types/lhr/audit-details';
+import {
+  formatBytes,
+  formatDuration,
+  html,
+  truncateText,
+  ui,
+} from '@code-pushup/utils';
+
+export type PrimitiveItemValue = string | number | boolean;
+export type ObjectItemValue = Exclude<
+  Details.ItemValue,
+  PrimitiveItemValue | IcuMessage
+>;
+export type SimpleItemValue =
+  | Extract<
+      ObjectItemValue,
+      Details.NumericValue | Details.CodeValue | Details.UrlValue
+    >
+  | PrimitiveItemValue;
+
+export function trimSlice(item?: PrimitiveItemValue, maxLength = 0) {
+  const str = String(item).trim();
+  return maxLength > 0 ? str.slice(0, maxLength) : str;
+}
+
+export function parseNodeValue(node?: Details.NodeValue): string {
+  const { selector = '' } = node ?? {};
+  return selector;
+}
+
+// eslint-disable-next-line max-lines-per-function
+export function formatTableItemPropertyValue(
+  itemValue?: Details.ItemValue,
+  itemValueFormat?: Details.ItemValueType,
+) {
+  // null
+  if (itemValue == null) {
+    return '';
+  }
+
+  // Primitive Values
+  if (itemValueFormat == null) {
+    if (typeof itemValue === 'string') {
+      return trimSlice(itemValue);
+    }
+
+    if (typeof itemValue === 'number') {
+      return Number(itemValue);
+    }
+
+    if (typeof itemValue === 'boolean') {
+      return itemValue;
+    }
+  }
+
+  const parsedItemValue = parseTableItemPropertyValue(itemValue);
+
+  /* eslint-disable no-magic-numbers */
+  switch (itemValueFormat) {
+    case 'bytes':
+      return formatBytes(Number(parsedItemValue));
+    case 'code':
+      return html.code(trimSlice(parsedItemValue as string));
+    case 'link':
+      const link = parsedItemValue as Details.LinkValue;
+      return html.link(link.url, link.text);
+    case 'url':
+      const url = parsedItemValue as string;
+      return html.link(url);
+    case 'timespanMs':
+    case 'ms':
+      return formatDuration(Number(parsedItemValue));
+    case 'node':
+      return parseNodeValue(itemValue as Details.NodeValue);
+    case 'source-location':
+      return truncateText(String(parsedItemValue), 200);
+    case 'numeric':
+      const num = Number(parsedItemValue);
+      if (num.toFixed(3).toString().endsWith('.000')) {
+        return String(num);
+      }
+      return String(num.toFixed(3));
+    case 'text':
+      return truncateText(String(parsedItemValue), 500);
+    case 'multi': // @TODO
+      // @TODO log verbose first, then implement data type
+      ui().logger.info(`Format type ${chalk.bold('multi')} is not implemented`);
+      return '';
+    case 'thumbnail': // @TODO
+      // @TODO log verbose first, then implement data type
+      ui().logger.info(
+        `Format type ${chalk.bold('thumbnail')} is not implemented`,
+      );
+      return '';
+    case null:
+      return '';
+    default:
+      return itemValue;
+  }
+  /* eslint-enable no-magic-numbers */
+}
+
+export function parseSimpleItemValue(
+  item: SimpleItemValue,
+): PrimitiveItemValue {
+  if (typeof item === 'object') {
+    const value = item.value;
+    if (typeof value === 'object') {
+      return value.formattedDefault;
+    }
+    return value;
+  }
+  return item;
+}
+
+// @TODO extract Link type from logic
+export function parseTableItemPropertyValue(
+  itemValue?: Details.ItemValue,
+): PrimitiveItemValue | Details.LinkValue {
+  if (itemValue == null) {
+    return '';
+  }
+
+  // Primitive Values
+  if (
+    typeof itemValue === 'string' ||
+    typeof itemValue === 'number' ||
+    typeof itemValue === 'boolean'
+  ) {
+    return parseSimpleItemValue(itemValue);
+  }
+
+  // Object Values
+  const objectValue = itemValue as ObjectItemValue;
+  const { type } = objectValue;
+  switch (type) {
+    case 'code':
+    case 'url':
+      return String(parseSimpleItemValue(objectValue));
+    case 'node':
+      return parseNodeValue(objectValue);
+    case 'link':
+      return objectValue;
+    case 'numeric':
+      return Number(parseSimpleItemValue(objectValue));
+    case 'source-location':
+      const { url } = objectValue;
+      return String(url);
+    case 'subitems':
+      // @TODO log verbose first, then implement data type
+      ui().logger.info(
+        `Value type ${chalk.bold('subitems')} is not implemented`,
+      );
+      return '';
+    case 'debugdata':
+      // @TODO log verbose first, then implement data type
+      ui().logger.info(
+        `Value type ${chalk.bold('debugdata')} is not implemented`,
+        { silent: true },
+      );
+      return '';
+  }
+  // IcuMessage
+  return parseSimpleItemValue(objectValue as SimpleItemValue);
+}
diff --git a/packages/plugin-lighthouse/src/lib/runner/details/item-value.unit.test.ts b/packages/plugin-lighthouse/src/lib/runner/details/item-value.unit.test.ts
new file mode 100644
index 000000000..8bdf16b2a
--- /dev/null
+++ b/packages/plugin-lighthouse/src/lib/runner/details/item-value.unit.test.ts
@@ -0,0 +1,383 @@
+import chalk from 'chalk';
+import Details from 'lighthouse/types/lhr/audit-details';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { getLogMessages } from '@code-pushup/test-utils';
+import { ui } from '@code-pushup/utils';
+import {
+  SimpleItemValue,
+  formatTableItemPropertyValue,
+  parseNodeValue,
+  parseSimpleItemValue,
+  parseTableItemPropertyValue,
+} from './item-value';
+
+describe('parseNodeValue', () => {
+  it('should parse selector of node', () => {
+    expect(parseNodeValue({ type: 'node', selector: 'h1 > span.icon' })).toBe(
+      'h1 > span.icon',
+    );
+  });
+
+  it('should parse empty node', () => {
+    expect(parseNodeValue(undefined)).toBe('');
+  });
+});
+
+describe('parseSimpleItemValue', () => {
+  it('should parse primitive ItemValue type string', () => {
+    expect(parseSimpleItemValue('42')).toBe('42');
+  });
+
+  it('should parse primitive ItemValue type number', () => {
+    expect(parseSimpleItemValue(42)).toBe(42);
+  });
+
+  it('should parse primitive ItemValue type boolean', () => {
+    expect(parseSimpleItemValue(false)).toBe(false);
+  });
+
+  it('should parse ObjectItemValue ItemValue type boolean', () => {
+    expect(parseSimpleItemValue({ type: 'numeric', value: 42 })).toBe(42);
+  });
+
+  it('should parse IcuMessage', () => {
+    expect(
+      parseSimpleItemValue({
+        value: { i18nId: 'i18nId-42', formattedDefault: '42' },
+      } as any),
+    ).toBe('42');
+  });
+});
+
+describe('parseTableItemPropertyValue', () => {
+  beforeAll(() => {
+    ui().switchMode('raw');
+  });
+
+  it('should parse undefined', () => {
+    expect(parseTableItemPropertyValue(undefined)).toBe('');
+  });
+
+  it('should parse primitive string value', () => {
+    expect(parseTableItemPropertyValue('42')).toBe('42');
+  });
+
+  it('should parse primitive number float value', () => {
+    expect(parseTableItemPropertyValue(42.21)).toBe(42.21);
+  });
+
+  it('should parse primitive number int value', () => {
+    expect(parseTableItemPropertyValue(42)).toBe(42);
+  });
+
+  it('should parse primitive boolean value', () => {
+    expect(parseTableItemPropertyValue(false)).toBe(false);
+  });
+
+  it('should parse value item code', () => {
+    expect(
+      parseTableItemPropertyValue({ type: 'code', value: 'const num = 42;' }),
+    ).toBe('const num = 42;');
+  });
+
+  it('should parse value item url', () => {
+    expect(
+      parseTableItemPropertyValue({
+        type: 'url',
+        value: 'https://www.code-pushup.dev',
+      }),
+    ).toBe('https://www.code-pushup.dev');
+  });
+
+  it('should parse value item link', () => {
+    expect(
+      parseTableItemPropertyValue({
+        type: 'link',
+        url: 'https://www.code-pushup.dev',
+        text: 'Code Pushup',
+      }),
+    ).toEqual({
+      type: 'link',
+      url: 'https://www.code-pushup.dev',
+      text: 'Code Pushup',
+    });
+  });
+
+  it('should parse value item node', () => {
+    expect(
+      parseTableItemPropertyValue({ type: 'node', selector: 'h1 > span.icon' }),
+    ).toBe('h1 > span.icon');
+  });
+
+  it('should parse value item numeric', () => {
+    expect(parseTableItemPropertyValue({ type: 'numeric', value: 42 })).toBe(
+      42,
+    );
+  });
+
+  it('should parse value item source-location', () => {
+    expect(
+      parseTableItemPropertyValue({
+        type: 'code',
+        value: 'Legible text',
+      }),
+    ).toBe('Legible text');
+  });
+
+  it('should parse value item subitems to empty string and log implemented', () => {
+    expect(
+      parseTableItemPropertyValue({
+        type: 'subitems',
+        items: [
+          {
+            url: 'https://fonts.gstatic.com/s/spacegrotesk/v16/V8mDoQDjQSkFtoMM3T6r8E7mPbF4Cw.woff2',
+            mainThreadTime: 0,
+            blockingTime: 0,
+            transferSize: 22_826,
+            tbtImpact: 0,
+          },
+          {
+            url: 'https://fonts.gstatic.com/s/spacegrotesk/v16/V8mDoQDjQSkFtoMM3T6r8E7mPb94C-s0.woff2',
+            mainThreadTime: 0,
+            blockingTime: 0,
+            transferSize: 18_380,
+            tbtImpact: 0,
+          },
+        ],
+      }),
+    ).toBe('');
+
+    expect(getLogMessages(ui().logger).at(0)).toBe(
+      `[ blue(info) ] Value type ${chalk.bold('subitems')} is not implemented`,
+    );
+  });
+
+  it('should parse value item debugdata to empty string and log implemented', () => {
+    expect(parseTableItemPropertyValue({ type: 'debugdata' })).toBe('');
+    expect(getLogMessages(ui().logger).at(0)).toBe(
+      `[ blue(info) ] Value type ${chalk.bold('debugdata')} is not implemented`,
+    );
+  });
+
+  it('should parse value item IcuMessage', () => {
+    expect(
+      parseTableItemPropertyValue({
+        value: { i18nId: 'i18nId-42', formattedDefault: 'IcuMessageValue' },
+      } as SimpleItemValue),
+    ).toBe('IcuMessageValue');
+  });
+});
+
+describe('formatTableItemPropertyValue', () => {
+  const alphabet = 'abcdefghijklmnopqrstuvwxyz';
+  const stringOfLength = (length: number, postfix = ''): string => {
+    const maxLength = length - postfix.length;
+    let result = '';
+    // eslint-disable-next-line functional/no-loop-statements
+    for (let i = 0; i < maxLength; i++) {
+      result += alphabet.at((alphabet.length - 1) % i);
+    }
+
+    if (postfix) {
+      result += postfix;
+    }
+
+    return result;
+  };
+
+  beforeAll(() => {
+    ui().switchMode('raw');
+  });
+
+  it('should format undefined to empty string', () => {
+    expect(formatTableItemPropertyValue(undefined)).toBe('');
+  });
+
+  it('should format primitive string value without extra type format', () => {
+    expect(formatTableItemPropertyValue('42   ')).toBe('42');
+  });
+
+  it('should format primitive number', () => {
+    expect(formatTableItemPropertyValue(42.213_123_123)).toBe(42.213_123_123);
+  });
+
+  it('should format primitive number value have no floating numbers if all are zeros', () => {
+    expect(formatTableItemPropertyValue(42)).toBe(42);
+  });
+
+  it('should format primitive boolean value', () => {
+    expect(formatTableItemPropertyValue(false)).toBe(false);
+  });
+
+  it('should forward non primitive value directly if no format is provided', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'debugdata', value: '42' },
+        undefined,
+      ),
+    ).toStrictEqual({ type: 'debugdata', value: '42' });
+  });
+
+  it('should format value based on itemValueFormat "bytes"', () => {
+    expect(formatTableItemPropertyValue('100000', 'numeric')).toBe('100000');
+  });
+
+  it('should format value based on itemValueFormat "code"', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'code', value: '<body><h1>Code Pushup</h1></body>' },
+        'code',
+      ),
+    ).toBe('<code><body><h1>Code Pushup</h1></body></code>');
+  });
+
+  it('should format value based on itemValueFormat "link"', () => {
+    expect(
+      formatTableItemPropertyValue(
+        {
+          type: 'link',
+          url: 'https://code-pushup.dev',
+          text: 'code-pushup.dev',
+        },
+        'link',
+      ),
+    ).toBe('<a href="https://code-pushup.dev">code-pushup.dev</a>');
+  });
+
+  it('should format value based on itemValueFormat "url"', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'url', value: 'https://code-pushup.dev' },
+        'url',
+      ),
+    ).toBe('<a href="https://code-pushup.dev">https://code-pushup.dev</a>');
+  });
+
+  it('should format value based on itemValueFormat "timespanMs"', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'numeric', value: 2142 },
+        'timespanMs',
+      ),
+    ).toBe('2.14 s');
+  });
+
+  it('should format value based on itemValueFormat "ms"', () => {
+    expect(
+      formatTableItemPropertyValue({ type: 'numeric', value: 2142 }, 'ms'),
+    ).toBe('2.14 s');
+  });
+
+  it('should format value based on itemValueFormat "node"', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'node', selector: 'h1 > span' },
+        'node',
+      ),
+    ).toBe('h1 > span');
+  });
+
+  it('should format value based on itemValueFormat "source-location"', () => {
+    expect(
+      formatTableItemPropertyValue(
+        {
+          type: 'source-location',
+          url: 'https://code-pushup.dev',
+        } as Details.ItemValue,
+        'source-location',
+      ),
+    ).toBe('https://code-pushup.dev');
+  });
+
+  it('should format value based on itemValueFormat "source-location" to a length of 200 and add "..."', () => {
+    const formattedStr = formatTableItemPropertyValue(
+      {
+        type: 'source-location',
+        url: stringOfLength(210, 'https://code-pushup.dev'),
+      } as Details.ItemValue,
+      'source-location',
+    ) as string;
+
+    expect(formattedStr.length).toBeLessThanOrEqual(200);
+    expect(formattedStr.slice(-3)).toBe('...');
+  });
+
+  it('should format value based on itemValueFormat "numeric" as int', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'numeric', value: 42 } as Details.ItemValue,
+        'numeric',
+      ),
+    ).toBe('42');
+  });
+
+  it('should format value based on itemValueFormat "numeric" as float', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'numeric', value: 42.1 } as Details.ItemValue,
+        'numeric',
+      ),
+    ).toBe('42.100');
+  });
+
+  it('should format value based on itemValueFormat "numeric" as int if float has only 0 post comma', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'numeric', value: Number('42.0') } as Details.ItemValue,
+        'numeric',
+      ),
+    ).toBe('42');
+  });
+
+  it('should format value based on itemValueFormat "text"', () => {
+    expect(
+      formatTableItemPropertyValue(
+        {
+          type: 'url',
+          value: 'https://github.com/code-pushup/cli/blob/main/README.md',
+        } as Details.ItemValue,
+        'text',
+      ),
+    ).toBe('https://github.com/code-pushup/cli/blob/main/README.md');
+  });
+
+  it('should format value based on itemValueFormat "text" to a length of 500 and add "..."', () => {
+    const formattedStr = formatTableItemPropertyValue(
+      {
+        type: 'url',
+        value: stringOfLength(510, 'https://github.com/'),
+      } as Details.ItemValue,
+      'text',
+    ) as string;
+
+    expect(formattedStr.length).toBeLessThanOrEqual(500);
+    expect(formattedStr.slice(-3)).toBe('...');
+  });
+
+  it('should format value based on itemValueFormat "multi"', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'numeric', value: 42 } as Details.ItemValue,
+        'multi',
+      ),
+    ).toBe('');
+
+    expect(getLogMessages(ui().logger).at(0)).toBe(
+      `[ blue(info) ] Format type ${chalk.bold('multi')} is not implemented`,
+    );
+  });
+
+  it('should format value based on itemValueFormat "thumbnail"', () => {
+    expect(
+      formatTableItemPropertyValue(
+        { type: 'numeric', value: 42 } as Details.ItemValue,
+        'thumbnail',
+      ),
+    ).toBe('');
+    expect(getLogMessages(ui().logger).at(0)).toBe(
+      `[ blue(info) ] Format type ${chalk.bold(
+        'thumbnail',
+      )} is not implemented`,
+    );
+  });
+});
diff --git a/packages/plugin-lighthouse/src/lib/runner/details/table.type.ts b/packages/plugin-lighthouse/src/lib/runner/details/table.type.ts
new file mode 100644
index 000000000..7937e50bb
--- /dev/null
+++ b/packages/plugin-lighthouse/src/lib/runner/details/table.type.ts
@@ -0,0 +1,58 @@
+import type Details from 'lighthouse/types/lhr/audit-details';
+import { Table, TableColumnObject, TableRowObject } from '@code-pushup/models';
+import { formatTableItemPropertyValue } from './item-value';
+
+export function parseTableToAuditDetailsTable(
+  details: Details.Table,
+): Table | undefined {
+  const { headings: rawHeadings, items } = details;
+
+  if (items.length === 0) {
+    return undefined;
+  }
+
+  return {
+    columns: parseTableColumns(rawHeadings),
+    rows: items.map(row => parseTableRow(row, rawHeadings)),
+  };
+}
+
+export function parseTableColumns(
+  rawHeadings: Details.TableColumnHeading[],
+): TableColumnObject[] {
+  return rawHeadings.map(({ key, label }) => ({
+    key: key ?? '',
+    label: typeof label === 'string' ? label : undefined,
+    align: 'left',
+  }));
+}
+
+export function parseTableRow(
+  tableItem: Details.TableItem,
+  headings: Details.TableColumnHeading[],
+): TableRowObject {
+  const keys = new Set(headings.map(({ key }) => key));
+  const valueTypesByKey = new Map(
+    headings.map(({ key, valueType }) => [key, valueType]),
+  );
+
+  return Object.fromEntries(
+    Object.entries(tableItem)
+      .filter(([key]) => keys.has(key))
+      .map(([key, value]) => {
+        const valueType = valueTypesByKey.get(key);
+        return parseTableEntry([key, value], valueType);
+      }),
+  ) as TableRowObject;
+}
+
+export function parseTableEntry<T extends Details.TableItem>(
+  [key, value]: [keyof T, T[keyof T]],
+  valueType?: Details.ItemValueType,
+): [keyof T, Details.ItemValue | undefined] {
+  if (value == null) {
+    return [key, value];
+  }
+
+  return [key, formatTableItemPropertyValue(value, valueType)];
+}
diff --git a/packages/plugin-lighthouse/src/lib/runner/details/table.type.unit.test.ts b/packages/plugin-lighthouse/src/lib/runner/details/table.type.unit.test.ts
new file mode 100644
index 000000000..6daabe70f
--- /dev/null
+++ b/packages/plugin-lighthouse/src/lib/runner/details/table.type.unit.test.ts
@@ -0,0 +1,378 @@
+import type Details from 'lighthouse/types/lhr/audit-details';
+import { describe, expect, it } from 'vitest';
+import { Table } from '@code-pushup/models';
+import {
+  parseTableColumns,
+  parseTableEntry,
+  parseTableRow,
+  parseTableToAuditDetailsTable,
+} from './table.type';
+
+describe('parseTableToAuditDetails', () => {
+  it('should render complete details of type table', () => {
+    const outputs = parseTableToAuditDetailsTable({
+      type: 'table',
+      headings: [
+        {
+          key: 'statistic',
+          valueType: 'text',
+          label: 'Statistic',
+        },
+        {
+          key: 'node',
+          valueType: 'node',
+          label: 'Element',
+        },
+        {
+          key: 'value',
+          valueType: 'numeric',
+          label: 'Value',
+        },
+      ],
+      items: [
+        {
+          statistic: 'Total DOM Elements',
+          value: {
+            type: 'numeric',
+            granularity: 1,
+            value: 138,
+          },
+        },
+        {
+          node: {
+            type: 'node',
+            lhId: '1-5-IMG',
+            path: '1,HTML,1,BODY,1,CP-ROOT,0,HEADER,0,DIV,1,NAV,0,UL,0,LI,0,A,0,IMG',
+            selector: 'ul.navigation > li > a.nav-item > img.icon',
+            boundingRect: {
+              top: 12,
+              bottom: 44,
+              left: 293,
+              right: 325,
+              width: 32,
+              height: 32,
+            },
+            snippet:
+              '<img _ngcontent-ng-c3690293395="" ngsrc="assets/github.svg" alt="" height="32" width="32" class="icon" loading="lazy" fetchpriority="auto" ng-img="true" src="assets/github.svg">',
+            nodeLabel: 'ul.navigation > li > a.nav-item > img.icon',
+          },
+          statistic: 'Maximum DOM Depth',
+          value: {
+            type: 'numeric',
+            granularity: 1,
+            value: 9,
+          },
+        },
+        {
+          node: {
+            type: 'node',
+            lhId: '1-6-P',
+            path: '1,HTML,1,BODY,1,CP-ROOT,4,FOOTER,0,DIV,0,P',
+            selector: 'cp-root > footer.footer > div.footer-content > p.legal',
+            boundingRect: {
+              top: 5705,
+              bottom: 5914,
+              left: 10,
+              right: 265,
+              width: 254,
+              height: 209,
+            },
+            snippet: '<p _ngcontent-ng-c3690293395="" class="legal">',
+            nodeLabel:
+              'CodePushUp, s.r.o.\n\nKorunní 2569/108,\n101 00, Prague,\nIČ: 19880197\n\nhello@code-…',
+          },
+          statistic: 'Maximum Child Elements',
+          value: {
+            type: 'numeric',
+            granularity: 1,
+            value: 9,
+          },
+        },
+      ],
+    } satisfies Details.Table);
+
+    expect(outputs).toStrictEqual({
+      columns: [
+        {
+          key: 'statistic',
+          label: 'Statistic',
+          align: 'left',
+        },
+        {
+          key: 'node',
+          label: 'Element',
+          align: 'left',
+        },
+        {
+          key: 'value',
+          label: 'Value',
+          align: 'left',
+        },
+      ],
+      rows: [
+        {
+          statistic: 'Total DOM Elements',
+          value: '138',
+        },
+        {
+          statistic: 'Maximum DOM Depth',
+          node: 'ul.navigation > li > a.nav-item > img.icon',
+          value: '9',
+        },
+        {
+          statistic: 'Maximum Child Elements',
+          node: 'cp-root > footer.footer > div.footer-content > p.legal',
+          value: '9',
+        },
+      ],
+    } satisfies Table);
+  });
+
+  it('should omit empty table', () => {
+    const outputs = parseTableToAuditDetailsTable({
+      type: 'table',
+      headings: [],
+      items: [],
+    } as Details.Table);
+
+    expect(outputs).toBeUndefined();
+  });
+
+  it('should accept rows with primitive values', () => {
+    const outputs = parseTableToAuditDetailsTable({
+      type: 'table',
+      headings: [
+        {
+          key: 'label',
+          valueType: 'text',
+          label: 'Resource Type',
+        },
+        {
+          key: 'requestCount',
+          valueType: 'numeric',
+          label: 'Requests',
+        },
+        {
+          key: 'transferSize',
+          valueType: 'bytes',
+          label: 'Transfer Size',
+        },
+      ],
+      items: [
+        {
+          resourceType: 'total',
+          label: 'Total',
+          requestCount: 14,
+          transferSize: 441_023,
+        },
+        {
+          resourceType: 'image',
+          label: 'Image',
+          requestCount: 9,
+          transferSize: 357_829,
+        },
+        {
+          resourceType: 'font',
+          label: 'Font',
+          requestCount: 2,
+          transferSize: 41_206,
+        },
+        {
+          resourceType: 'script',
+          label: 'Script',
+          requestCount: 1,
+          transferSize: 38_076,
+        },
+        {
+          resourceType: 'document',
+          label: 'Document',
+          requestCount: 1,
+          transferSize: 3455,
+        },
+        {
+          resourceType: 'stylesheet',
+          label: 'Stylesheet',
+          requestCount: 1,
+          transferSize: 457,
+        },
+        {
+          resourceType: 'media',
+          label: 'Media',
+          requestCount: 0,
+          transferSize: 0,
+        },
+        {
+          resourceType: 'other',
+          label: 'Other',
+          requestCount: 0,
+          transferSize: 0,
+        },
+        {
+          resourceType: 'third-party',
+          label: 'Third-party',
+          requestCount: 2,
+          transferSize: 41_206,
+        },
+      ],
+    } as Details.Table);
+
+    expect(outputs).toEqual({
+      columns: [
+        {
+          align: 'left',
+          key: 'label',
+          label: 'Resource Type',
+        },
+        {
+          align: 'left',
+          key: 'requestCount',
+          label: 'Requests',
+        },
+        {
+          align: 'left',
+          key: 'transferSize',
+          label: 'Transfer Size',
+        },
+      ],
+      rows: [
+        {
+          label: 'Total',
+          requestCount: '14',
+          transferSize: '430.69 kB',
+        },
+        {
+          label: 'Image',
+          requestCount: '9',
+          transferSize: '349.44 kB',
+        },
+        {
+          label: 'Font',
+          requestCount: '2',
+          transferSize: '40.24 kB',
+        },
+        {
+          label: 'Script',
+          requestCount: '1',
+          transferSize: '37.18 kB',
+        },
+        {
+          label: 'Document',
+          requestCount: '1',
+          transferSize: '3.37 kB',
+        },
+        {
+          label: 'Stylesheet',
+          requestCount: '1',
+          transferSize: '457 B',
+        },
+        {
+          label: 'Media',
+          requestCount: '0',
+          transferSize: '0 B',
+        },
+        {
+          label: 'Other',
+          requestCount: '0',
+          transferSize: '0 B',
+        },
+        {
+          label: 'Third-party',
+          requestCount: '2',
+          transferSize: '40.24 kB',
+        },
+      ],
+    } satisfies Table);
+  });
+});
+
+describe('parseTableColumns', () => {
+  it('should return for empty columns', () => {
+    const outputs = parseTableColumns([]);
+    expect(outputs).toStrictEqual([]);
+  });
+
+  it('should fall back to empty string if key property is missing', () => {
+    const outputs = parseTableColumns([
+      {
+        keyy: 'prop',
+        label: 'PROP',
+      } as unknown as Details.TableColumnHeading,
+    ]);
+
+    expect(outputs).toEqual([expect.objectContaining({ key: '' })]);
+  });
+
+  it('should fall back to undefined if label property is missing', () => {
+    const outputs = parseTableColumns([
+      {
+        key: 'prop',
+        labellll: 'PROP',
+      } as unknown as Details.TableColumnHeading,
+    ]);
+
+    expect(outputs).toEqual([expect.objectContaining({ label: undefined })]);
+  });
+
+  it('should fill align with "left"', () => {
+    const outputs = parseTableColumns([
+      {
+        key: 'prop',
+        label: 'PROP',
+      } as Details.TableColumnHeading,
+    ]);
+
+    expect(outputs).toEqual([expect.objectContaining({ align: 'left' })]);
+  });
+
+  it('should accept columns', () => {
+    const outputs = parseTableColumns([
+      {
+        key: 'prop',
+        label: 'PROP',
+      } as Details.TableColumnHeading,
+    ]);
+
+    expect(outputs).toStrictEqual([
+      {
+        align: 'left',
+        key: 'prop',
+        label: 'PROP',
+      },
+    ]);
+  });
+});
+
+describe('parseTableRow', () => {
+  it('should accept rows with primitive values', () => {
+    const outputs = parseTableRow({ value: 12 }, []);
+
+    expect(outputs).toEqual({});
+  });
+
+  it('should filter keys by headings', () => {
+    const outputs = parseTableRow({ value: 12, tralala: '42' }, [
+      { key: 'tralala' },
+    ] as Details.TableColumnHeading[]);
+
+    expect(outputs).toEqual({ tralala: '42' });
+  });
+
+  it('should render complete details of type table', () => {
+    const outputs = parseTableRow({ value: 12 }, []);
+    expect(outputs).toEqual({});
+  });
+});
+
+describe('parseTableEntry', () => {
+  it('should forward nullish values', () => {
+    const outputs = parseTableEntry(['prop1', undefined]);
+
+    expect(outputs).toStrictEqual(['prop1', undefined]);
+  });
+
+  it('should forward non nullish values', () => {
+    const outputs = parseTableEntry(['prop1', 42]);
+
+    expect(outputs).toStrictEqual(['prop1', 42]);
+  });
+});
diff --git a/packages/plugin-lighthouse/src/lib/runner/details/types.ts b/packages/plugin-lighthouse/src/lib/runner/details/types.ts
new file mode 100644
index 000000000..e681b673b
--- /dev/null
+++ b/packages/plugin-lighthouse/src/lib/runner/details/types.ts
@@ -0,0 +1,4 @@
+export type DOM = {
+  append: (v: string) => string;
+  createComponent: (type: 'crcChain', opt: Record<string, unknown>) => string;
+};
diff --git a/packages/plugin-lighthouse/src/lib/runner/runner.unit.test.ts b/packages/plugin-lighthouse/src/lib/runner/runner.unit.test.ts
index 696436af0..66191db89 100644
--- a/packages/plugin-lighthouse/src/lib/runner/runner.unit.test.ts
+++ b/packages/plugin-lighthouse/src/lib/runner/runner.unit.test.ts
@@ -1,6 +1,6 @@
-import { type Config } from 'lighthouse';
+import type { Config } from 'lighthouse';
 import { runLighthouse } from 'lighthouse/cli/run.js';
-import { Result } from 'lighthouse/types/lhr/audit-result';
+import type { Result } from 'lighthouse/types/lhr/audit-result';
 import { expect, vi } from 'vitest';
 import { DEFAULT_CLI_FLAGS } from './constants';
 import { createRunnerFunction } from './runner';
diff --git a/packages/plugin-lighthouse/src/lib/runner/utils.ts b/packages/plugin-lighthouse/src/lib/runner/utils.ts
index 3a59e6fae..85d29cd95 100644
--- a/packages/plugin-lighthouse/src/lib/runner/utils.ts
+++ b/packages/plugin-lighthouse/src/lib/runner/utils.ts
@@ -8,7 +8,7 @@ import { Result } from 'lighthouse/types/lhr/audit-result';
 import { AuditOutput, AuditOutputs } from '@code-pushup/models';
 import { importEsmModule, readJsonFile, ui } from '@code-pushup/utils';
 import type { LighthouseOptions } from '../types';
-import { PLUGIN_SLUG } from './constants';
+import { logUnsupportedDetails, toAuditDetails } from './details/details';
 import { LighthouseCliFlags } from './types';
 
 // @TODO fix https://github.com/code-pushup/cli/issues/612
@@ -37,7 +37,6 @@ export function toAuditOutputs(
   { verbose = false }: { verbose?: boolean } = {},
 ): AuditOutputs {
   if (verbose) {
-    // @TODO implement all details
     logUnsupportedDetails(lhrAudits);
   }
   return lhrAudits.map(
@@ -55,9 +54,19 @@ export function toAuditOutputs(
         displayValue,
       };
 
-      if (details == null) {
-        // @TODO implement details
-        return auditOutput;
+      if (details != null) {
+        try {
+          const parsedDetails = toAuditDetails(details);
+          return parsedDetails
+            ? { ...auditOutput, details: parsedDetails }
+            : auditOutput;
+        } catch (error) {
+          throw new Error(
+            `\nAudit ${chalk.bold(slug)} failed parsing details: \n${
+              (error as Error).message
+            }`,
+          );
+        }
       }
 
       return auditOutput;
@@ -75,32 +84,6 @@ export const unsupportedDetailTypes = new Set([
   'criticalrequestchain',
 ]);
 
-export function logUnsupportedDetails(
-  lhrAudits: Result[],
-  { displayCount = 3 }: { displayCount?: number } = {},
-) {
-  const slugsWithDetailParsingErrors = [
-    ...new Set(
-      lhrAudits
-        .filter(({ details }) =>
-          unsupportedDetailTypes.has(details?.type as string),
-        )
-        .map(({ details }) => details?.type),
-    ),
-  ];
-  if (slugsWithDetailParsingErrors.length > 0) {
-    const postFix = (count: number) =>
-      count > displayCount ? ` and ${count - displayCount} more.` : '';
-    ui().logger.debug(
-      `${chalk.yellow('⚠')} Plugin ${chalk.bold(
-        PLUGIN_SLUG,
-      )} skipped parsing of unsupported audit details: ${chalk.bold(
-        slugsWithDetailParsingErrors.slice(0, displayCount).join(', '),
-      )}${postFix(slugsWithDetailParsingErrors.length)}`,
-    );
-  }
-}
-
 export type LighthouseLogLevel =
   | 'verbose'
   | 'error'
@@ -138,7 +121,7 @@ export async function getConfig(
 ): Promise<Config | undefined> {
   const { configPath: filepath, preset } = options;
 
-  if (typeof filepath === 'string') {
+  if (filepath != null) {
     if (filepath.endsWith('.json')) {
       // Resolve the config file path relative to where cli was called.
       return readJsonFile<Config>(filepath);
diff --git a/packages/plugin-lighthouse/src/lib/runner/utils.unit.test.ts b/packages/plugin-lighthouse/src/lib/runner/utils.unit.test.ts
index 3e55afdef..06de390a1 100644
--- a/packages/plugin-lighthouse/src/lib/runner/utils.unit.test.ts
+++ b/packages/plugin-lighthouse/src/lib/runner/utils.unit.test.ts
@@ -1,20 +1,22 @@
-import chalk from 'chalk';
 import debug from 'debug';
 import log from 'lighthouse-logger';
-import Details from 'lighthouse/types/lhr/audit-details';
 import { Result } from 'lighthouse/types/lhr/audit-result';
 import { vol } from 'memfs';
 import { join } from 'node:path';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { CoreConfig, auditOutputsSchema } from '@code-pushup/models';
+import {
+  AuditOutput,
+  CoreConfig,
+  auditOutputsSchema,
+} from '@code-pushup/models';
 import { MEMFS_VOLUME, getLogMessages } from '@code-pushup/test-utils';
 import { ui } from '@code-pushup/utils';
+import { unsupportedDetailTypes } from './details/details';
 import {
   determineAndSetLogLevel,
   getConfig,
-  logUnsupportedDetails,
+  normalizeAuditOutputs,
   toAuditOutputs,
-  unsupportedDetailTypes,
 } from './utils';
 
 // mock bundleRequire inside importEsmModule used for fetching config
@@ -42,36 +44,29 @@ vi.mock('bundle-require', async () => {
   };
 });
 
-describe('logUnsupportedDetails', () => {
-  it('should log unsupported entries', () => {
-    logUnsupportedDetails([
-      { details: { type: 'table' } },
-    ] as unknown as Result[]);
-    expect(getLogMessages(ui().logger)).toHaveLength(1);
-    expect(getLogMessages(ui().logger).at(0)).toBe(
-      `[ cyan(debug) ] ${chalk.yellow('⚠')} Plugin ${chalk.bold(
-        'lighthouse',
-      )} skipped parsing of unsupported audit details: ${chalk.bold('table')}`,
-    );
+describe('normalizeAuditOutputs', () => {
+  it('should filter audits listed under skipAudits', () => {
+    expect(
+      normalizeAuditOutputs(
+        [
+          { slug: 'largest-contentful-paint' } as AuditOutput,
+          { slug: 'cumulative-layout-shifts' } as AuditOutput,
+        ],
+        { skipAudits: ['largest-contentful-paint'] },
+      ),
+    ).toStrictEqual([{ slug: 'cumulative-layout-shifts' }]);
   });
-  it('should log only 3 details of unsupported entries', () => {
-    logUnsupportedDetails([
-      { details: { type: 'table' } },
-      { details: { type: 'filmstrip' } },
-      { details: { type: 'screenshot' } },
-      { details: { type: 'opportunity' } },
-      { details: { type: 'debugdata' } },
-      { details: { type: 'treemap-data' } },
-      { details: { type: 'criticalrequestchain' } },
-    ] as unknown as Result[]);
-    expect(getLogMessages(ui().logger)).toHaveLength(1);
-    expect(getLogMessages(ui().logger).at(0)).toBe(
-      `[ cyan(debug) ] ${chalk.yellow('⚠')} Plugin ${chalk.bold(
-        'lighthouse',
-      )} skipped parsing of unsupported audit details: ${chalk.bold(
-        'table, filmstrip, screenshot',
-      )} and 4 more.`,
-    );
+
+  it('should NOT filter audits if no skipAudits are listed', () => {
+    expect(
+      normalizeAuditOutputs([
+        { slug: 'largest-contentful-paint' } as AuditOutput,
+        { slug: 'cumulative-layout-shifts' } as AuditOutput,
+      ]),
+    ).toStrictEqual([
+      { slug: 'largest-contentful-paint' },
+      { slug: 'cumulative-layout-shifts' },
+    ]);
   });
 });
 
@@ -131,7 +126,7 @@ describe('toAuditOutputs', () => {
     );
   });
 
-  it('should NOT inform that for all unsupported details if verbose is NOT given', () => {
+  it('should NOT inform for unsupported details if verbose is NOT given', () => {
     const types = [...unsupportedDetailTypes];
     toAuditOutputs(
       types.map(
@@ -143,6 +138,7 @@ describe('toAuditOutputs', () => {
     );
     expect(getLogMessages(ui().logger)).toHaveLength(0);
   });
+
   it('should inform that for all unsupported details if verbose IS given', () => {
     const types = [...unsupportedDetailTypes];
     toAuditOutputs(
@@ -156,187 +152,6 @@ describe('toAuditOutputs', () => {
     );
     expect(getLogMessages(ui().logger)).toHaveLength(1);
   });
-
-  it('should inform that opportunity detail type is not supported yet', () => {
-    const outputs = toAuditOutputs([
-      {
-        id: 'dummy-audit',
-        title: 'Dummy Audit',
-        description: 'This is a dummy audit.',
-        score: null,
-        scoreDisplayMode: 'informative',
-        details: {
-          type: 'opportunity',
-          headings: [
-            {
-              key: 'url',
-              valueType: 'url',
-              label: 'URL',
-            },
-            {
-              key: 'responseTime',
-              valueType: 'timespanMs',
-              label: 'Time Spent',
-            },
-          ],
-          items: [
-            {
-              url: 'https://staging.code-pushup.dev/login',
-              responseTime: 449.292_000_000_000_03,
-            },
-          ],
-          overallSavingsMs: 349.292_000_000_000_03,
-        } satisfies Details.Opportunity,
-      },
-    ]);
-
-    expect(outputs[0]?.details).toBeUndefined();
-  });
-
-  it('should inform that table detail type is not supported yet', () => {
-    const outputs = toAuditOutputs([
-      {
-        id: 'dummy-audit',
-        title: 'Dummy Audit',
-        description: 'This is a dummy audit.',
-        score: null,
-        scoreDisplayMode: 'informative',
-        details: {
-          type: 'table',
-          headings: [],
-          items: [],
-        },
-      },
-    ]);
-
-    expect(outputs[0]?.details).toBeUndefined();
-  });
-
-  it('should inform that debugdata detail type is not supported yet', () => {
-    const outputs = toAuditOutputs([
-      {
-        id: 'cumulative-layout-shift',
-        title: 'Cumulative Layout Shift',
-        description:
-          'Cumulative Layout Shift measures the movement of visible elements within the viewport. [Learn more about the Cumulative Layout Shift metric](https://web.dev/cls/).',
-        score: 1,
-        scoreDisplayMode: 'numeric',
-        numericValue: 0.000_350_978_852_728_593_95,
-        numericUnit: 'unitless',
-        displayValue: '0',
-        details: {
-          type: 'debugdata',
-          items: [
-            {
-              cumulativeLayoutShiftMainFrame: 0.000_350_978_852_728_593_95,
-            },
-          ],
-        },
-      },
-    ]);
-
-    // @TODO add check that cliui.logger is called. Resolve TODO after PR #487 is merged.
-
-    expect(outputs[0]?.details).toBeUndefined();
-  });
-
-  it('should inform that filmstrip detail type is not supported yet', () => {
-    const outputs = toAuditOutputs([
-      {
-        id: 'screenshot-thumbnails',
-        title: 'Screenshot Thumbnails',
-        description: 'This is what the load of your site looked like.',
-        score: null,
-        scoreDisplayMode: 'informative',
-        details: {
-          type: 'filmstrip',
-          scale: 3000,
-          items: [
-            {
-              timing: 375,
-              timestamp: 106_245_424_545,
-              data: 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwY...',
-            },
-          ],
-        },
-      },
-    ]);
-
-    expect(outputs[0]?.details).toBeUndefined();
-  });
-
-  it('should inform that screenshot detail type is not supported yet', () => {
-    const outputs = toAuditOutputs([
-      {
-        id: 'final-screenshot',
-        title: 'Final Screenshot',
-        description: 'The last screenshot captured of the pageload.',
-        score: null,
-        scoreDisplayMode: 'informative',
-        details: {
-          type: 'screenshot',
-          timing: 541,
-          timestamp: 106_245_590_644,
-          data: 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD//2Q==',
-        },
-      },
-    ]);
-
-    expect(outputs[0]?.details).toBeUndefined();
-  });
-
-  it('should inform that treemap-data detail type is not supported yet', () => {
-    const outputs = toAuditOutputs([
-      {
-        id: 'script-treemap-data',
-        title: 'Script Treemap Data',
-        description: 'Used for treemap app',
-        score: null,
-        scoreDisplayMode: 'informative',
-        details: {
-          type: 'treemap-data',
-          nodes: [],
-        },
-      },
-    ]);
-
-    expect(outputs[0]?.details).toBeUndefined();
-  });
-
-  it('should inform that criticalrequestchain detail type is not supported yet', () => {
-    const outputs = toAuditOutputs([
-      {
-        id: 'critical-request-chains',
-        title: 'Avoid chaining critical requests',
-        description:
-          'The Critical Request Chains below show you what resources are loaded with a high priority. Consider reducing the length of chains, reducing the download size of resources, or deferring the download of unnecessary resources to improve page load. [Learn how to avoid chaining critical requests](https://developer.chrome.com/docs/lighthouse/performance/critical-request-chains/).',
-        score: null,
-        scoreDisplayMode: 'notApplicable',
-        displayValue: '',
-        details: {
-          type: 'criticalrequestchain',
-          chains: {
-            EED301D300C9A7B634A444E0C6019FC1: {
-              request: {
-                url: 'https://example.com/',
-                startTime: 106_245.050_727,
-                endTime: 106_245.559_225,
-                responseReceivedTime: 106_245.559_001,
-                transferSize: 849,
-              },
-            },
-          },
-          longestChain: {
-            duration: 508.498_000_010_848_05,
-            length: 1,
-            transferSize: 849,
-          },
-        },
-      },
-    ]);
-
-    expect(outputs[0]?.details).toBeUndefined();
-  });
 });
 
 describe('getConfig', () => {
diff --git a/packages/utils/src/lib/formatting.ts b/packages/utils/src/lib/formatting.ts
index d3129af02..efe7bef44 100644
--- a/packages/utils/src/lib/formatting.ts
+++ b/packages/utils/src/lib/formatting.ts
@@ -49,9 +49,9 @@ export function pluralizeToken(token: string, times: number): string {
   return `${times} ${Math.abs(times) === 1 ? token : pluralize(token)}`;
 }
 
-export function formatDuration(duration: number): string {
+export function formatDuration(duration: number, granularity = 0): string {
   if (duration < 1000) {
-    return `${duration} ms`;
+    return `${granularity ? duration.toFixed(granularity) : duration} ms`;
   }
   return `${(duration / 1000).toFixed(2)} s`;
 }
diff --git a/packages/utils/src/lib/reports/formatting.unit.test.ts b/packages/utils/src/lib/reports/formatting.unit.test.ts
index 81ff85712..371ec7131 100644
--- a/packages/utils/src/lib/reports/formatting.unit.test.ts
+++ b/packages/utils/src/lib/reports/formatting.unit.test.ts
@@ -3,6 +3,45 @@ import { NEW_LINE } from '../text-formats/constants';
 import { metaDescription, tableSection } from './formatting';
 
 describe('tableSection', () => {
+  it('should accept a title', () => {
+    const sectionContent = tableSection({
+      title: 'LCP Breakdown',
+      rows: [[1]],
+    });
+    expect(sectionContent).toMatch('#### LCP Breakdown\n\n');
+  });
+
+  it('should accept a title level', () => {
+    const sectionContent = tableSection(
+      {
+        title: 'LCP Breakdown',
+        rows: [[1]],
+      },
+      { level: 3 },
+    );
+    expect(sectionContent).toMatch('### LCP Breakdown\n\n');
+  });
+
+  it('should not add heading format and additional new line if level value is 0', () => {
+    const sectionContent = tableSection(
+      {
+        title: 'LCP Breakdown',
+        rows: [[1]],
+      },
+      { level: 0 },
+    );
+    expect(sectionContent).toMatch('LCP Breakdown\n');
+  });
+
+  it('should return empty string for a table with empty rows', () => {
+    expect(
+      tableSection({
+        title: 'LCP Breakdown',
+        rows: [],
+      }),
+    ).toMatch('');
+  });
+
   it('should render complete section', () => {
     expect(
       tableSection(
diff --git a/packages/utils/src/lib/table.ts b/packages/utils/src/lib/table.ts
deleted file mode 100644
index 338b6b01a..000000000
--- a/packages/utils/src/lib/table.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import {
-  PrimitiveValue,
-  Table,
-  TableAlignment,
-  TableColumnObject,
-  TableColumnPrimitive,
-} from '@code-pushup/models';
-import { capitalize } from './transform';
-
-export function rowToStringArray({ rows, columns = [] }: Table): string[][] {
-  if (Array.isArray(rows.at(0)) && typeof columns.at(0) === 'object') {
-    throw new TypeError(
-      'Column can`t be object when rows are primitive values',
-    );
-  }
-
-  return rows.map(row => {
-    // row = ['100 ms', '200 ms']
-    if (Array.isArray(row)) {
-      return row.map(String);
-    }
-
-    // row = { prop1: '100 ms', prop2: '200 ms' }
-    const objectRow = row;
-
-    // columns [] || column = 'center'
-    if (columns.length === 0 || typeof columns.at(0) === 'string') {
-      return Object.values(objectRow).map(String);
-    }
-
-    // column = {key: 'prop1'}
-    return (columns as TableColumnObject[]).map(({ key }): string =>
-      String(objectRow[key]),
-    );
-  });
-}
-
-// Determine effective columns based on the input rows and optional columns parameter
-export function columnsToStringArray({ rows, columns = [] }: Table): string[] {
-  const firstRow = rows.at(0);
-  const primitiveRows = Array.isArray(firstRow);
-
-  if (typeof columns.at(0) === 'string' && !primitiveRows) {
-    throw new Error('invalid union type. Caught by model parsing.');
-  }
-
-  if (columns.length === 0) {
-    if (Array.isArray(firstRow)) {
-      return (firstRow as unknown[]).map((_, idx) => String(idx));
-    }
-    return Object.keys(firstRow as object);
-  }
-
-  // columns = ['right', 'left']; row = ['100 ms', '200 ms'] => 1,2,3
-  if (typeof columns.at(0) === 'string') {
-    return columns.map(String);
-  }
-
-  // columns = [
-  // {key: 'prop1' label: 'Property 1'},
-  // {key: 'prop2'}
-  // ]; row = [ {prop1: '100 ms', prop2: '200 ms'}] => Property 1, Prop2
-  const cols = columns as TableColumnObject[];
-  return cols.map(({ label, key }) => label ?? capitalize(key));
-}
-
-export function getColumnAlignmentForKeyAndIndex(
-  targetKey: string,
-  targetIdx: number,
-  columns: TableColumnObject[] = [],
-): TableAlignment {
-  const column =
-    columns.at(targetIdx) ?? columns.find(col => col.key === targetKey);
-  if (typeof column === 'string') {
-    return column as TableAlignment;
-  } else if (typeof column === 'object') {
-    return column.align ?? 'center';
-  } else {
-    return 'center';
-  }
-}
-
-export function getColumnAlignmentForIndex(
-  targetIdx: number,
-  columns: TableColumnPrimitive[] = [],
-): TableAlignment {
-  const column = columns.at(targetIdx) as
-    | TableColumnObject
-    | TableAlignment
-    | undefined;
-  if (column == null) {
-    return 'center';
-  } else if (typeof column === 'string') {
-    return column as TableAlignment;
-  } else if (typeof column === 'object') {
-    return column.align ?? 'center';
-  } else {
-    return 'center';
-  }
-}
-
-export function getColumnAlignments({
-  rows,
-  columns = [],
-}: Table): TableAlignment[] {
-  // this is caught by the table schema in @code-pushup/models
-  if (rows.at(0) == null) {
-    throw new Error('first row can`t be undefined.');
-  }
-
-  if (Array.isArray(rows.at(0))) {
-    const firstPrimitiveRow = rows.at(0) as PrimitiveValue[];
-    return Array.from({ length: firstPrimitiveRow.length }).map((_, idx) =>
-      getColumnAlignmentForIndex(idx, columns as TableColumnPrimitive[]),
-    );
-  }
-
-  const firstObject = rows.at(0) as Record<string, unknown>;
-  return Object.keys(firstObject).map((key, idx) =>
-    getColumnAlignmentForKeyAndIndex(key, idx, columns as TableColumnObject[]),
-  );
-}
diff --git a/packages/utils/src/lib/table.unit.test.ts b/packages/utils/src/lib/table.unit.test.ts
deleted file mode 100644
index bb7ca2c72..000000000
--- a/packages/utils/src/lib/table.unit.test.ts
+++ /dev/null
@@ -1,176 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { TableRowObject } from '@code-pushup/models';
-import {
-  columnsToStringArray,
-  getColumnAlignmentForIndex,
-  getColumnAlignmentForKeyAndIndex,
-  getColumnAlignments,
-  rowToStringArray,
-} from './table';
-
-describe('columnToStringArray', () => {
-  it('should index primitive rows', () => {
-    expect(
-      columnsToStringArray({
-        rows: [['a', 'b', 'c']],
-      }),
-    ).toStrictEqual(['0', '1', '2']);
-  });
-
-  it('should take keys as column heading', () => {
-    expect(
-      columnsToStringArray({
-        rows: [{ prop1: 'prop value', prop2: 42 }],
-      }),
-    ).toStrictEqual(['prop1', 'prop2']);
-  });
-
-  it('should take keys defined in columns', () => {
-    expect(
-      columnsToStringArray({
-        columns: [{ key: 'slug' }],
-        rows: [{ slug: 'my-slug', value: 'my value' }],
-      }),
-    ).toStrictEqual(['Slug']);
-  });
-
-  it('should take labels defined in columns', () => {
-    expect(
-      columnsToStringArray({
-        columns: [{ key: 'value', label: 'Value' }],
-        rows: [{ slug: 'my-slug', value: 'my value' }],
-      }),
-    ).toStrictEqual(['Value']);
-  });
-
-  it('should only output headings row the present rows', () => {
-    expect(
-      columnsToStringArray({
-        columns: [{ key: 'value', label: 'Value' }],
-        rows: [{ slug: 'my-slug', value: 'my value' }],
-      }),
-    ).toStrictEqual(['Value']);
-  });
-});
-
-describe('rowToStringArray', () => {
-  it('turns row of primitive values row to a string array', () => {
-    expect(rowToStringArray({ rows: [[1, 2, 3]] })).toStrictEqual([
-      ['1', '2', '3'],
-    ]);
-  });
-
-  it('turns row of object row to a string array', () => {
-    expect(
-      rowToStringArray({
-        rows: [
-          {
-            prop1: 1,
-            prop2: 2,
-            prop3: 3,
-          },
-        ],
-      }),
-    ).toStrictEqual([['1', '2', '3']]);
-  });
-
-  it('turns row of object row defined by headings to a string array', () => {
-    expect(
-      rowToStringArray({
-        rows: [
-          {
-            prop1: 1,
-            prop2: 2,
-            prop3: 3,
-          },
-        ],
-        columns: [{ key: 'prop2' }],
-      }),
-    ).toStrictEqual([['2']]);
-  });
-});
-
-describe('getColumnAlignmentForKey', () => {
-  it('return center align for a key and no heading definitions', () => {
-    expect(getColumnAlignmentForKeyAndIndex('value', 0)).toBe('center');
-  });
-
-  it('return center align for a key and heading definitions without align', () => {
-    expect(
-      getColumnAlignmentForKeyAndIndex('value', 0, [
-        { key: 'value' },
-        { key: 'other-prop' },
-      ]),
-    ).toBe('center');
-  });
-
-  it('return defined align for a key', () => {
-    expect(
-      getColumnAlignmentForKeyAndIndex('value', 0, [
-        { key: 'value', align: 'left' },
-        { key: 'other-prop' },
-      ]),
-    ).toBe('left');
-  });
-});
-
-describe('getColumnAlignmentForIndex', () => {
-  it('return center align for a index and no heading definitions', () => {
-    expect(getColumnAlignmentForIndex(60)).toBe('center');
-  });
-
-  it('return center align for a index and heading definitions without align', () => {
-    expect(getColumnAlignmentForIndex(1, ['left'])).toBe('center');
-  });
-
-  it('return defined align for a index', () => {
-    expect(getColumnAlignmentForIndex(0, ['left'])).toBe('left');
-  });
-});
-
-describe('getColumnAlignments', () => {
-  it('return center align for primitive rows without heading definitions', () => {
-    expect(getColumnAlignments({ rows: [[1, 2, 3]] })).toStrictEqual([
-      'center',
-      'center',
-      'center',
-    ]);
-  });
-
-  it('return align for primitive rows and heading definitions', () => {
-    expect(
-      getColumnAlignments({ rows: [[1, 2, 3]], columns: ['left'] }),
-    ).toStrictEqual(['left', 'center', 'center']);
-  });
-
-  it('return center align for object rows without heading definitions', () => {
-    expect(
-      getColumnAlignments({
-        rows: [
-          { value: 1, name: 'first' },
-          { value: 2, name: 'second' },
-          { value: 3, name: 'third' },
-        ],
-      }),
-    ).toStrictEqual(['center', 'center']);
-  });
-
-  it('return accept align for object rows and heading definitions', () => {
-    expect(
-      getColumnAlignments({
-        rows: [
-          { value: 1, name: 'first' },
-          { value: 2, name: 'second' },
-          { value: 3, name: 'third' },
-        ],
-        columns: [{ key: 'value', align: 'left' }],
-      }),
-    ).toStrictEqual(['left', 'center']);
-  });
-
-  it('throws for a undefined row', () => {
-    expect(() =>
-      getColumnAlignments({ rows: [undefined as unknown as TableRowObject] }),
-    ).toThrow('first row can`t be undefined.');
-  });
-});
diff --git a/packages/utils/src/lib/text-formats/html/link.ts b/packages/utils/src/lib/text-formats/html/link.ts
index fd9a4ba92..25d763e10 100644
--- a/packages/utils/src/lib/text-formats/html/link.ts
+++ b/packages/utils/src/lib/text-formats/html/link.ts
@@ -1,3 +1,3 @@
 export function link(href: string, text?: string): string {
-  return `<a href="${href}">${text || href}"</a>`;
+  return `<a href="${href}">${text || href}</a>`;
 }
diff --git a/packages/utils/src/lib/text-formats/html/table.ts b/packages/utils/src/lib/text-formats/html/table.ts
index 7e50aece7..dd51c92fa 100644
--- a/packages/utils/src/lib/text-formats/html/table.ts
+++ b/packages/utils/src/lib/text-formats/html/table.ts
@@ -1,6 +1,6 @@
 import { Table } from '@code-pushup/models';
-import { columnsToStringArray, rowToStringArray } from '../../table';
 import { NEW_LINE } from '../constants';
+import { columnsToStringArray, rowToStringArray } from '../table';
 
 function wrap(elem: string, content: string): string {
   return `<${elem}>${content}</${elem}>${NEW_LINE}`;
diff --git a/packages/utils/src/lib/text-formats/md/section.ts b/packages/utils/src/lib/text-formats/md/section.ts
index 8f4757a4b..07f99ae90 100644
--- a/packages/utils/src/lib/text-formats/md/section.ts
+++ b/packages/utils/src/lib/text-formats/md/section.ts
@@ -4,6 +4,11 @@ export function section(...contents: (string | undefined | boolean)[]): string {
   return `${lines(...contents)}${NEW_LINE}`;
 }
 
-export function lines(...contents: (string | undefined | boolean)[]): string {
-  return `${contents.filter(Boolean).join(NEW_LINE)}`;
+export function lines(
+  ...contents: (string | undefined | boolean | number)[]
+): string {
+  const filteredContent = contents.filter(
+    value => value != null && value !== '' && value !== false,
+  );
+  return `${filteredContent.join(NEW_LINE)}`;
 }
diff --git a/packages/utils/src/lib/text-formats/md/table.ts b/packages/utils/src/lib/text-formats/md/table.ts
index 9599f62ed..175a8876c 100644
--- a/packages/utils/src/lib/text-formats/md/table.ts
+++ b/packages/utils/src/lib/text-formats/md/table.ts
@@ -3,7 +3,7 @@ import {
   columnsToStringArray,
   getColumnAlignments,
   rowToStringArray,
-} from '../../table';
+} from '../table';
 import { lines, section } from './section';
 
 const alignString = new Map<TableAlignment, string>([
diff --git a/packages/utils/src/lib/text-formats/md/table.unit.test.ts b/packages/utils/src/lib/text-formats/md/table.unit.test.ts
index 179d27718..ab1c057c0 100644
--- a/packages/utils/src/lib/text-formats/md/table.unit.test.ts
+++ b/packages/utils/src/lib/text-formats/md/table.unit.test.ts
@@ -2,7 +2,12 @@ import { Table } from '@code-pushup/models';
 import { table } from './table';
 
 describe('MD table', () => {
-  it('should create a table with center alignment by default', () => {
+  it('should throw for empty data', () => {
+    const data: Table = { rows: [] };
+    expect(() => table(data)).toThrow("Data can't be empty");
+  });
+
+  it('should have a default alignment of "center"', () => {
     const data: Table = { rows: [[1, 2]] };
     const result = table(data);
     expect(result).toMatch('|:--:|:--:|');
@@ -17,11 +22,6 @@ describe('MD table', () => {
     expect(result).toMatch('|:--|:--:|--:|');
   });
 
-  it('should throw for empty data', () => {
-    const data: Table = { rows: [] };
-    expect(() => table(data)).toThrow("Data can't be empty");
-  });
-
   it('should create a table from primitive values', () => {
     const data: Table = { rows: [['Value 1', 'Value 2']] };
     const result = table(data);
@@ -35,11 +35,15 @@ describe('MD table', () => {
         { key: 'col1', label: 'Header 1' },
         { key: 'col2', label: 'Header 2' },
       ],
-      rows: [{ col1: '11', col2: '12' }],
+      rows: [
+        { col1: '1a', col2: '2a' },
+        { col1: '1b', col2: '2b' },
+      ],
     };
     const result = table(data);
     expect(result).toMatch('|Header 1|Header 2|');
-    expect(result).toMatch('|11|12|');
+    expect(result).toMatch('|1a|2a|');
+    expect(result).toMatch('|1b|2b|');
   });
 
   it('should create a complete table', () => {
@@ -47,13 +51,17 @@ describe('MD table', () => {
       columns: [
         { key: 'date', label: 'Date of Action', align: 'right' },
         { key: 'time', label: 'Time of Action', align: 'left' },
-        { key: 'action', label: 'Action', align: 'center' },
+        { key: 'action', label: 'Action' },
+      ],
+      rows: [
+        { date: '2025.01.01', time: '00:00:00', action: 'add item' },
+        { date: '2025.01.02' },
       ],
-      rows: [{ date: '2025.01.01', time: '00:00:00', action: 'add item' }],
     };
     const result = table(data);
     expect(result).toMatch('|Date of Action|Time of Action|Action|');
     expect(result).toMatch('|--:|:--|:--:|');
     expect(result).toMatch('|2025.01.01|00:00:00|add item|');
+    expect(result).toMatch('|2025.01.02|||');
   });
 });
diff --git a/packages/utils/src/lib/text-formats/table.ts b/packages/utils/src/lib/text-formats/table.ts
index 34e643765..98574562b 100644
--- a/packages/utils/src/lib/text-formats/table.ts
+++ b/packages/utils/src/lib/text-formats/table.ts
@@ -1,7 +1,7 @@
 import {
-  PrimitiveValue,
   Table,
   TableAlignment,
+  TableCellValue,
   TableColumnObject,
   TableColumnPrimitive,
 } from '@code-pushup/models';
@@ -23,20 +23,25 @@ export function rowToStringArray({ rows, columns = [] }: Table): string[][] {
     // row = { prop1: '100 ms', prop2: '200 ms' }
     const objectRow = row;
 
-    // columns [] || column = 'center'
+    // columns [] || column.at(0) = 'center'
     if (columns.length === 0 || typeof columns.at(0) === 'string') {
-      return Object.values(objectRow).map(String);
+      return Object.values(objectRow).map(value =>
+        value == null ? '' : String(value),
+      );
     }
 
     // column = {key: 'prop1'}
     return (columns as TableColumnObject[]).map(({ key }): string =>
-      String(objectRow[key]),
+      objectRow[key] == null ? '' : String(objectRow[key]),
     );
   });
 }
 
 // Determine effective columns based on the input rows and optional columns parameter
-export function columnsToStringArray({ rows, columns = [] }: Table): string[] {
+export function columnsToStringArray({
+  rows,
+  columns = [],
+}: Pick<Table, 'columns' | 'rows'>): string[] {
   const firstRow = rows.at(0);
   const primitiveRows = Array.isArray(firstRow);
 
@@ -46,7 +51,7 @@ export function columnsToStringArray({ rows, columns = [] }: Table): string[] {
 
   if (columns.length === 0) {
     if (Array.isArray(firstRow)) {
-      return (firstRow as unknown[]).map((_, idx) => String(idx));
+      return firstRow.map((_, idx) => String(idx));
     }
     return Object.keys(firstRow as object);
   }
@@ -99,24 +104,35 @@ export function getColumnAlignmentForIndex(
   }
 }
 
-export function getColumnAlignments({
-  rows,
-  columns = [],
-}: Table): TableAlignment[] {
+export function getColumnAlignments(tableData: Table): TableAlignment[] {
+  const { rows, columns = [] } = tableData;
+
   // this is caught by the table schema in @code-pushup/models
   if (rows.at(0) == null) {
     throw new Error('first row can`t be undefined.');
   }
 
   if (Array.isArray(rows.at(0))) {
-    const firstPrimitiveRow = rows.at(0) as PrimitiveValue[];
+    const firstPrimitiveRow = rows.at(0) as TableCellValue[];
     return Array.from({ length: firstPrimitiveRow.length }).map((_, idx) =>
       getColumnAlignmentForIndex(idx, columns as TableColumnPrimitive[]),
     );
   }
 
-  const firstObject = rows.at(0) as Record<string, unknown>;
-  return Object.keys(firstObject).map((key, idx) =>
-    getColumnAlignmentForKeyAndIndex(key, idx, columns as TableColumnObject[]),
-  );
+  const biggestRow = [...rows]
+    .sort((a, b) => Object.keys(a).length - Object.keys(b).length)
+    .at(-1);
+  if (columns.length > 0) {
+    return columns.map((column, idx) =>
+      typeof column === 'string'
+        ? column
+        : getColumnAlignmentForKeyAndIndex(
+            column.key,
+            idx,
+            columns as TableColumnObject[],
+          ),
+    );
+  }
+
+  return Object.keys(biggestRow ?? {}).map(_ => 'center');
 }
diff --git a/packages/utils/src/lib/text-formats/table.unit.test.ts b/packages/utils/src/lib/text-formats/table.unit.test.ts
index bb7ca2c72..5fc8b75a5 100644
--- a/packages/utils/src/lib/text-formats/table.unit.test.ts
+++ b/packages/utils/src/lib/text-formats/table.unit.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { TableRowObject } from '@code-pushup/models';
+import { Table, TableRowObject } from '@code-pushup/models';
 import {
   columnsToStringArray,
   getColumnAlignmentForIndex,
@@ -8,6 +8,73 @@ import {
   rowToStringArray,
 } from './table';
 
+describe('rowToStringArray', () => {
+  it('should throw if data shape is incorrect', () => {
+    expect(() =>
+      rowToStringArray({
+        columns: [{ key: 'prop' }],
+        rows: [[1, 2, 3]],
+      } as unknown as Table),
+    ).toThrow('Column can`t be object when rows are primitive values');
+  });
+
+  it('should transform row of primitive values row to a string array', () => {
+    expect(
+      rowToStringArray({
+        rows: [
+          [1, 2, 3],
+          ['a', 'b', 'c'],
+        ],
+      }),
+    ).toStrictEqual([
+      ['1', '2', '3'],
+      ['a', 'b', 'c'],
+    ]);
+  });
+
+  it('should transform row of object row to a string array', () => {
+    expect(
+      rowToStringArray({
+        rows: [
+          {
+            prop1: 1,
+            prop2: 2,
+            prop3: 3,
+          },
+          {
+            prop1: 'a',
+            prop2: 'b',
+            prop3: 'c',
+          },
+        ],
+      }),
+    ).toStrictEqual([
+      ['1', '2', '3'],
+      ['a', 'b', 'c'],
+    ]);
+  });
+
+  it('should transform row of object row defined by headings to a string array', () => {
+    expect(
+      rowToStringArray({
+        rows: [
+          {
+            prop1: 1,
+            prop2: 2,
+            prop3: 3,
+          },
+          {
+            prop1: 'a',
+            prop2: 'b',
+            prop3: 'c',
+          },
+        ],
+        columns: [{ key: 'prop2' }],
+      }),
+    ).toStrictEqual([['2'], ['b']]);
+  });
+});
+
 describe('columnToStringArray', () => {
   it('should index primitive rows', () => {
     expect(
@@ -53,43 +120,6 @@ describe('columnToStringArray', () => {
   });
 });
 
-describe('rowToStringArray', () => {
-  it('turns row of primitive values row to a string array', () => {
-    expect(rowToStringArray({ rows: [[1, 2, 3]] })).toStrictEqual([
-      ['1', '2', '3'],
-    ]);
-  });
-
-  it('turns row of object row to a string array', () => {
-    expect(
-      rowToStringArray({
-        rows: [
-          {
-            prop1: 1,
-            prop2: 2,
-            prop3: 3,
-          },
-        ],
-      }),
-    ).toStrictEqual([['1', '2', '3']]);
-  });
-
-  it('turns row of object row defined by headings to a string array', () => {
-    expect(
-      rowToStringArray({
-        rows: [
-          {
-            prop1: 1,
-            prop2: 2,
-            prop3: 3,
-          },
-        ],
-        columns: [{ key: 'prop2' }],
-      }),
-    ).toStrictEqual([['2']]);
-  });
-});
-
 describe('getColumnAlignmentForKey', () => {
   it('return center align for a key and no heading definitions', () => {
     expect(getColumnAlignmentForKeyAndIndex('value', 0)).toBe('center');
@@ -129,7 +159,7 @@ describe('getColumnAlignmentForIndex', () => {
 });
 
 describe('getColumnAlignments', () => {
-  it('return center align for primitive rows without heading definitions', () => {
+  it('return center alignments for primitive rows without heading definitions', () => {
     expect(getColumnAlignments({ rows: [[1, 2, 3]] })).toStrictEqual([
       'center',
       'center',
@@ -137,13 +167,13 @@ describe('getColumnAlignments', () => {
     ]);
   });
 
-  it('return align for primitive rows and heading definitions', () => {
+  it('return alignments for primitive rows and heading definitions', () => {
     expect(
       getColumnAlignments({ rows: [[1, 2, 3]], columns: ['left'] }),
     ).toStrictEqual(['left', 'center', 'center']);
   });
 
-  it('return center align for object rows without heading definitions', () => {
+  it('return center alignments for object rows without heading definitions', () => {
     expect(
       getColumnAlignments({
         rows: [
@@ -155,7 +185,7 @@ describe('getColumnAlignments', () => {
     ).toStrictEqual(['center', 'center']);
   });
 
-  it('return accept align for object rows and heading definitions', () => {
+  it('return accept alignments for object rows and heading definitions', () => {
     expect(
       getColumnAlignments({
         rows: [
@@ -163,11 +193,19 @@ describe('getColumnAlignments', () => {
           { value: 2, name: 'second' },
           { value: 3, name: 'third' },
         ],
-        columns: [{ key: 'value', align: 'left' }],
+        columns: [{ key: 'value', align: 'left' }, { key: 'name' }],
       }),
     ).toStrictEqual(['left', 'center']);
   });
 
+  it('return alignments for biggest row if columns are missing', () => {
+    expect(
+      getColumnAlignments({
+        rows: [{ value: 1 }, { value: 1, prop2: 42 }],
+      }),
+    ).toStrictEqual(['center', 'center']);
+  });
+
   it('throws for a undefined row', () => {
     expect(() =>
       getColumnAlignments({ rows: [undefined as unknown as TableRowObject] }),