@zeropress/build-core 0.5.2 → 0.6.2

package/src/index.d.ts

@@ -1,4 +1,4 @@
-import type { PreviewDataV05 } from '@zeropress/preview-data-validator';
+import type { PreviewDataV06 } from '@zeropress/preview-data-validator';
 import type { ThemeManifest } from '@zeropress/theme-validator';
 
 export interface ThemePackage {
@@ -28,6 +28,7 @@ export interface BuildOptions {
     png?: string;
     apple_touch_icon?: string;
   };
+  sitemapStylesheetHref?: string;
   generateSpecialFiles?: boolean;
   generateRobotsTxt?: boolean;
   writeManifest?: boolean;
@@ -51,14 +52,14 @@ export interface BuildSiteResult {
 }
 
 export function buildSite(input: {
-  previewData: PreviewDataV05;
+  previewData: PreviewDataV06;
   themePackage: ThemePackage;
   writer: BuildWriter;
   options?: BuildOptions;
 }): Promise<BuildSiteResult>;
 
 export function buildSiteFromThemeDir(input: {
-  previewData: PreviewDataV05;
+  previewData: PreviewDataV06;
   themeDir: string;
   writer: BuildWriter;
   options?: BuildOptions;

package/src/render/content-renderer.js

@@ -306,6 +306,7 @@ function sanitizeHtml(html) {
     'a', 'img',
     'ul', 'ol', 'li',
     'blockquote', 'aside',
+    'figure', 'figcaption', 'picture', 'source',
     'table', 'thead', 'tbody', 'tr', 'th', 'td',
     'div', 'span', 'nav',
     'iframe', 'input',
@@ -314,9 +315,10 @@ function sanitizeHtml(html) {
   const allowedAttributes = {
     a: new Set(['href', 'title', 'class', 'id']),
     aside: new Set(['role', 'class', 'id']),
-    img: new Set(['src', 'alt', 'title', 'class', 'id', 'width', 'height']),
+    img: new Set(['src', 'srcset', 'sizes', 'alt', 'title', 'class', 'id', 'width', 'height', 'loading', 'decoding']),
     iframe: new Set(['src', 'width', 'height', 'frameborder', 'allowfullscreen', 'class']),
     input: new Set(['type', 'checked', 'disabled', 'class', 'id']),
+    source: new Set(['src', 'srcset', 'sizes', 'type', 'media', 'width', 'height', 'class', 'id']),
     '*': new Set(['class', 'id']),
   };
 
@@ -357,6 +359,10 @@ function sanitizeHtml(html) {
           continue;
         }
 
+        if (attributeName === 'srcset' && !isSafeSrcset(attributeValue, safeUriPattern)) {
+          continue;
+        }
+
         if (normalizedTag === 'input' && attributeName === 'type' && attributeValue !== 'checkbox') {
           continue;
         }
@@ -365,7 +371,7 @@ function sanitizeHtml(html) {
       }
     }
 
-    const isSelfClosing = match.endsWith('/>') || normalizedTag === 'br' || normalizedTag === 'hr' || normalizedTag === 'img' || normalizedTag === 'input';
+    const isSelfClosing = match.endsWith('/>') || normalizedTag === 'br' || normalizedTag === 'hr' || normalizedTag === 'img' || normalizedTag === 'input' || normalizedTag === 'source';
     const attributeSuffix = filteredAttributes.length > 0 ? ` ${filteredAttributes.join(' ')}` : '';
     return isSelfClosing ? `<${normalizedTag}${attributeSuffix} />` : `<${normalizedTag}${attributeSuffix}>`;
   });
@@ -382,6 +388,18 @@ function sanitizeHtml(html) {
     .join('');
 }
 
+function isSafeSrcset(value, safeUriPattern) {
+  const candidates = String(value)
+    .split(',')
+    .map((candidate) => candidate.trim())
+    .filter(Boolean);
+
+  return candidates.length > 0 && candidates.every((candidate) => {
+    const [url] = candidate.split(/\s+/);
+    return Boolean(url) && safeUriPattern.test(url);
+  });
+}
+
 function slugify(value) {
   return String(value || '')
     .toLowerCase()

package/src/render/control-flow-renderer.js

@@ -3,7 +3,145 @@ import { parsePartialToken } from './partial-resolver.js';
 const PATH_SEGMENT_SOURCE = '[a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)*';
 const PATH_REGEX = new RegExp(`^${PATH_SEGMENT_SOURCE}(?:\\.${PATH_SEGMENT_SOURCE})*$`);
 const FOR_EXPRESSION_REGEX = new RegExp(`^([a-zA-Z_][a-zA-Z0-9_]*)\\s+in\\s+(${PATH_SEGMENT_SOURCE}(?:\\.${PATH_SEGMENT_SOURCE})*)$`);
-const IF_EQ_EXPRESSION_REGEX = new RegExp(`^(${PATH_SEGMENT_SOURCE}(?:\\.${PATH_SEGMENT_SOURCE})*)\\s+("(?:[^"\\\\]|\\\\.)*")$`);
+const NUMBER_LITERAL_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+const COMPARISON_BLOCK_TAGS = new Set(['if_eq', 'if_neq', 'if_in', 'if_starts_with']);
+const COMPARISON_ELSE_IF_TAGS = new Set(['else_if_eq', 'else_if_neq', 'else_if_in', 'else_if_starts_with']);
+const COMPARISON_TAG_OPERATORS = {
+  if_eq: 'eq',
+  else_if_eq: 'eq',
+  if_neq: 'neq',
+  else_if_neq: 'neq',
+  if_in: 'in',
+  else_if_in: 'in',
+  if_starts_with: 'starts_with',
+  else_if_starts_with: 'starts_with',
+};
+const PARTIAL_ARG_ROOT_PATHS = new Set([
+  'archive',
+  'author',
+  'category',
+  'collection',
+  'collections',
+  'currentUrl',
+  'language',
+  'menu',
+  'menus',
+  'meta',
+  'page',
+  'pagination',
+  'partial',
+  'post',
+  'posts',
+  'route',
+  'site',
+  'tag',
+  'taxonomies',
+  'taxonomy',
+  'widget',
+  'widgets',
+]);
+
+function getComparisonBlockTag(token) {
+  for (const tagName of COMPARISON_BLOCK_TAGS) {
+    if (token.startsWith(`#${tagName} `)) {
+      return tagName;
+    }
+  }
+  return '';
+}
+
+function getComparisonElseIfTag(token) {
+  for (const tagName of COMPARISON_ELSE_IF_TAGS) {
+    if (token.startsWith(`#${tagName} `)) {
+      return tagName;
+    }
+  }
+  return '';
+}
+
+function tokenizeExpression(expression) {
+  const tokens = [];
+  let index = 0;
+
+  while (index < expression.length) {
+    while (/\s/.test(expression[index] || '')) {
+      index += 1;
+    }
+    if (index >= expression.length) {
+      break;
+    }
+
+    if (expression[index] === '"') {
+      const start = index;
+      index += 1;
+      let escaped = false;
+      while (index < expression.length) {
+        const char = expression[index];
+        if (escaped) {
+          escaped = false;
+        } else if (char === '\\') {
+          escaped = true;
+        } else if (char === '"') {
+          index += 1;
+          tokens.push(expression.slice(start, index));
+          break;
+        }
+        index += 1;
+      }
+      if (tokens[tokens.length - 1] !== expression.slice(start, index)) {
+        throw new Error(`Unclosed string literal in expression: ${expression}`);
+      }
+      continue;
+    }
+
+    const start = index;
+    while (index < expression.length && !/\s/.test(expression[index])) {
+      index += 1;
+    }
+    tokens.push(expression.slice(start, index));
+  }
+
+  return tokens;
+}
+
+function parsePathOperand(token, tagName, expression) {
+  if (!PATH_REGEX.test(token)) {
+    throw new Error(`Invalid ${tagName} expression: ${expression}`);
+  }
+  return { kind: 'path', path: token };
+}
+
+function parseComparisonOperand(token, tagName, expression) {
+  if (token.startsWith('"')) {
+    try {
+      const value = JSON.parse(token);
+      if (typeof value !== 'string') {
+        throw new Error('Expected string literal');
+      }
+      return { kind: 'literal', value };
+    } catch {
+      throw new Error(`Invalid ${tagName} expression: ${expression}`);
+    }
+  }
+
+  if (token === 'true') {
+    return { kind: 'literal', value: true };
+  }
+  if (token === 'false') {
+    return { kind: 'literal', value: false };
+  }
+  if (token === 'null') {
+    return { kind: 'literal', value: null };
+  }
+  if (NUMBER_LITERAL_REGEX.test(token)) {
+    return { kind: 'literal', value: Number(token) };
+  }
+  if (PATH_REGEX.test(token)) {
+    return { kind: 'path', path: token };
+  }
+
+  throw new Error(`Invalid ${tagName} expression: ${expression}`);
+}
 
 export class ControlFlowRenderer {
   constructor(options = {}) {
@@ -34,7 +172,7 @@ export class ControlFlowRenderer {
 
   parse(template) {
     const source = String(template || '');
-    const { nodes, nextIndex, stopTag } = this.parseNodes(source, 0, new Set());
+    const { nodes, nextIndex, stopTag } = this.parseNodes(source, 0, new Set(), PARTIAL_ARG_ROOT_PATHS);
     if (stopTag) {
       throw new Error(`Unexpected closing tag ${stopTag}`);
     }
@@ -44,7 +182,7 @@ export class ControlFlowRenderer {
     return nodes;
   }
 
-  parseNodes(source, startIndex, stopTags) {
+  parseNodes(source, startIndex, stopTags, partialArgScope) {
     const nodes = [];
     let index = startIndex;
 
@@ -104,9 +242,10 @@ export class ControlFlowRenderer {
         return { nodes, nextIndex: tokenEnd + 2, stopTag: 'else' };
       }
 
-      if (token.startsWith('#else_if_eq ')) {
-        if (!stopTags.has('else_if_eq')) {
-          throw new Error('Unexpected else_if_eq tag');
+      const comparisonElseIfTag = getComparisonElseIfTag(token);
+      if (comparisonElseIfTag) {
+        if (!stopTags.has(comparisonElseIfTag)) {
+          throw new Error(`Unexpected ${comparisonElseIfTag} tag`);
         }
         return { nodes, nextIndex: tokenEnd + 2, stopTag: token };
       }
@@ -119,15 +258,16 @@ export class ControlFlowRenderer {
       }
 
       if (token.startsWith('partial:')) {
-        const { name, args } = parsePartialToken(token);
+        const { name, args } = parsePartialToken(token, { allowedSingleSegmentPaths: partialArgScope });
         nodes.push({ type: 'partial', name, args });
         index = tokenEnd + 2;
         continue;
       }
 
-      if (token.startsWith('#if_eq ')) {
-        const expression = token.slice('#if_eq '.length).trim();
-        const block = this.parseIfEqBlock(source, tokenEnd + 2, expression);
+      const comparisonBlockTag = getComparisonBlockTag(token);
+      if (comparisonBlockTag) {
+        const expression = token.slice(`#${comparisonBlockTag} `.length).trim();
+        const block = this.parseComparisonBlock(source, tokenEnd + 2, comparisonBlockTag, expression, partialArgScope);
         nodes.push(block.node);
         index = block.nextIndex;
         continue;
@@ -135,7 +275,7 @@ export class ControlFlowRenderer {
 
       if (token.startsWith('#if ')) {
         const expression = token.slice('#if '.length).trim();
-        const block = this.parseIfBlock(source, tokenEnd + 2, expression);
+        const block = this.parseIfBlock(source, tokenEnd + 2, expression, partialArgScope);
         nodes.push(block.node);
         index = block.nextIndex;
         continue;
@@ -148,7 +288,8 @@ export class ControlFlowRenderer {
           throw new Error(`Invalid for expression: ${expression}`);
         }
         const [, itemName, path] = match;
-        const forResult = this.parseNodes(source, tokenEnd + 2, new Set(['for']));
+        const forScope = new Set([...partialArgScope, itemName, 'loop']);
+        const forResult = this.parseNodes(source, tokenEnd + 2, new Set(['for']), forScope);
         if (forResult.stopTag !== 'for') {
           throw new Error('Unclosed for block');
         }
@@ -169,7 +310,7 @@ export class ControlFlowRenderer {
     return { nodes, nextIndex: source.length, stopTag: null };
   }
 
-  parseIfBlock(source, startIndex, initialPath) {
+  parseIfBlock(source, startIndex, initialPath, partialArgScope) {
     if (!PATH_REGEX.test(initialPath)) {
       throw new Error(`Invalid if expression: ${initialPath}`);
     }
@@ -180,14 +321,14 @@ export class ControlFlowRenderer {
     let currentPath = initialPath;
 
     while (true) {
-      const branchResult = this.parseNodes(source, nextIndex, new Set(['else', 'else_if', 'if']));
+      const branchResult = this.parseNodes(source, nextIndex, new Set(['else', 'else_if', 'if']), partialArgScope);
       branches.push({
         path: currentPath,
         consequent: branchResult.nodes,
       });
 
       if (branchResult.stopTag === 'else') {
-        const elseResult = this.parseNodes(source, branchResult.nextIndex, new Set(['if']));
+        const elseResult = this.parseNodes(source, branchResult.nextIndex, new Set(['if']), partialArgScope);
         if (elseResult.stopTag !== 'if') {
           throw new Error('Unclosed if block after else');
         }
@@ -223,51 +364,53 @@ export class ControlFlowRenderer {
     };
   }
 
-  parseIfEqBlock(source, startIndex, expression) {
-    const initialBranch = this.parseIfEqBranchExpression(expression, 'if_eq');
+  parseComparisonBlock(source, startIndex, tagName, expression, partialArgScope) {
+    const initialBranch = this.parseComparisonBranchExpression(expression, tagName);
     const branches = [];
     let alternate = [];
     let nextIndex = startIndex;
     let currentBranch = initialBranch;
+    const elseIfTag = `else_${tagName}`;
 
     while (true) {
-      const branchResult = this.parseNodes(source, nextIndex, new Set(['else', 'else_if_eq', 'if_eq']));
+      const branchResult = this.parseNodes(source, nextIndex, new Set(['else', elseIfTag, tagName]), partialArgScope);
       branches.push({
-        path: currentBranch.path,
-        literal: currentBranch.literal,
+        operator: currentBranch.operator,
+        left: currentBranch.left,
+        operands: currentBranch.operands,
         consequent: branchResult.nodes,
       });
 
       if (branchResult.stopTag === 'else') {
-        const elseResult = this.parseNodes(source, branchResult.nextIndex, new Set(['if_eq']));
-        if (elseResult.stopTag !== 'if_eq') {
-          throw new Error('Unclosed if_eq block after else');
+        const elseResult = this.parseNodes(source, branchResult.nextIndex, new Set([tagName]), partialArgScope);
+        if (elseResult.stopTag !== tagName) {
+          throw new Error(`Unclosed ${tagName} block after else`);
         }
         alternate = elseResult.nodes;
         nextIndex = elseResult.nextIndex;
         break;
       }
 
-      if (typeof branchResult.stopTag === 'string' && branchResult.stopTag.startsWith('#else_if_eq ')) {
-        currentBranch = this.parseIfEqBranchExpression(
-          branchResult.stopTag.slice('#else_if_eq '.length).trim(),
-          'else_if_eq',
+      if (typeof branchResult.stopTag === 'string' && branchResult.stopTag.startsWith(`#${elseIfTag} `)) {
+        currentBranch = this.parseComparisonBranchExpression(
+          branchResult.stopTag.slice(`#${elseIfTag} `.length).trim(),
+          elseIfTag,
         );
         nextIndex = branchResult.nextIndex;
         continue;
       }
 
-      if (branchResult.stopTag === 'if_eq') {
+      if (branchResult.stopTag === tagName) {
         nextIndex = branchResult.nextIndex;
         break;
       }
 
-      throw new Error('Unclosed if_eq block');
+      throw new Error(`Unclosed ${tagName} block`);
     }
 
     return {
       node: {
-        type: 'if_eq',
+        type: 'comparison',
         branches,
         alternate,
       },
@@ -275,16 +418,23 @@ export class ControlFlowRenderer {
     };
   }
 
-  parseIfEqBranchExpression(expression, tagName) {
-    const match = IF_EQ_EXPRESSION_REGEX.exec(expression);
-    if (!match) {
+  parseComparisonBranchExpression(expression, tagName) {
+    const operator = COMPARISON_TAG_OPERATORS[tagName];
+    const tokens = tokenizeExpression(expression);
+    if (
+      !operator
+      || (operator === 'in' && tokens.length < 2)
+      || (operator !== 'in' && tokens.length !== 2)
+    ) {
       throw new Error(`Invalid ${tagName} expression: ${expression}`);
     }
 
-    const [, path, literalSource] = match;
+    const left = parsePathOperand(tokens[0], tagName, expression);
+    const operands = tokens.slice(1).map((token) => parseComparisonOperand(token, tagName, expression));
     return {
-      path,
-      literal: JSON.parse(literalSource),
+      operator,
+      left,
+      operands,
     };
   }
 
@@ -302,8 +452,8 @@ export class ControlFlowRenderer {
           ? this.renderNodes(branch.consequent, data, renderOptions)
           : this.renderNodes(node.alternate, data, renderOptions);
       }
-      case 'if_eq': {
-        const branch = node.branches.find((entry) => this.resolvePath(data, entry.path) === entry.literal);
+      case 'comparison': {
+        const branch = node.branches.find((entry) => this.evaluateComparison(entry, data));
         return branch
           ? this.renderNodes(branch.consequent, data, renderOptions)
           : this.renderNodes(node.alternate, data, renderOptions);
@@ -345,9 +495,13 @@ export class ControlFlowRenderer {
     }
 
     const partialTemplate = String(partials.get(node.name) || '');
+    const partialArgs = this.resolvePartialArgs(node.args, data);
     const partialData = {
       ...data,
-      partial: { ...node.args },
+      partial: {
+        ...(data?.partial && typeof data.partial === 'object' ? data.partial : {}),
+        ...partialArgs,
+      },
     };
 
     return this.renderTemplate(partialTemplate, partialData, {
@@ -356,6 +510,64 @@ export class ControlFlowRenderer {
     });
   }
 
+  resolvePartialArgs(args, data) {
+    const resolved = {};
+    for (const [key, operand] of Object.entries(args || {})) {
+      if (operand?.kind === 'literal') {
+        resolved[key] = operand.value;
+        continue;
+      }
+      if (operand?.kind === 'path') {
+        resolved[key] = this.resolvePath(data, operand.path);
+      }
+    }
+    return resolved;
+  }
+
+  evaluateComparison(entry, data) {
+    const left = this.evaluateOperand(entry.left, data);
+    const operands = entry.operands.map((operand) => this.evaluateOperand(operand, data));
+
+    if (entry.operator === 'eq') {
+      const right = operands[0];
+      return !left.missing && !right.missing && left.value === right.value;
+    }
+
+    if (entry.operator === 'neq') {
+      const right = operands[0];
+      return left.missing || right.missing || left.value !== right.value;
+    }
+
+    if (entry.operator === 'in') {
+      if (left.missing) {
+        return false;
+      }
+      return operands.some((operand) => !operand.missing && left.value === operand.value);
+    }
+
+    if (entry.operator === 'starts_with') {
+      const right = operands[0];
+      return (
+        !left.missing
+        && !right.missing
+        && typeof left.value === 'string'
+        && typeof right.value === 'string'
+        && left.value.startsWith(right.value)
+      );
+    }
+
+    return false;
+  }
+
+  evaluateOperand(operand, data) {
+    if (operand.kind === 'literal') {
+      return { value: operand.value, missing: false };
+    }
+
+    const value = this.resolvePath(data, operand.path);
+    return { value, missing: value === undefined };
+  }
+
   isTruthy(value) {
     if (Array.isArray(value)) {
       return value.length > 0;

package/src/render/partial-resolver.js

@@ -1,7 +1,10 @@
 const PARTIAL_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_-]*(?:\/[a-zA-Z_][a-zA-Z0-9_-]*)*$/;
 const IDENTIFIER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const PATH_SEGMENT_SOURCE = '[a-zA-Z_][a-zA-Z0-9_]*(?:-[a-zA-Z0-9_]+)*';
+const PATH_REGEX = new RegExp(`^${PATH_SEGMENT_SOURCE}(?:\\.${PATH_SEGMENT_SOURCE})*$`);
+const NUMBER_LITERAL_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
 
-export function parsePartialToken(token) {
+export function parsePartialToken(token, options = {}) {
   const source = String(token || '').trim();
   if (!source.startsWith('partial:')) {
     throw new Error(`Invalid partial token: ${source}`);
@@ -19,12 +22,12 @@ export function parsePartialToken(token) {
   }
 
   const argsSource = expression.slice(name.length).trim();
-  const args = parsePartialArgs(argsSource);
+  const args = parsePartialArgs(argsSource, options);
 
   return { name, args };
 }
 
-function parsePartialArgs(source) {
+function parsePartialArgs(source, options = {}) {
   if (!source) {
     return {};
   }
@@ -86,23 +89,47 @@ function parsePartialArgs(source) {
         throw new Error(`Unclosed string literal for partial argument "${key}"`);
       }
 
-      args[key] = JSON.parse(source.slice(index, cursor + 1));
+      args[key] = { kind: 'literal', value: JSON.parse(source.slice(index, cursor + 1)) };
       index = cursor + 1;
       continue;
     }
 
     if (source.startsWith('true', index) && isValueBoundary(source, index + 4)) {
-      args[key] = true;
+      args[key] = { kind: 'literal', value: true };
       index += 4;
       continue;
     }
 
     if (source.startsWith('false', index) && isValueBoundary(source, index + 5)) {
-      args[key] = false;
+      args[key] = { kind: 'literal', value: false };
       index += 5;
       continue;
     }
 
+    if (source.startsWith('null', index) && isValueBoundary(source, index + 4)) {
+      args[key] = { kind: 'literal', value: null };
+      index += 4;
+      continue;
+    }
+
+    const valueMatch = /^\S+/.exec(source.slice(index));
+    if (!valueMatch) {
+      throw new Error(`Missing partial argument value for "${key}"`);
+    }
+
+    const valueToken = valueMatch[0];
+    if (NUMBER_LITERAL_REGEX.test(valueToken)) {
+      args[key] = { kind: 'literal', value: Number(valueToken) };
+      index += valueToken.length;
+      continue;
+    }
+
+    if (PATH_REGEX.test(valueToken) && isAllowedPathArgument(valueToken, options)) {
+      args[key] = { kind: 'path', path: valueToken };
+      index += valueToken.length;
+      continue;
+    }
+
     throw new Error(`Unsupported partial argument value for "${key}"`);
   }
 
@@ -112,3 +139,12 @@ function parsePartialArgs(source) {
 function isValueBoundary(source, index) {
   return index >= source.length || /\s/.test(source[index]);
 }
+
+function isAllowedPathArgument(valueToken, options) {
+  if (valueToken.includes('.')) {
+    return true;
+  }
+
+  const allowedSingleSegmentPaths = options?.allowedSingleSegmentPaths;
+  return allowedSingleSegmentPaths instanceof Set && allowedSingleSegmentPaths.has(valueToken);
+}

package/src/render/variable-resolver.js

@@ -94,6 +94,10 @@ export class VariableResolver {
       }
     }
 
+    if (variablePath === 'data' || variablePath.startsWith('data.') || variablePath.includes('.data.')) {
+      return false;
+    }
+
     const lastSegment = variablePath.split('.').pop();
     if (lastSegment === 'html' || lastSegment?.endsWith('_html')) {
       return true;

package/src/render/zeropress-engine.js

@@ -37,7 +37,7 @@ export class ZeroPressEngine {
     const renderData = this.combineRenderData(data, context);
     const renderedContent = this.renderTemplate(template, renderData);
     const layoutWithSlots = this.slotResolver.resolve(layout, this.themePackage.partials, CONTENT_SLOT_PLACEHOLDER);
-    return this.renderTemplate(layoutWithSlots, renderData).replaceAll(CONTENT_SLOT_PLACEHOLDER, renderedContent);
+    return this.renderTemplate(layoutWithSlots, renderData).replaceAll(CONTENT_SLOT_PLACEHOLDER, () => renderedContent);
   }
 
   combineRenderData(data, context) {
@@ -50,7 +50,7 @@ export class ZeroPressEngine {
   }
 
   renderTemplate(template, data) {
-    if (this.themePackage?.metadata?.runtime !== '0.5') {
+    if (this.themePackage?.metadata?.runtime !== '0.6') {
       throw new Error(`Unsupported theme runtime: ${this.themePackage?.metadata?.runtime || 'unknown'}`);
     }