@open-agent-toolkit/cli 0.2.25 → 0.2.27

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

@@ -0,0 +1,379 @@
+import { createHash } from 'node:crypto';
+
+import { browserCaptureIdentity } from './browser-runtime.mjs';
+import { canonicalHash, validateContract } from './contracts.mjs';
+
+export const PACKAGE_COVERAGE_VERSION = 'explainer-kit.package-coverage/v2';
+export const SET_PLAN_RECORD_PATHS = Object.freeze([
+  'source/set-plan/request.json',
+  'source/set-plan/result.json',
+  'source/set-plan/ledger.json',
+  'source/set-plan/portfolio.json',
+  'source/set-plan/drafts.json',
+]);
+export const VISUAL_REVISION_PATH = 'qa/visual-review/revision.json';
+
+const REVIEW_VIEWPORTS = Object.freeze(['mobile', 'tablet', 'desktop']);
+const SUCCESSFUL_OUTCOMES = new Set(['built-not-durable', 'built-durable']);
+const PARTIAL_REVIEW_OUTCOME = 'built-needs-review';
+
+export function requiredImmutablePackagePaths(manifest, { runMode } = {}) {
+  if (!isObject(manifest)) {
+    throw new TypeError(
+      'Manifest package coverage requires a manifest object.',
+    );
+  }
+  if (
+    runMode !== undefined &&
+    runMode !== 'interactive' &&
+    runMode !== 'unattended'
+  ) {
+    throw new TypeError(
+      'Manifest package coverage run mode must be interactive or unattended.',
+    );
+  }
+
+  const required = new Set([
+    'run-request.json',
+    'source/content-approval.json',
+    manifest.source?.factBasePath,
+    'source/fact-base.md',
+    ...(manifest.source?.authorResultPaths ?? []),
+    manifest.theme?.path,
+    ...(manifest.artifacts ?? []).flatMap((artifact) => [
+      artifact.contentPath,
+      ...(artifact.status === 'built' &&
+      typeof artifact.renderedPath === 'string'
+        ? [artifact.renderedPath]
+        : []),
+    ]),
+  ]);
+  required.delete(undefined);
+
+  if (manifest.recipe?.id !== 'project-recap') return [...required];
+
+  const successful = SUCCESSFUL_OUTCOMES.has(manifest.outcome);
+  if (successful) {
+    for (const path of SET_PLAN_RECORD_PATHS) required.add(path);
+  }
+
+  const recorded = Object.keys(manifest.immutableHashes ?? {});
+  if (manifest.outcome === PARTIAL_REVIEW_OUTCOME) return [...required];
+
+  const retainsReviewMaterial = recorded.some(isReviewMaterial);
+  const requireAttemptOne =
+    (successful && runMode === 'unattended') ||
+    (successful && runMode === 'interactive' && retainsReviewMaterial) ||
+    (!successful && retainsReviewMaterial);
+  const retainsAttemptTwo = recorded.some(isAttemptTwoMaterial);
+
+  if (requireAttemptOne || retainsAttemptTwo) {
+    addVisualReviewAttemptPaths(required, manifest, 1);
+  }
+  if (retainsAttemptTwo) {
+    required.add(VISUAL_REVISION_PATH);
+    addVisualReviewAttemptPaths(required, manifest, 2);
+  }
+  return [...required];
+}
+
+export async function validateImmutablePackageEvidence(
+  manifest,
+  { runMode, read } = {},
+) {
+  const requiredPaths = requiredImmutablePackagePaths(manifest, { runMode });
+  const missing = requiredPaths.filter(
+    (path) => !(path in (manifest?.immutableHashes ?? {})),
+  );
+  if (missing.length > 0) {
+    throw new Error(
+      `Manifest immutable hashes do not cover the canonical package: ${missing.join(', ')}.`,
+    );
+  }
+  if (manifest?.recipe?.id !== 'project-recap') return;
+
+  const recorded = Object.keys(manifest.immutableHashes ?? {});
+  const successful = SUCCESSFUL_OUTCOMES.has(manifest.outcome);
+  const retainsReviewMaterial = recorded.some(isReviewMaterial);
+  if (manifest.outcome === PARTIAL_REVIEW_OUTCOME) return;
+  const requireAttemptOne =
+    (successful && runMode === 'unattended') ||
+    (successful && runMode === 'interactive' && retainsReviewMaterial) ||
+    (!successful &&
+      manifest.outcome !== PARTIAL_REVIEW_OUTCOME &&
+      retainsReviewMaterial);
+  const retainsAttemptTwo = recorded.some(isAttemptTwoMaterial);
+  if (!requireAttemptOne && !retainsAttemptTwo) return;
+  if (typeof read !== 'function') {
+    throw new TypeError(
+      'Canonical browser evidence validation requires an immutable package reader.',
+    );
+  }
+
+  const readVerified = async (path) => {
+    const value = await read(path);
+    const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    const expected = manifest.immutableHashes[path];
+    const actual = `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+    if (actual !== expected) {
+      throw new Error(`Immutable package hash mismatch for ${path}.`);
+    }
+    return bytes;
+  };
+  const builtArtifacts = (manifest.artifacts ?? []).filter(
+    ({ status }) => status === 'built',
+  );
+  const browserRecords = new Map();
+  let expectedRuntimeHash;
+  let expectedCaptureIdentity;
+  for (const artifact of builtArtifacts) {
+    for (const viewport of REVIEW_VIEWPORTS) {
+      const metricsPath = `qa/browser/${artifact.id}/${viewport}.json`;
+      const bytes = await readVerified(metricsPath);
+      const screenshotPath = `qa/browser/${artifact.id}/${viewport}.png`;
+      const screenshotBytes = await readVerified(screenshotPath);
+      if (!isPng(screenshotBytes)) {
+        throw new Error(
+          `Browser screenshot evidence ${screenshotPath} is not a PNG.`,
+        );
+      }
+      const record = parseJson(bytes, metricsPath);
+      validateBrowserEvidenceRecord(record, {
+        artifactId: artifact.id,
+        viewport,
+        metricsPath,
+        requireLaunched: successful && runMode === 'unattended',
+      });
+      const runtimeHash = canonicalHash(record.runtime);
+      expectedRuntimeHash ??= runtimeHash;
+      expectedCaptureIdentity ??= record.captureIdentity;
+      if (
+        runtimeHash !== expectedRuntimeHash ||
+        record.captureIdentity !== expectedCaptureIdentity
+      ) {
+        throw new Error(
+          `Browser runtime or capture identity mismatch in ${metricsPath}.`,
+        );
+      }
+      browserRecords.set(metricsPath, { bytes, record, screenshotBytes });
+    }
+  }
+
+  const attempts = retainsAttemptTwo ? [1, 2] : [1];
+  let terminalResult;
+  for (const attempt of attempts) {
+    const root = `qa/visual-review/attempt-${attempt}`;
+    const requestPath = `${root}/request.json`;
+    const request = parseJson(await readVerified(requestPath), requestPath);
+    const requestValidation = validateContract(
+      'visual-review-request',
+      request,
+    );
+    if (!requestValidation.valid) {
+      throw new Error(
+        `Immutable visual-review request ${requestPath} is invalid: ${requestValidation.errors
+          .map(({ code }) => code)
+          .join(', ')}.`,
+      );
+    }
+    if (
+      canonicalHash(request.browserRuntime) !== expectedRuntimeHash ||
+      request.captureIdentity !== expectedCaptureIdentity
+    ) {
+      throw new Error(
+        `Visual-review browser runtime or capture identity mismatch in ${requestPath}.`,
+      );
+    }
+    const requestEvidence = new Map(
+      request.renderedArtifacts.flatMap((artifact) =>
+        artifact.evidence.map((evidence) => [
+          `${artifact.artifactId}:${evidence.viewport}`,
+          evidence,
+        ]),
+      ),
+    );
+    for (const artifact of builtArtifacts) {
+      for (const viewport of REVIEW_VIEWPORTS) {
+        const key = `${artifact.id}:${viewport}`;
+        const evidence = requestEvidence.get(key);
+        const sourceMetricsPath = `qa/browser/${artifact.id}/${viewport}.json`;
+        const sourceScreenshotPath = `qa/browser/${artifact.id}/${viewport}.png`;
+        if (
+          !evidence ||
+          evidence.metricsPath !== sourceMetricsPath ||
+          evidence.screenshotPath !== sourceScreenshotPath ||
+          evidence.captureIdentity !== expectedCaptureIdentity
+        ) {
+          throw new Error(
+            `Visual-review evidence binding mismatch for ${key} in ${requestPath}.`,
+          );
+        }
+        const copiedMetricsPath = `${root}/evidence/${artifact.id}/${viewport}.json`;
+        const copiedMetrics = await readVerified(copiedMetricsPath);
+        const copiedScreenshotPath = `${root}/evidence/${artifact.id}/${viewport}.png`;
+        const copiedScreenshot = await readVerified(copiedScreenshotPath);
+        if (!isPng(copiedScreenshot)) {
+          throw new Error(
+            `Retained visual-review screenshot ${copiedScreenshotPath} is not a PNG.`,
+          );
+        }
+        const copiedRecord = parseJson(copiedMetrics, copiedMetricsPath);
+        validateBrowserEvidenceRecord(copiedRecord, {
+          artifactId: artifact.id,
+          viewport,
+          metricsPath: copiedMetricsPath,
+          requireLaunched: successful && runMode === 'unattended',
+        });
+        if (
+          canonicalHash(copiedRecord.runtime) !== expectedRuntimeHash ||
+          copiedRecord.captureIdentity !== expectedCaptureIdentity
+        ) {
+          throw new Error(
+            `Retained visual-review browser runtime or capture identity mismatch in ${copiedMetricsPath}.`,
+          );
+        }
+        if (
+          evidence.metricsHash !==
+          `sha256:${createHash('sha256').update(copiedMetrics).digest('hex')}`
+        ) {
+          throw new Error(
+            `Visual-review metrics hash mismatch for ${key} in ${requestPath}.`,
+          );
+        }
+        if (
+          evidence.screenshotHash !==
+          `sha256:${createHash('sha256')
+            .update(copiedScreenshot)
+            .digest('hex')}`
+        ) {
+          throw new Error(
+            `Visual-review screenshot hash mismatch for ${key} in ${requestPath}.`,
+          );
+        }
+        if (attempt === attempts.at(-1)) {
+          const sourceMetrics = browserRecords.get(sourceMetricsPath);
+          if (
+            !copiedMetrics.equals(sourceMetrics.bytes) ||
+            !copiedScreenshot.equals(sourceMetrics.screenshotBytes)
+          ) {
+            throw new Error(
+              `Terminal visual-review evidence differs from ${sourceMetricsPath}.`,
+            );
+          }
+        }
+      }
+    }
+    if (
+      requestEvidence.size !==
+      builtArtifacts.length * REVIEW_VIEWPORTS.length
+    ) {
+      throw new Error(
+        `Visual-review evidence set in ${requestPath} does not match the complete browser record set.`,
+      );
+    }
+
+    const resultPath = `${root}/result.json`;
+    const result = parseJson(await readVerified(resultPath), resultPath);
+    const resultValidation = validateContract('visual-review-result', result, {
+      visualReviewRequest: request,
+    });
+    if (!resultValidation.valid) {
+      throw new Error(
+        `Immutable visual-review result ${resultPath} is invalid: ${resultValidation.errors
+          .map(({ code }) => code)
+          .join(', ')}.`,
+      );
+    }
+    terminalResult = result;
+  }
+  if (successful && terminalResult?.disposition !== 'pass') {
+    throw new Error(
+      'Successful recap package requires a terminal passing visual review.',
+    );
+  }
+}
+
+function addVisualReviewAttemptPaths(required, manifest, attempt) {
+  const root = `qa/visual-review/attempt-${attempt}`;
+  required.add(`${root}/request.json`);
+  required.add(`${root}/result.json`);
+  for (const artifact of manifest.artifacts ?? []) {
+    if (artifact.status !== 'built') continue;
+    for (const viewport of REVIEW_VIEWPORTS) {
+      required.add(`qa/browser/${artifact.id}/${viewport}.png`);
+      required.add(`qa/browser/${artifact.id}/${viewport}.json`);
+      required.add(`${root}/evidence/${artifact.id}/${viewport}.png`);
+      required.add(`${root}/evidence/${artifact.id}/${viewport}.json`);
+    }
+  }
+}
+
+function isReviewMaterial(path) {
+  return (
+    path.startsWith('qa/browser/') ||
+    path.startsWith('qa/visual-review/') ||
+    path.startsWith('qa/review-gate/')
+  );
+}
+
+function isAttemptTwoMaterial(path) {
+  return (
+    path === VISUAL_REVISION_PATH ||
+    path.startsWith('qa/visual-review/attempt-2/') ||
+    path.startsWith('qa/review-gate/attempt-2')
+  );
+}
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isPng(bytes) {
+  return (
+    bytes.length >= 8 &&
+    bytes
+      .subarray(0, 8)
+      .equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))
+  );
+}
+
+function validateBrowserEvidenceRecord(
+  record,
+  { artifactId, viewport, metricsPath, requireLaunched },
+) {
+  if (
+    !isObject(record) ||
+    record.schemaVersion !== 'explainer-kit.browser-evidence/v2' ||
+    record.artifactId !== artifactId ||
+    record.viewport !== viewport ||
+    record.scenario !== 'default' ||
+    !isObject(record.runtime) ||
+    !['launched', 'fixture'].includes(record.runtime.kind) ||
+    record.runtime.name !== 'chromium' ||
+    typeof record.runtime.version !== 'string' ||
+    record.runtime.version.length === 0 ||
+    !isObject(record.capture) ||
+    !/^sha256:[a-f0-9]{64}$/.test(record.captureIdentity ?? '') ||
+    record.captureIdentity !==
+      browserCaptureIdentity(record.runtime, record.capture)
+  ) {
+    throw new Error(
+      `Browser evidence ${metricsPath} does not satisfy explainer-kit.browser-evidence/v2.`,
+    );
+  }
+  if (requireLaunched && record.runtime.kind !== 'launched') {
+    throw new Error(
+      `Production browser evidence ${metricsPath} must identify launched Chromium, not a fixture session.`,
+    );
+  }
+}
+
+function parseJson(bytes, path) {
+  try {
+    return JSON.parse(bytes.toString('utf8'));
+  } catch {
+    throw new Error(
+      `Immutable package record ${path} must contain valid JSON.`,
+    );
+  }
+}

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

@@ -0,0 +1,287 @@
+import { createHash } from 'node:crypto';
+import { crc32, inflateSync } from 'node:zlib';
+
+const PNG_SIGNATURE = Buffer.from('89504e470d0a1a0a', 'hex');
+const SUPPORTED_COLOR_TYPES = new Map([
+  [2, 3],
+  [6, 4],
+]);
+const KNOWN_CRITICAL_CHUNKS = new Set(['IHDR', 'IDAT', 'IEND']);
+
+export const MAX_PNG_INPUT_BYTES = 20 * 1024 * 1024;
+export const MAX_PNG_DECODED_BYTES = 64 * 1024 * 1024;
+export const MAX_PNG_DIMENSION = 16_384;
+
+export function decodeBrowserPng(bytes) {
+  if (!Buffer.isBuffer(bytes)) {
+    throw pngError('PNG input must be a Buffer.');
+  }
+  if (
+    bytes.length < PNG_SIGNATURE.length + 12 ||
+    bytes.length > MAX_PNG_INPUT_BYTES
+  ) {
+    throw pngError(
+      `PNG input must be between ${PNG_SIGNATURE.length + 12} and ${MAX_PNG_INPUT_BYTES} bytes.`,
+    );
+  }
+  if (!bytes.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE)) {
+    throw pngError('PNG signature is invalid.');
+  }
+
+  let offset = PNG_SIGNATURE.length;
+  let ihdr = null;
+  let sawIdat = false;
+  let idatEnded = false;
+  let sawIend = false;
+  const idatParts = [];
+  let idatLength = 0;
+
+  while (offset < bytes.length) {
+    if (bytes.length - offset < 12) {
+      throw pngError('PNG chunk boundary is truncated.');
+    }
+    const length = bytes.readUInt32BE(offset);
+    const dataStart = offset + 8;
+    const dataEnd = dataStart + length;
+    const chunkEnd = dataEnd + 4;
+    if (chunkEnd > bytes.length) {
+      throw pngError('PNG chunk length exceeds the input boundary.');
+    }
+
+    const typeBytes = bytes.subarray(offset + 4, offset + 8);
+    if (
+      typeBytes.some(
+        (byte) => !((byte >= 65 && byte <= 90) || (byte >= 97 && byte <= 122)),
+      ) ||
+      (typeBytes[2] & 0x20) !== 0
+    ) {
+      throw pngError('PNG chunk type is invalid.');
+    }
+    const type = typeBytes.toString('ascii');
+    const expectedCrc = bytes.readUInt32BE(dataEnd);
+    const actualCrc = crc32(bytes.subarray(offset + 4, dataEnd));
+    if (actualCrc !== expectedCrc) {
+      throw pngError(`PNG ${type} chunk CRC is invalid.`);
+    }
+    if (!KNOWN_CRITICAL_CHUNKS.has(type) && (typeBytes[0] & 0x20) === 0) {
+      throw pngError(`PNG critical chunk ${type} is unsupported.`);
+    }
+
+    const data = bytes.subarray(dataStart, dataEnd);
+    if (ihdr === null && type !== 'IHDR') {
+      throw pngError('PNG IHDR must be the first chunk.');
+    }
+    if (type === 'IHDR') {
+      if (ihdr !== null || offset !== PNG_SIGNATURE.length || length !== 13) {
+        throw pngError('PNG must contain exactly one 13-byte IHDR first.');
+      }
+      ihdr = parseIhdr(data);
+    } else if (type === 'IDAT') {
+      if (sawIend || idatEnded) {
+        throw pngError('PNG IDAT chunks must be contiguous.');
+      }
+      sawIdat = true;
+      idatLength = boundedAdd(idatLength, length, MAX_PNG_INPUT_BYTES);
+      idatParts.push(data);
+    } else if (type === 'IEND') {
+      if (!sawIdat || sawIend || length !== 0) {
+        throw pngError('PNG must contain one empty IEND after IDAT.');
+      }
+      sawIend = true;
+      if (chunkEnd !== bytes.length) {
+        throw pngError('PNG contains trailing bytes after IEND.');
+      }
+    } else if (sawIdat) {
+      idatEnded = true;
+    }
+
+    offset = chunkEnd;
+  }
+
+  if (ihdr === null || !sawIdat || idatLength === 0 || !sawIend) {
+    throw pngError(
+      'PNG requires IHDR, non-empty contiguous IDAT, and IEND chunks.',
+    );
+  }
+
+  const { width, height, bitDepth, channels, colorType } = ihdr;
+  const rowBytes = boundedMultiply(width, channels, MAX_PNG_DECODED_BYTES);
+  const scanlineBytes = boundedMultiply(
+    height,
+    boundedAdd(rowBytes, 1, MAX_PNG_DECODED_BYTES),
+    MAX_PNG_DECODED_BYTES,
+  );
+  const compressed = Buffer.concat(idatParts, idatLength);
+  let inflated;
+  let consumed;
+  try {
+    const result = inflateSync(compressed, {
+      info: true,
+      maxOutputLength: scanlineBytes,
+    });
+    inflated = result.buffer;
+    consumed = result.engine.bytesWritten;
+  } catch (error) {
+    throw pngError(`PNG IDAT zlib stream is invalid: ${error.message}`);
+  }
+  if (consumed !== compressed.length) {
+    throw pngError('PNG IDAT contains trailing zlib data.');
+  }
+  if (inflated.length !== scanlineBytes) {
+    throw pngError('PNG inflated scanline length is invalid.');
+  }
+
+  const pixels = reconstructScanlines(inflated, {
+    width,
+    height,
+    channels,
+    rowBytes,
+  });
+  const pixelHash = hashBytes(pixels);
+  const decodedHash = hashDecodedIdentity({
+    width,
+    height,
+    bitDepth,
+    colorType,
+    channels,
+    pixels,
+  });
+  return {
+    width,
+    height,
+    bitDepth,
+    colorType,
+    channels,
+    pixels,
+    pixelHash,
+    decodedHash,
+  };
+}
+
+function parseIhdr(data) {
+  const width = data.readUInt32BE(0);
+  const height = data.readUInt32BE(4);
+  const bitDepth = data[8];
+  const colorType = data[9];
+  const channels = SUPPORTED_COLOR_TYPES.get(colorType);
+  if (
+    width === 0 ||
+    height === 0 ||
+    width > MAX_PNG_DIMENSION ||
+    height > MAX_PNG_DIMENSION
+  ) {
+    throw pngError(`PNG dimensions must be within 1..${MAX_PNG_DIMENSION}.`);
+  }
+  if (
+    bitDepth !== 8 ||
+    channels === undefined ||
+    data[10] !== 0 ||
+    data[11] !== 0 ||
+    data[12] !== 0
+  ) {
+    throw pngError(
+      'PNG browser profile must be non-interlaced 8-bit RGB or RGBA.',
+    );
+  }
+  return { width, height, bitDepth, channels, colorType };
+}
+
+function hashDecodedIdentity({
+  width,
+  height,
+  bitDepth,
+  colorType,
+  channels,
+  pixels,
+}) {
+  const descriptor = Buffer.alloc(11);
+  descriptor.writeUInt32BE(width, 0);
+  descriptor.writeUInt32BE(height, 4);
+  descriptor[8] = bitDepth;
+  descriptor[9] = colorType;
+  descriptor[10] = channels;
+  return `sha256:${createHash('sha256')
+    .update('explainer-kit.decoded-png/v1\0', 'utf8')
+    .update(descriptor)
+    .update(pixels)
+    .digest('hex')}`;
+}
+
+function hashBytes(bytes) {
+  return `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+}
+
+function reconstructScanlines(inflated, { height, channels, rowBytes }) {
+  const pixels = Buffer.allocUnsafe(rowBytes * height);
+  let inputOffset = 0;
+  for (let row = 0; row < height; row += 1) {
+    const filter = inflated[inputOffset];
+    inputOffset += 1;
+    if (filter > 4) {
+      throw pngError(`PNG scanline filter ${filter} is unsupported.`);
+    }
+    const rowOffset = row * rowBytes;
+    for (let column = 0; column < rowBytes; column += 1) {
+      const encoded = inflated[inputOffset + column];
+      const left =
+        column >= channels ? pixels[rowOffset + column - channels] : 0;
+      const up = row > 0 ? pixels[rowOffset - rowBytes + column] : 0;
+      const upLeft =
+        row > 0 && column >= channels
+          ? pixels[rowOffset - rowBytes + column - channels]
+          : 0;
+      pixels[rowOffset + column] =
+        (encoded + filterPrediction(filter, left, up, upLeft)) & 0xff;
+    }
+    inputOffset += rowBytes;
+  }
+  return pixels;
+}
+
+function filterPrediction(filter, left, up, upLeft) {
+  switch (filter) {
+    case 0:
+      return 0;
+    case 1:
+      return left;
+    case 2:
+      return up;
+    case 3:
+      return Math.floor((left + up) / 2);
+    case 4:
+      return paeth(left, up, upLeft);
+    default:
+      throw pngError(`PNG scanline filter ${filter} is unsupported.`);
+  }
+}
+
+function paeth(left, up, upLeft) {
+  const estimate = left + up - upLeft;
+  const leftDistance = Math.abs(estimate - left);
+  const upDistance = Math.abs(estimate - up);
+  const upLeftDistance = Math.abs(estimate - upLeft);
+  if (leftDistance <= upDistance && leftDistance <= upLeftDistance) return left;
+  return upDistance <= upLeftDistance ? up : upLeft;
+}
+
+function boundedAdd(left, right, maximum) {
+  const result = left + right;
+  if (!Number.isSafeInteger(result) || result > maximum) {
+    throw pngError('PNG size exceeds the configured bounds.');
+  }
+  return result;
+}
+
+function boundedMultiply(left, right, maximum) {
+  const result = left * right;
+  if (!Number.isSafeInteger(result) || result > maximum) {
+    throw pngError('PNG decoded size exceeds the configured bounds.');
+  }
+  return result;
+}
+
+function pngError(message) {
+  const error = new Error(message);
+  error.code = 'E_PNG';
+  return error;
+}