@pygmalionjs/pygmalion 0.2.11 → 0.2.13

package/node/route-preview-artifact-v3.mjs

@@ -0,0 +1,584 @@
+import { createHash } from 'node:crypto';
+import {
+  createRoutePreviewArtifactV2,
+  reconstructRoutePreviewArtifactSnapshot,
+  reconstructRoutePreviewArtifactSnapshots,
+  validateRoutePreviewArtifactV2,
+} from './route-preview-artifact-v2.mjs';
+
+const HASH_PATTERN = /^sha256-[a-f0-9]{64}$/;
+const TOKEN_PATTERN = /^[A-Za-z][A-Za-z0-9]*(?:[-_.:][A-Za-z0-9]+)*$/;
+const BASE64_PATTERN =
+  /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const FORBIDDEN_RECORD_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+const STATUSES = new Set([
+  'ready',
+  'rendered-with-qa-failure',
+  'capture-error',
+]);
+const QA_STAGES = new Set(['interaction', 'assertion']);
+const MEDIA_TYPES = new Set(['image/png', 'image/webp']);
+
+export const ROUTE_PREVIEW_ARTIFACT_V3_LIMITS = Object.freeze({
+  bundleBytes: 256 * 1024 * 1024,
+  screenshotAssetBytes: 16 * 1024 * 1024,
+  screenshotAssetCount: 2_048,
+  frameCount: 2_048,
+  diagnosticCountPerFrame: 256,
+  identifierLength: 512,
+  tokenLength: 128,
+  selectorLength: 4_096,
+  labelLength: 1_024,
+  messageLength: 4_096,
+  viewportDimension: 32_768,
+});
+
+function byteLength(value) {
+  return Buffer.byteLength(value, 'utf8');
+}
+
+function safeJsonByteLength(value) {
+  try {
+    return byteLength(JSON.stringify(value));
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+
+function isPlainRecord(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function validIdentifier(value) {
+  return (
+    typeof value === 'string' &&
+    value.length > 0 &&
+    value.length <= ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.identifierLength &&
+    value === value.trim() &&
+    !FORBIDDEN_RECORD_KEYS.has(value)
+  );
+}
+
+function validOptionalIdentifier(value) {
+  return value == null || validIdentifier(value);
+}
+
+function validViewport(value) {
+  return (
+    isPlainRecord(value) &&
+    Number.isInteger(value.width) &&
+    value.width > 0 &&
+    value.width <= ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.viewportDimension &&
+    Number.isInteger(value.height) &&
+    value.height > 0 &&
+    value.height <= ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.viewportDimension
+  );
+}
+
+function sameViewport(left, right) {
+  return (
+    validViewport(left) &&
+    validViewport(right) &&
+    left.width === right.width &&
+    left.height === right.height
+  );
+}
+
+function copyViewport(value) {
+  if (!validViewport(value)) return value;
+  return { width: value.width, height: value.height };
+}
+
+function validToken(value) {
+  return (
+    typeof value === 'string' &&
+    value.length > 0 &&
+    value.length <= ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.tokenLength &&
+    TOKEN_PATTERN.test(value)
+  );
+}
+
+function validOptionalText(value, maximumLength) {
+  return (
+    value == null ||
+    (typeof value === 'string' &&
+      value.length > 0 &&
+      value.length <= maximumLength &&
+      !/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/.test(value))
+  );
+}
+
+function screenshotContentHash(mediaType, width, height, bytes) {
+  return `sha256-${createHash('sha256')
+    .update('screenshot')
+    .update('\0')
+    .update(mediaType)
+    .update('\0')
+    .update(`${width}x${height}`)
+    .update('\0')
+    .update(bytes)
+    .digest('hex')}`;
+}
+
+function sortedRecord(entries) {
+  return Object.fromEntries(
+    [...entries].sort(([left], [right]) => left.localeCompare(right)),
+  );
+}
+
+function normalizeScreenshot(rawScreenshot) {
+  if (
+    !isPlainRecord(rawScreenshot) ||
+    !MEDIA_TYPES.has(rawScreenshot.mediaType) ||
+    !Number.isInteger(rawScreenshot.width) ||
+    !Number.isInteger(rawScreenshot.height)
+  ) {
+    throw new TypeError('Route preview screenshot metadata is invalid.');
+  }
+  const rawBytes = rawScreenshot.bytes;
+  if (!(rawBytes instanceof Uint8Array)) {
+    throw new TypeError('Route preview screenshot bytes must be a Uint8Array.');
+  }
+  const bytes = Buffer.from(rawBytes.buffer, rawBytes.byteOffset, rawBytes.byteLength);
+  if (
+    bytes.byteLength === 0 ||
+    bytes.byteLength > ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.screenshotAssetBytes
+  ) {
+    throw new RangeError('Route preview screenshot exceeds the byte limit.');
+  }
+  if (
+    rawScreenshot.width <= 0 ||
+    rawScreenshot.width > ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.viewportDimension ||
+    rawScreenshot.height <= 0 ||
+    rawScreenshot.height > ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.viewportDimension
+  ) {
+    throw new RangeError('Route preview screenshot dimensions are invalid.');
+  }
+  const hash = screenshotContentHash(
+    rawScreenshot.mediaType,
+    rawScreenshot.width,
+    rawScreenshot.height,
+    bytes,
+  );
+  return {
+    reference: {
+      hash,
+      mediaType: rawScreenshot.mediaType,
+      width: rawScreenshot.width,
+      height: rawScreenshot.height,
+    },
+    asset: {
+      mediaType: rawScreenshot.mediaType,
+      width: rawScreenshot.width,
+      height: rawScreenshot.height,
+      data: bytes.toString('base64'),
+      byteLength: bytes.byteLength,
+    },
+  };
+}
+
+function normalizeDiagnostic(rawDiagnostic, viewport) {
+  if (!isPlainRecord(rawDiagnostic)) {
+    throw new TypeError('Route preview diagnostic must be a record.');
+  }
+  return {
+    stage: rawDiagnostic.stage,
+    code: rawDiagnostic.code,
+    ...(rawDiagnostic.selector == null ? {} : { selector: rawDiagnostic.selector }),
+    ...(rawDiagnostic.label == null ? {} : { label: rawDiagnostic.label }),
+    ...(rawDiagnostic.message == null ? {} : { message: rawDiagnostic.message }),
+    viewport: copyViewport(rawDiagnostic.viewport ?? viewport),
+  };
+}
+
+function projectArtifactV2(bundle) {
+  const frames = {};
+  if (isPlainRecord(bundle?.frames)) {
+    for (const [frameId, frame] of Object.entries(bundle.frames)) {
+      if (isPlainRecord(frame) && frame.snapshot !== undefined) {
+        frames[frameId] = frame.snapshot;
+      }
+    }
+  }
+  return {
+    version: 2,
+    namespace: bundle?.namespace,
+    ...(bundle?.sourceRevision == null
+      ? {}
+      : { sourceRevision: bundle.sourceRevision }),
+    assets: {
+      head: bundle?.assets?.head,
+      stylesheets: bundle?.assets?.stylesheets,
+    },
+    frames,
+  };
+}
+
+function inspectScreenshotAssets(value, errors) {
+  if (!isPlainRecord(value)) {
+    errors.push('Screenshot assets must be a record.');
+    return new Map();
+  }
+  const assets = new Map();
+  for (const [hash, rawAsset] of Object.entries(value)) {
+    if (!HASH_PATTERN.test(hash) || !isPlainRecord(rawAsset)) {
+      errors.push(`Screenshot asset "${hash}" is invalid.`);
+      continue;
+    }
+    if (
+      !MEDIA_TYPES.has(rawAsset.mediaType) ||
+      !Number.isInteger(rawAsset.width) ||
+      rawAsset.width <= 0 ||
+      rawAsset.width > ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.viewportDimension ||
+      !Number.isInteger(rawAsset.height) ||
+      rawAsset.height <= 0 ||
+      rawAsset.height > ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.viewportDimension ||
+      !Number.isInteger(rawAsset.byteLength) ||
+      rawAsset.byteLength <= 0 ||
+      rawAsset.byteLength >
+        ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.screenshotAssetBytes ||
+      typeof rawAsset.data !== 'string' ||
+      !BASE64_PATTERN.test(rawAsset.data)
+    ) {
+      errors.push(`Screenshot asset "${hash}" metadata is invalid.`);
+      continue;
+    }
+    const bytes = Buffer.from(rawAsset.data, 'base64');
+    if (
+      bytes.byteLength !== rawAsset.byteLength ||
+      bytes.toString('base64') !== rawAsset.data
+    ) {
+      errors.push(`Screenshot asset "${hash}" data is invalid.`);
+      continue;
+    }
+    const expectedHash = screenshotContentHash(
+      rawAsset.mediaType,
+      rawAsset.width,
+      rawAsset.height,
+      bytes,
+    );
+    if (expectedHash !== hash) {
+      errors.push(`Screenshot asset "${hash}" does not match its content hash.`);
+    }
+    assets.set(hash, rawAsset);
+  }
+  if (
+    assets.size > ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.screenshotAssetCount
+  ) {
+    errors.push('Artifact has too many screenshot assets.');
+  }
+  return assets;
+}
+
+function inspectDiagnostic(rawDiagnostic, frameId, viewport, errors) {
+  if (!isPlainRecord(rawDiagnostic)) {
+    errors.push(`Frame "${frameId}" contains an invalid diagnostic.`);
+    return false;
+  }
+  let valid = true;
+  if (!validToken(rawDiagnostic.stage)) {
+    errors.push(`Frame "${frameId}" diagnostic stage is invalid.`);
+    valid = false;
+  }
+  if (!validToken(rawDiagnostic.code)) {
+    errors.push(`Frame "${frameId}" diagnostic code is invalid.`);
+    valid = false;
+  }
+  if (
+    !validOptionalText(
+      rawDiagnostic.selector,
+      ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.selectorLength,
+    )
+  ) {
+    errors.push(`Frame "${frameId}" diagnostic selector is invalid.`);
+    valid = false;
+  }
+  if (
+    !validOptionalText(
+      rawDiagnostic.label,
+      ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.labelLength,
+    )
+  ) {
+    errors.push(`Frame "${frameId}" diagnostic label is invalid.`);
+    valid = false;
+  }
+  if (
+    !validOptionalText(
+      rawDiagnostic.message,
+      ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.messageLength,
+    )
+  ) {
+    errors.push(`Frame "${frameId}" diagnostic message is invalid.`);
+    valid = false;
+  }
+  if (!sameViewport(rawDiagnostic.viewport, viewport)) {
+    errors.push(`Frame "${frameId}" diagnostic viewport is invalid.`);
+    valid = false;
+  }
+  return valid;
+}
+
+function isQaStage(stage) {
+  return (
+    typeof stage === 'string' &&
+    stage
+      .split(/[._:-]/)
+      .some((part) => QA_STAGES.has(part.toLowerCase()))
+  );
+}
+
+/**
+ * Creates a deterministic artifact that keeps stable render output separate from
+ * capture and QA outcomes. The function performs no I/O.
+ */
+export function createRoutePreviewArtifactV3(input) {
+  if (!isPlainRecord(input) || !isPlainRecord(input.captures)) {
+    throw new TypeError('Route preview artifact v3 input is invalid.');
+  }
+  const captureEntries = Object.entries(input.captures).sort(([left], [right]) =>
+    left.localeCompare(right),
+  );
+  if (captureEntries.length > ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.frameCount) {
+    throw new RangeError('Route preview artifact has too many frames.');
+  }
+
+  const snapshots = {};
+  for (const [frameId, capture] of captureEntries) {
+    if (isPlainRecord(capture) && capture.snapshot != null) {
+      snapshots[frameId] = capture.snapshot;
+    }
+  }
+  const compact = createRoutePreviewArtifactV2({
+    namespace: input.namespace,
+    ...(input.sourceRevision == null
+      ? {}
+      : { sourceRevision: input.sourceRevision }),
+    snapshots,
+  });
+  const screenshotAssets = new Map();
+  const frames = [];
+  for (const [frameId, rawCapture] of captureEntries) {
+    if (!isPlainRecord(rawCapture)) {
+      throw new TypeError(`Route preview capture "${frameId}" is invalid.`);
+    }
+    const diagnostics = Array.isArray(rawCapture.diagnostics)
+      ? rawCapture.diagnostics.map((diagnostic) =>
+          normalizeDiagnostic(diagnostic, rawCapture.viewport),
+        )
+      : [];
+    const screenshot =
+      rawCapture.screenshot == null
+        ? null
+        : normalizeScreenshot(rawCapture.screenshot);
+    if (screenshot) {
+      screenshotAssets.set(screenshot.reference.hash, screenshot.asset);
+    }
+    frames.push([
+      frameId,
+      {
+        status: rawCapture.status,
+        viewport: copyViewport(rawCapture.viewport),
+        ...(compact.frames[frameId] == null
+          ? {}
+          : { snapshot: compact.frames[frameId] }),
+        ...(screenshot == null ? {} : { screenshot: screenshot.reference }),
+        diagnostics,
+      },
+    ]);
+  }
+  const artifact = {
+    version: 3,
+    namespace: compact.namespace,
+    ...(compact.sourceRevision == null
+      ? {}
+      : { sourceRevision: compact.sourceRevision }),
+    assets: {
+      head: compact.assets.head,
+      stylesheets: compact.assets.stylesheets,
+      screenshots: sortedRecord(screenshotAssets),
+    },
+    frames: Object.fromEntries(frames),
+  };
+  const report = validateRoutePreviewArtifactV3(artifact);
+  if (!report.valid) {
+    throw new TypeError(
+      `Invalid generated route preview artifact v3: ${report.errors.join(' ')}`,
+    );
+  }
+  return artifact;
+}
+
+export function validateRoutePreviewArtifactV3(bundle) {
+  const errors = [];
+  const bundleBytes = safeJsonByteLength(bundle);
+  if (!isPlainRecord(bundle) || bundle.version !== 3) {
+    return {
+      valid: false,
+      errors: ['Route preview artifact must be a version 3 record.'],
+      bytes: bundleBytes,
+    };
+  }
+  if (!validIdentifier(bundle.namespace)) errors.push('Artifact namespace is invalid.');
+  if (!validOptionalIdentifier(bundle.sourceRevision)) {
+    errors.push('Artifact source revision is invalid.');
+  }
+  if (bundleBytes > ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.bundleBytes) {
+    errors.push('Artifact exceeds the bundle byte limit.');
+  }
+  if (!isPlainRecord(bundle.assets)) {
+    errors.push('Artifact assets must be a record.');
+  }
+  const screenshotAssets = inspectScreenshotAssets(
+    bundle.assets?.screenshots,
+    errors,
+  );
+  const v2Report = validateRoutePreviewArtifactV2(projectArtifactV2(bundle));
+  errors.push(...v2Report.errors.map((error) => `Snapshot data: ${error}`));
+
+  if (!isPlainRecord(bundle.frames)) {
+    errors.push('Artifact frames must be a record.');
+    return { valid: false, errors, bytes: bundleBytes };
+  }
+  const frameEntries = Object.entries(bundle.frames);
+  if (frameEntries.length > ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.frameCount) {
+    errors.push('Artifact has too many frames.');
+  }
+  const usedScreenshotHashes = new Set();
+  for (const [frameId, rawFrame] of frameEntries) {
+    if (!validIdentifier(frameId)) {
+      errors.push(`Frame identifier "${frameId}" is invalid.`);
+      continue;
+    }
+    if (
+      !isPlainRecord(rawFrame) ||
+      !STATUSES.has(rawFrame.status) ||
+      !validViewport(rawFrame.viewport)
+    ) {
+      errors.push(`Frame "${frameId}" status or viewport is invalid.`);
+      continue;
+    }
+    const diagnostics = rawFrame.diagnostics;
+    if (
+      !Array.isArray(diagnostics) ||
+      diagnostics.length >
+        ROUTE_PREVIEW_ARTIFACT_V3_LIMITS.diagnosticCountPerFrame
+    ) {
+      errors.push(`Frame "${frameId}" diagnostics are invalid.`);
+      continue;
+    }
+    for (const diagnostic of diagnostics) {
+      inspectDiagnostic(diagnostic, frameId, rawFrame.viewport, errors);
+    }
+
+    let hasScreenshot = false;
+    if (rawFrame.screenshot !== undefined) {
+      const reference = rawFrame.screenshot;
+      if (
+        !isPlainRecord(reference) ||
+        typeof reference.hash !== 'string' ||
+        !HASH_PATTERN.test(reference.hash) ||
+        !MEDIA_TYPES.has(reference.mediaType) ||
+        !Number.isInteger(reference.width) ||
+        !Number.isInteger(reference.height)
+      ) {
+        errors.push(`Frame "${frameId}" screenshot reference is invalid.`);
+      } else {
+        const asset = screenshotAssets.get(reference.hash);
+        if (!asset) {
+          errors.push(`Frame "${frameId}" references a missing screenshot asset.`);
+        } else if (
+          asset.mediaType !== reference.mediaType ||
+          asset.width !== reference.width ||
+          asset.height !== reference.height
+        ) {
+          errors.push(`Frame "${frameId}" screenshot metadata does not match its asset.`);
+        } else {
+          hasScreenshot = true;
+          usedScreenshotHashes.add(reference.hash);
+        }
+      }
+    }
+    const hasSnapshot = rawFrame.snapshot !== undefined;
+    if (rawFrame.status === 'ready') {
+      if (!hasSnapshot || !hasScreenshot) {
+        errors.push(`Frame "${frameId}" ready output is incomplete.`);
+      }
+      if (diagnostics.length !== 0) {
+        errors.push(`Frame "${frameId}" ready output cannot contain diagnostics.`);
+      }
+    } else if (rawFrame.status === 'rendered-with-qa-failure') {
+      if (!hasSnapshot || !hasScreenshot) {
+        errors.push(`Frame "${frameId}" QA failure must preserve stable output.`);
+      }
+      if (
+        diagnostics.length === 0 ||
+        !diagnostics.some((diagnostic) =>
+          isPlainRecord(diagnostic) ? isQaStage(diagnostic.stage) : false,
+        )
+      ) {
+        errors.push(`Frame "${frameId}" QA failure requires a QA diagnostic.`);
+      }
+    } else if (diagnostics.length === 0) {
+      errors.push(`Frame "${frameId}" capture error requires a diagnostic.`);
+    }
+  }
+  for (const hash of screenshotAssets.keys()) {
+    if (!usedScreenshotHashes.has(hash)) {
+      errors.push(`Screenshot asset "${hash}" is unreferenced.`);
+    }
+  }
+  return { valid: errors.length === 0, errors, bytes: bundleBytes };
+}
+
+/**
+ * Validates every compact route-preview artifact version accepted by the
+ * server runtime. Version-specific validators remain available for callers
+ * that intentionally require one exact contract.
+ */
+export function validateRoutePreviewArtifactBundle(bundle) {
+  return bundle?.version === 3
+    ? validateRoutePreviewArtifactV3(bundle)
+    : validateRoutePreviewArtifactV2(bundle);
+}
+
+export function reconstructRoutePreviewArtifactSnapshotV3(bundle, frameId) {
+  const report = validateRoutePreviewArtifactV3(bundle);
+  if (!report.valid) {
+    throw new TypeError(
+      `Invalid route preview artifact v3: ${report.errors.join(' ')}`,
+    );
+  }
+  const frame = bundle.frames[frameId];
+  if (!frame?.snapshot) return null;
+  return reconstructRoutePreviewArtifactSnapshot(projectArtifactV2(bundle), frameId);
+}
+
+export function reconstructRoutePreviewArtifactSnapshotsV3(bundle) {
+  const report = validateRoutePreviewArtifactV3(bundle);
+  if (!report.valid) {
+    throw new TypeError(
+      `Invalid route preview artifact v3: ${report.errors.join(' ')}`,
+    );
+  }
+  return reconstructRoutePreviewArtifactSnapshots(projectArtifactV2(bundle));
+}
+
+export function reconstructRoutePreviewArtifactScreenshotV3(bundle, frameId) {
+  const report = validateRoutePreviewArtifactV3(bundle);
+  if (!report.valid) {
+    throw new TypeError(
+      `Invalid route preview artifact v3: ${report.errors.join(' ')}`,
+    );
+  }
+  const reference = bundle.frames[frameId]?.screenshot;
+  if (!reference) return null;
+  const asset = bundle.assets.screenshots[reference.hash];
+  return {
+    mediaType: asset.mediaType,
+    width: asset.width,
+    height: asset.height,
+    bytes: Buffer.from(asset.data, 'base64'),
+  };
+}

package/node/source-revision.mjs

@@ -0,0 +1,83 @@
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { lstatSync, readFileSync, readlinkSync } from 'node:fs';
+import path from 'node:path';
+
+const MAX_GIT_OUTPUT_BYTES = 256 * 1024 * 1024;
+
+function git(root, args, encoding = 'utf8') {
+  return execFileSync('git', ['-C', root, ...args], {
+    encoding,
+    maxBuffer: MAX_GIT_OUTPUT_BYTES,
+  });
+}
+
+function nullSeparated(value) {
+  return value
+    .toString('utf8')
+    .split('\0')
+    .filter(Boolean);
+}
+
+/**
+ * Returns a source identity that is a plain commit for clean worktrees and a
+ * deterministic commit-scoped fingerprint for dirty worktrees.
+ *
+ * Ignored files are intentionally excluded. Hosts should represent runtime
+ * configuration separately in their capture recipe.
+ */
+export function resolveGitSourceState(root = process.cwd()) {
+  const resolvedRoot = path.resolve(root);
+  const commit = git(resolvedRoot, ['rev-parse', 'HEAD']).trim();
+  const status = git(
+    resolvedRoot,
+    ['status', '--porcelain=v1', '-z', '--untracked-files=all'],
+    'buffer',
+  );
+  if (status.byteLength === 0) {
+    return {
+      commit,
+      revision: commit,
+      dirty: false,
+      fingerprint: null,
+    };
+  }
+
+  const hash = createHash('sha256');
+  hash.update('pygmalion-source-state-v1\0');
+  hash.update(commit);
+  hash.update('\0');
+  hash.update(status);
+  hash.update(
+    git(resolvedRoot, ['diff', '--binary', 'HEAD', '--'], 'buffer'),
+  );
+  const untracked = nullSeparated(
+    git(
+      resolvedRoot,
+      ['ls-files', '--others', '--exclude-standard', '-z'],
+      'buffer',
+    ),
+  ).sort((left, right) => left.localeCompare(right));
+  for (const relativePath of untracked) {
+    const absolutePath = path.resolve(resolvedRoot, relativePath);
+    if (
+      absolutePath !== resolvedRoot &&
+      !absolutePath.startsWith(`${resolvedRoot}${path.sep}`)
+    ) {
+      throw new Error('Git returned an untracked path outside the repository.');
+    }
+    const stat = lstatSync(absolutePath);
+    hash.update('\0untracked\0');
+    hash.update(relativePath);
+    hash.update('\0');
+    if (stat.isSymbolicLink()) hash.update(readlinkSync(absolutePath));
+    else if (stat.isFile()) hash.update(readFileSync(absolutePath));
+  }
+  const fingerprint = hash.digest('hex');
+  return {
+    commit,
+    revision: `${commit}-dirty-${fingerprint.slice(0, 16)}`,
+    dirty: true,
+    fingerprint,
+  };
+}