@open-agent-toolkit/cli 0.2.20 → 0.2.21

package/assets/skills/explainer-kit/scripts/lib/content-approval.mjs

@@ -2,9 +2,21 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
 import { writeJsonAtomic } from './fs-safe.mjs';
+import { loadRecipe, recipeFloor } from './recipes.mjs';
+import { validateSafeRelativePath } from './safe-paths.mjs';
 
 const APPROVAL_PATH = 'source/content-approval.json';
+const APPROVAL_SCHEMA_V1 = 'explainer-kit.content-approval/v1';
+const APPROVAL_SCHEMA_V2 = 'explainer-kit.content-approval/v2';
 const MODES = new Set(['interactive', 'unattended']);
+const STATUSES = new Set(['pending', 'approved', 'rejected']);
+const ORIGINS = new Set(['floor', 'expansion']);
+const AUTHORING_TYPES = new Set(['markdown', 'html']);
+const CONTENT_EXTENSIONS = new Map([
+  ['markdown', 'md'],
+  ['html', 'html'],
+]);
+const SAFE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const DECISIONS = new Map([
   ['approve', 'approved'],
   ['approved', 'approved'],
@@ -17,13 +29,20 @@ export async function resolveContentApproval(
   mode,
   reviewedSource,
   authorResultPaths,
+  artifacts,
 ) {
   assertRun(run);
   if (!MODES.has(mode)) {
     throw new Error('Content approval mode must be interactive or unattended.');
   }
+  if (artifacts !== undefined) {
+    assertArtifacts(artifacts);
+  }
+  if (authorResultPaths !== undefined) {
+    assertAuthorResultPaths(authorResultPaths);
+  }
 
-  const previous = await readPrevious(run);
+  const previous = await readContentApproval(run);
   let record;
   if (mode === 'unattended') {
     assertAuthorResultPaths(authorResultPaths);
@@ -31,31 +50,41 @@ export async function resolveContentApproval(
       reviewedSource ?? approvedSourceProvenance(run.request.factBase);
     assertProvenance(provenance);
     record = {
-      schemaVersion: 'explainer-kit.content-approval/v1',
+      schemaVersion: APPROVAL_SCHEMA_V2,
       runId: run.runId,
       mode,
       status: 'approved',
+      marking: 'auto-drafted',
       reviewedSource: structuredClone(provenance),
       authorResultPaths: [...authorResultPaths],
       attempts: previous?.attempts ?? [],
+      ...optionalArtifacts(artifacts ?? previous?.artifacts),
     };
   } else if (reviewedSource === undefined) {
     record = previous ?? {
-      schemaVersion: 'explainer-kit.content-approval/v1',
+      schemaVersion: APPROVAL_SCHEMA_V2,
       runId: run.runId,
       mode,
       status: 'pending',
       attempts: [],
     };
+    record = {
+      ...record,
+      ...optionalAuthorResultPaths(
+        authorResultPaths ?? previous?.authorResultPaths,
+      ),
+      ...optionalArtifacts(artifacts ?? previous?.artifacts),
+    };
   } else {
     const decision = normalizeDecision(reviewedSource.decision);
     const attempt = interactiveAttempt(reviewedSource, decision);
     record = {
-      schemaVersion: 'explainer-kit.content-approval/v1',
+      schemaVersion: APPROVAL_SCHEMA_V2,
       runId: run.runId,
       mode,
       status: decision,
       attempts: [...(previous?.attempts ?? []), attempt],
+      ...(decision === 'approved' && { marking: 'human-approved' }),
       ...(decision === 'approved' && {
         reviewedSource: structuredClone(
           reviewedSource.source ?? {
@@ -64,6 +93,10 @@ export async function resolveContentApproval(
           },
         ),
       }),
+      ...optionalAuthorResultPaths(
+        authorResultPaths ?? previous?.authorResultPaths,
+      ),
+      ...optionalArtifacts(artifacts ?? previous?.artifacts),
     };
     if (record.reviewedSource) {
       assertProvenance(record.reviewedSource);
@@ -79,24 +112,204 @@ export async function resolveContentApproval(
   };
 }
 
-async function readPrevious(run) {
+export async function readContentApproval(run) {
+  assertRun(run);
   try {
     const previous = JSON.parse(
       await readFile(join(run.runRoot, APPROVAL_PATH), 'utf8'),
     );
-    if (
-      previous.schemaVersion !== 'explainer-kit.content-approval/v1' ||
-      previous.runId !== run.runId
-    ) {
+    if (previous.runId !== run.runId) {
       throw new Error('Content approval record does not belong to this run.');
     }
-    return previous;
+    if (previous.schemaVersion === APPROVAL_SCHEMA_V1) {
+      return normalizeLegacyRecord(run, previous);
+    }
+    if (previous.schemaVersion !== APPROVAL_SCHEMA_V2) {
+      throw new Error('Content approval record has an unsupported version.');
+    }
+    assertApprovalRecord(previous);
+    return structuredClone(previous);
   } catch (error) {
     if (error?.code === 'ENOENT') return null;
     throw error;
   }
 }
 
+function normalizeLegacyRecord(run, previous) {
+  assertLegacyRecord(previous);
+  const marking =
+    previous.status === 'approved'
+      ? previous.mode === 'unattended'
+        ? 'auto-drafted'
+        : 'human-approved'
+      : undefined;
+  const record = {
+    schemaVersion: APPROVAL_SCHEMA_V2,
+    runId: previous.runId,
+    mode: previous.mode,
+    status: previous.status,
+    ...(marking && { marking }),
+    ...(previous.reviewedSource && {
+      reviewedSource: structuredClone(previous.reviewedSource),
+    }),
+    ...(previous.authorResultPaths && {
+      authorResultPaths: [...previous.authorResultPaths],
+    }),
+    attempts: structuredClone(previous.attempts),
+    artifacts: legacyFloorArtifacts(run, previous.authorResultPaths),
+  };
+  assertApprovalRecord(record);
+  return record;
+}
+
+function legacyFloorArtifacts(run, authorResultPaths = []) {
+  const recipe = loadRecipe(run.request.recipe.id, run.request.recipe.version);
+  const resultPaths = new Set(authorResultPaths);
+  return recipeFloor(recipe).map((artifact) => {
+    const authorResultPath = `source/author/${artifact.id}.json`;
+    const authoring = artifact.authoring ?? 'markdown';
+    return {
+      artifactId: artifact.id,
+      origin: 'floor',
+      authoring,
+      contentPath: contentPathFor(artifact.id, authoring),
+      ...(resultPaths.has(authorResultPath) && { authorResultPath }),
+    };
+  });
+}
+
+function contentPathFor(artifactId, authoring) {
+  const extension = CONTENT_EXTENSIONS.get(authoring);
+  if (!extension) {
+    throw new Error(`Unsupported content authoring mode: ${authoring}`);
+  }
+  return `source/content/${artifactId}.${extension}`;
+}
+
+function optionalArtifacts(artifacts) {
+  return artifacts === undefined
+    ? {}
+    : { artifacts: structuredClone(artifacts) };
+}
+
+function optionalAuthorResultPaths(paths) {
+  return paths === undefined
+    ? {}
+    : { authorResultPaths: structuredClone(paths) };
+}
+
+function assertLegacyRecord(record) {
+  if (
+    !isObject(record) ||
+    record.schemaVersion !== APPROVAL_SCHEMA_V1 ||
+    typeof record.runId !== 'string' ||
+    !MODES.has(record.mode) ||
+    !STATUSES.has(record.status) ||
+    !Array.isArray(record.attempts)
+  ) {
+    throw new Error('Legacy content approval record is malformed.');
+  }
+  if (record.reviewedSource !== undefined) {
+    assertProvenance(record.reviewedSource);
+  }
+  if (record.authorResultPaths !== undefined) {
+    assertAuthorResultPaths(record.authorResultPaths);
+  }
+}
+
+function assertApprovalRecord(record) {
+  if (
+    !isObject(record) ||
+    record.schemaVersion !== APPROVAL_SCHEMA_V2 ||
+    typeof record.runId !== 'string' ||
+    !MODES.has(record.mode) ||
+    !STATUSES.has(record.status) ||
+    !Array.isArray(record.attempts)
+  ) {
+    throw new Error('Content approval v2 record is malformed.');
+  }
+  const expectedMarking =
+    record.status !== 'approved'
+      ? undefined
+      : record.mode === 'unattended'
+        ? 'auto-drafted'
+        : 'human-approved';
+  if (record.marking !== expectedMarking) {
+    throw new Error('Content approval marking does not match mode and status.');
+  }
+  if (record.reviewedSource !== undefined) {
+    assertProvenance(record.reviewedSource);
+  }
+  if (record.authorResultPaths !== undefined) {
+    assertAuthorResultPaths(record.authorResultPaths);
+  }
+  if (record.artifacts !== undefined) {
+    assertArtifacts(record.artifacts);
+  }
+}
+
+function assertArtifacts(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error('Content approval artifacts must be a non-empty array.');
+  }
+  const artifactIds = new Set();
+  const contentPaths = new Set();
+  const authorResultPaths = new Set();
+  for (const artifact of value) {
+    const keys = Object.keys(artifact ?? {}).sort();
+    const expectedKeys = [
+      'artifactId',
+      'authoring',
+      'contentPath',
+      'origin',
+      ...(artifact?.profileId === undefined ? [] : ['profileId']),
+      ...(artifact?.authorResultPath === undefined ? [] : ['authorResultPath']),
+    ].sort();
+    if (
+      !isObject(artifact) ||
+      keys.length !== expectedKeys.length ||
+      keys.some((key, index) => key !== expectedKeys[index]) ||
+      !SAFE_ID.test(artifact.artifactId) ||
+      !ORIGINS.has(artifact.origin) ||
+      !AUTHORING_TYPES.has(artifact.authoring) ||
+      !validateSafeRelativePath(artifact.contentPath).valid
+    ) {
+      throw new Error('Content approval artifact entry is malformed.');
+    }
+    if (
+      (artifact.origin === 'expansion') !==
+      (typeof artifact.profileId === 'string' &&
+        SAFE_ID.test(artifact.profileId))
+    ) {
+      throw new Error(
+        'Expansion approval artifacts require a safe profileId, and floor artifacts forbid one.',
+      );
+    }
+    if (
+      artifact.authorResultPath !== undefined &&
+      (!validateSafeRelativePath(artifact.authorResultPath).valid ||
+        !/^source\/author\/[^/]+\.json$/.test(artifact.authorResultPath))
+    ) {
+      throw new Error('Content approval authorResultPath is malformed.');
+    }
+    if (
+      artifactIds.has(artifact.artifactId) ||
+      contentPaths.has(artifact.contentPath) ||
+      (artifact.authorResultPath !== undefined &&
+        authorResultPaths.has(artifact.authorResultPath))
+    ) {
+      throw new Error(
+        'Content approval artifact paths and ids must be unique.',
+      );
+    }
+    artifactIds.add(artifact.artifactId);
+    contentPaths.add(artifact.contentPath);
+    if (artifact.authorResultPath !== undefined) {
+      authorResultPaths.add(artifact.authorResultPath);
+    }
+  }
+}
+
 function interactiveAttempt(source, status) {
   if (!isObject(source)) {
     throw new TypeError('Interactive approval requires a review decision.');

package/assets/skills/explainer-kit/scripts/lib/contracts.mjs

@@ -12,8 +12,12 @@ const SCHEMA_FILES = {
   'durability-evidence': 'durability-evidence.schema.json',
   'publish-request': 'publish-request.schema.json',
   'publish-receipt': 'publish-receipt.schema.json',
-  'author-request': 'author-request.schema.json',
-  'author-result': 'author-result.schema.json',
+  'author-request/v2': 'author-request.v2.schema.json',
+  'author-result/v2': 'author-result.v2.schema.json',
+};
+const DEFAULT_SCHEMA_KEYS = {
+  'author-request': 'author-request/v2',
+  'author-result': 'author-result/v2',
 };
 
 const SCHEMAS = Object.fromEntries(
@@ -45,7 +49,7 @@ const DATE_TIME_PATTERN =
   /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
 
 export function validateContract(kind, value, context = {}) {
-  const schema = SCHEMAS[kind];
+  const schema = resolveContractSchema(kind, value);
   if (!schema) {
     return {
       valid: false,
@@ -67,6 +71,27 @@ export function validateContract(kind, value, context = {}) {
   return { valid: errors.length === 0, errors };
 }
 
+function resolveContractSchema(kind, value) {
+  if (SCHEMAS[kind]) {
+    return SCHEMAS[kind];
+  }
+  if (SCHEMAS_BY_ID.has(kind)) {
+    return SCHEMAS_BY_ID.get(kind);
+  }
+
+  const defaultKey = DEFAULT_SCHEMA_KEYS[kind];
+  if (!defaultKey) {
+    return null;
+  }
+
+  const declared = isObject(value)
+    ? SCHEMAS_BY_ID.get(value.schemaVersion)
+    : undefined;
+  return declared?.$id.startsWith(`explainer-kit.${kind}/`)
+    ? declared
+    : SCHEMAS[defaultKey];
+}
+
 export function canonicalHash(value) {
   return `sha256:${createHash('sha256')
     .update(canonicalStringify(value))
@@ -452,46 +477,6 @@ function validateCrossRecord(kind, value, context, errors) {
     }
   }
 
-  if (kind === 'author-request') {
-    const requiredNarrative = Array.isArray(value.recipe?.requiredNarrative)
-      ? value.recipe.requiredNarrative
-      : [];
-    const outlineIds = Array.isArray(value.narrativeOutline)
-      ? value.narrativeOutline.map((section) => section?.id)
-      : [];
-    if (
-      requiredNarrative.length !== outlineIds.length ||
-      requiredNarrative.some((id, index) => outlineIds[index] !== id)
-    ) {
-      add(
-        errors,
-        '$.narrativeOutline',
-        'narrative-outline-mismatch',
-        'Author request narrative outline must exactly match recipe requiredNarrative order.',
-      );
-    }
-  }
-
-  if (kind === 'author-result') {
-    for (const [index, section] of (Array.isArray(value.content?.sections)
-      ? value.content.sections
-      : []
-    ).entries()) {
-      if (
-        isObject(section) &&
-        typeof section.prose === 'string' &&
-        section.prose.trim().length === 0
-      ) {
-        add(
-          errors,
-          `$.content.sections[${index}].prose`,
-          'empty-prose',
-          'Authored section prose must contain non-whitespace text.',
-        );
-      }
-    }
-  }
-
   if (kind === 'manifest') {
     const paths = [];
     for (const artifact of Array.isArray(value.artifacts)

package/assets/skills/explainer-kit/scripts/lib/diagram.mjs

@@ -0,0 +1,237 @@
+const HEADER_PATTERN = /^graph\s+(TD|LR)$/;
+const ID_PATTERN = '[A-Za-z][A-Za-z0-9_-]*';
+const OPERAND_PATTERN = `${ID_PATTERN}(?:\\[(?:[^\\]"]|"[^"]*")*\\]|\\((?:[^\\)"]|"[^"]*")*\\)|\\{(?:[^\\}"]|"[^"]*")*\\})?`;
+const EDGE_PATTERN = new RegExp(
+  `^(${OPERAND_PATTERN})\\s*(-->|---)(?:\\|([^|]*)\\|)?\\s*(${OPERAND_PATTERN})$`,
+);
+const DECLARATION_PATTERN = new RegExp(`^${OPERAND_PATTERN}$`);
+const NODE_PATTERN = new RegExp(
+  `^(${ID_PATTERN})(?:\\[((?:[^\\]"]|"[^"]*")*)\\]|\\(((?:[^\\)"]|"[^"]*")*)\\)|\\{((?:[^\\}"]|"[^"]*")*)\\})?$`,
+);
+const UNSUPPORTED_PATTERN =
+  /^(?:subgraph|end\b|classDef\b|class\b|style\b|linkStyle\b|click\b|sequenceDiagram\b|stateDiagram(?:-v2)?\b|flowchart\b)/i;
+
+export function parseDiagram(source) {
+  if (typeof source !== 'string') {
+    throw new TypeError('Diagram source must be a string.');
+  }
+
+  const lines = source
+    .replaceAll('\r\n', '\n')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('%%'));
+  const header = lines.shift() ?? '';
+  const headerMatch = header.match(HEADER_PATTERN);
+  if (!headerMatch) {
+    return degraded(
+      /^(?:sequenceDiagram|stateDiagram|flowchart)/i.test(header)
+        ? `Unsupported diagram type: ${header || 'missing header'}.`
+        : 'Diagram must begin with “graph TD” or “graph LR”.',
+    );
+  }
+
+  const nodes = new Map();
+  const edges = [];
+  for (const line of lines) {
+    if (UNSUPPORTED_PATTERN.test(line)) {
+      return degraded(`Unsupported diagram construct: ${line}.`);
+    }
+
+    const edge = line.match(EDGE_PATTERN);
+    if (edge) {
+      const from = parseNode(edge[1]);
+      const to = parseNode(edge[4]);
+      if (!from || !to) return degraded(`Unsupported diagram syntax: ${line}.`);
+      registerNode(nodes, from);
+      registerNode(nodes, to);
+      edges.push({
+        from: from.id,
+        to: to.id,
+        kind: edge[2] === '-->' ? 'arrow' : 'line',
+        label: unquote(edge[3]?.trim() ?? ''),
+      });
+      continue;
+    }
+
+    if (DECLARATION_PATTERN.test(line)) {
+      const node = parseNode(line);
+      if (!node) return degraded(`Unsupported diagram syntax: ${line}.`);
+      registerNode(nodes, node);
+      continue;
+    }
+
+    return degraded(`Unsupported diagram syntax: ${line}.`);
+  }
+
+  if (nodes.size === 0) {
+    return degraded('Diagram requires at least one node declaration or edge.');
+  }
+
+  return {
+    valid: true,
+    direction: headerMatch[1],
+    nodes: [...nodes.values()],
+    edges,
+    warnings: [],
+  };
+}
+
+export function renderDiagram(source, { theme } = {}) {
+  const parsed = parseDiagram(source);
+  if (!parsed.valid) {
+    return {
+      html: `<div class="diagram-fallback" role="note"><p class="diagram-warning">${escapeHtml(parsed.warnings[0].message)}</p><pre><code>${escapeHtml(source)}</code></pre></div>`,
+      warnings: parsed.warnings,
+      degraded: true,
+    };
+  }
+
+  const horizontal = parsed.direction === 'LR';
+  const nodeWidth = 180;
+  const nodeHeight = 72;
+  const gap = 90;
+  const margin = 50;
+  const positions = new Map(
+    parsed.nodes.map((node, index) => [
+      node.id,
+      horizontal
+        ? { x: margin + index * (nodeWidth + gap), y: margin }
+        : { x: margin, y: margin + index * (nodeHeight + gap) },
+    ]),
+  );
+  const width = horizontal
+    ? margin * 2 +
+      parsed.nodes.length * nodeWidth +
+      (parsed.nodes.length - 1) * gap
+    : margin * 2 + nodeWidth;
+  const height = horizontal
+    ? margin * 2 + nodeHeight
+    : margin * 2 +
+      parsed.nodes.length * nodeHeight +
+      (parsed.nodes.length - 1) * gap;
+  const markerId = `diagram-arrow-${stableHash(source)}`;
+  const mode = theme?.modes?.[theme.defaultMode];
+  const panel = mode?.surface?.panel ?? '#ffffff';
+  const ink = mode?.ink?.primary ?? '#172033';
+  const accent = mode?.accent?.primary ?? '#365270';
+  const muted = mode?.ink?.muted ?? '#526071';
+  const edges = parsed.edges
+    .map((edge) =>
+      renderEdge(edge, positions, {
+        horizontal,
+        nodeWidth,
+        nodeHeight,
+        markerId,
+      }),
+    )
+    .join('');
+  const nodes = parsed.nodes
+    .map((node) =>
+      renderNode(node, positions.get(node.id), { nodeWidth, nodeHeight }),
+    )
+    .join('');
+
+  return {
+    html: `<svg class="narrative-diagram" data-direction="${parsed.direction}" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}" role="img" aria-label="Diagram"><style>
+      .diagram-node-shape { fill: var(--panel, ${panel}); stroke: var(--accent, ${accent}); stroke-width: 2; }
+      .diagram-node-label { fill: var(--ink, ${ink}); font: 14px var(--sans, system-ui, sans-serif); text-anchor: middle; dominant-baseline: middle; }
+      .diagram-edge { fill: none; stroke: var(--muted, ${muted}); stroke-width: 2; }
+      .diagram-edge-label { fill: var(--muted, ${muted}); font: 12px var(--mono, ui-monospace, monospace); text-anchor: middle; }
+    </style><defs><marker id="${markerId}" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M 0 0 L 10 5 L 0 10 z" fill="var(--muted, ${muted})"></path></marker></defs>${edges}${nodes}</svg>`,
+    warnings: [],
+    degraded: false,
+  };
+}
+
+function parseNode(value) {
+  const match = value.match(NODE_PATTERN);
+  if (!match) return null;
+  const [, id, rectangle, rounded, diamond] = match;
+  const explicitLabel = rectangle ?? rounded ?? diamond;
+  return {
+    id,
+    label: unquote(explicitLabel ?? id),
+    shape:
+      diamond !== undefined
+        ? 'diamond'
+        : rounded !== undefined
+          ? 'rounded'
+          : 'rectangle',
+    explicit: explicitLabel !== undefined,
+  };
+}
+
+function registerNode(nodes, candidate) {
+  const current = nodes.get(candidate.id);
+  if (!current || candidate.explicit) nodes.set(candidate.id, candidate);
+}
+
+function renderNode(node, position, { nodeWidth, nodeHeight }) {
+  const centerX = position.x + nodeWidth / 2;
+  const centerY = position.y + nodeHeight / 2;
+  let shape;
+  if (node.shape === 'diamond') {
+    shape = `<polygon class="diagram-node-shape" points="${centerX},${position.y} ${position.x + nodeWidth},${centerY} ${centerX},${position.y + nodeHeight} ${position.x},${centerY}"></polygon>`;
+  } else {
+    shape = `<rect class="diagram-node-shape" x="${position.x}" y="${position.y}" width="${nodeWidth}" height="${nodeHeight}"${node.shape === 'rounded' ? ' rx="24"' : ''}></rect>`;
+  }
+  return `<g class="diagram-node" data-node="${escapeAttribute(node.id)}">${shape}<text class="diagram-node-label" x="${centerX}" y="${centerY}">${escapeHtml(node.label)}</text></g>`;
+}
+
+function renderEdge(
+  edge,
+  positions,
+  { horizontal, nodeWidth, nodeHeight, markerId },
+) {
+  const from = positions.get(edge.from);
+  const to = positions.get(edge.to);
+  const start = horizontal
+    ? { x: from.x + nodeWidth, y: from.y + nodeHeight / 2 }
+    : { x: from.x + nodeWidth / 2, y: from.y + nodeHeight };
+  const end = horizontal
+    ? { x: to.x, y: to.y + nodeHeight / 2 }
+    : { x: to.x + nodeWidth / 2, y: to.y };
+  const label = edge.label
+    ? `<text class="diagram-edge-label" x="${(start.x + end.x) / 2}" y="${(start.y + end.y) / 2 - 8}">${escapeHtml(edge.label)}</text>`
+    : '';
+  return `<g class="diagram-connection" data-from="${escapeAttribute(edge.from)}" data-to="${escapeAttribute(edge.to)}"><path class="diagram-edge" d="M ${start.x} ${start.y} L ${end.x} ${end.y}"${edge.kind === 'arrow' ? ` marker-end="url(#${markerId})"` : ''}></path>${label}</g>`;
+}
+
+function degraded(message) {
+  return {
+    valid: false,
+    direction: null,
+    nodes: [],
+    edges: [],
+    warnings: [{ code: 'unsupported-diagram', message }],
+  };
+}
+
+function unquote(value) {
+  return value.startsWith('"') && value.endsWith('"')
+    ? value.slice(1, -1)
+    : value;
+}
+
+function stableHash(value) {
+  let hash = 2166136261;
+  for (const character of value) {
+    hash ^= character.codePointAt(0);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, '0');
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+function escapeAttribute(value) {
+  return escapeHtml(value);
+}