@recordtimelabel/core 0.4.7 → 0.5.0

package/src/domain/group-identity.js

@@ -0,0 +1,456 @@
+import {fingerprintCanonicalJson} from './hash.js';
+import {
+  DEFAULT_UNKNOWN_CHANNEL,
+  DEFAULT_UNKNOWN_TITLE,
+  GROUP_ID_PREFIX,
+  TWITCH_STREAM_ANCHOR_TOLERANCE_MS,
+  collectNonVirtualRecords,
+  extractTwitchVodIdFromUrl,
+  extractYouTubeVideoIdFromUrl,
+  getFirstMatchingUrlValue,
+  getRecordTitle,
+  normalizeFallbackPlatform,
+  normalizeId,
+  normalizeIdList,
+  normalizeRecordPlatform,
+  normalizeText,
+  parseElapsedSeconds
+} from './shared.js';
+import {parseUtcMillis, roundDownToUtcMinuteIso, toCreatedAtMillis} from './time.js';
+
+export const RECORD_GROUP_IDENTITY_VERSION = 1;
+
+export const buildRecordTimeLabelStandaloneGroupIdentity = (
+  record,
+  fallbackPlatform,
+  unknownTitle = DEFAULT_UNKNOWN_TITLE
+) => {
+  const platform = normalizeRecordPlatform(record, fallbackPlatform);
+
+  if (platform === 'youtube') {
+    const videoId = normalizeText(record?.videoId) || getFirstMatchingUrlValue(record, extractYouTubeVideoIdFromUrl);
+    if (videoId) return `youtube:video:${videoId}`;
+  }
+
+  if (platform === 'twitch') {
+    const streamId = normalizeText(record?.streamId);
+    const streamCreatedAt = normalizeText(record?.streamCreatedAt || record?.streamStartedAt);
+    const channelHandle = normalizeText(
+      record?.channelHandle || record?.channelUsername || record?.username
+    ).toLowerCase();
+    const hasLiveIdentity = record?.isLiveStream === true || !!streamId || !!streamCreatedAt;
+
+    if (hasLiveIdentity) {
+      if (streamId) return `twitch:stream:${streamId}`;
+      if (channelHandle && streamCreatedAt) {
+        return `twitch:stream-start:${channelHandle}:${streamCreatedAt}`;
+      }
+    }
+
+    const vodId = normalizeText(record?.vodId) || getFirstMatchingUrlValue(record, extractTwitchVodIdFromUrl);
+    if (vodId) return `twitch:vod:${vodId}`;
+  }
+
+  return `legacy:${platform}:${getRecordTitle(record, unknownTitle)}`;
+};
+
+export const buildRecordTimeLabelStandaloneGroupId = (
+  record,
+  fallbackPlatform,
+  unknownTitle = DEFAULT_UNKNOWN_TITLE
+) => `${GROUP_ID_PREFIX}${buildRecordTimeLabelStandaloneGroupIdentity(record, fallbackPlatform, unknownTitle)}`;
+
+export const buildLegacyRecordTimeLabelGroupId = (
+  record,
+  fallbackPlatform,
+  unknownTitle = DEFAULT_UNKNOWN_TITLE
+) => `${GROUP_ID_PREFIX}${record?.title || unknownTitle}__${record?.platform || normalizeFallbackPlatform(fallbackPlatform)}`;
+
+const buildFallbackRecordGroupId = (
+  record,
+  fallbackPlatform,
+  unknownTitle = DEFAULT_UNKNOWN_TITLE
+) => `${GROUP_ID_PREFIX}legacy:${normalizeRecordPlatform(record, fallbackPlatform)}:${getRecordTitle(record, unknownTitle)}`;
+
+const getTwitchLiveIdentityParts = (record = {}, fallbackPlatform) => {
+  if (normalizeRecordPlatform(record, fallbackPlatform) !== 'twitch') {
+    return {
+      streamId: '',
+      streamStartKey: '',
+      vodId: '',
+      channelKey: '',
+      streamAnchorMs: null,
+      hasExactStreamStart: false
+    };
+  }
+
+  const streamId = normalizeText(record?.streamId);
+  const streamCreatedAt = normalizeText(record?.streamCreatedAt || record?.streamStartedAt);
+  const channelHandle = normalizeText(
+    record?.channelHandle || record?.channelUsername || record?.username
+  ).toLowerCase();
+  const vodId = normalizeText(record?.vodId) || getFirstMatchingUrlValue(record, extractTwitchVodIdFromUrl);
+  const explicitAnchorValue = streamCreatedAt || normalizeText(record?.vodStartAt || record?.vodPublishedAt);
+  const explicitAnchorMs = parseUtcMillis(explicitAnchorValue);
+  const createdAtMs = parseUtcMillis(record?.createdAt);
+  const elapsedSeconds = parseElapsedSeconds(record?.originalLiveTime || record?.liveTime);
+  const currentTimeSeconds = parseElapsedSeconds(record?.currentTime);
+  const inferredElapsed = elapsedSeconds === null ? currentTimeSeconds : elapsedSeconds;
+  const inferredAnchorMs = createdAtMs !== null && inferredElapsed !== null
+    ? createdAtMs - (inferredElapsed * 1000)
+    : null;
+
+  return {
+    streamId,
+    streamStartKey: channelHandle && streamCreatedAt
+      ? `twitch:stream-start:${channelHandle}:${streamCreatedAt}`
+      : '',
+    vodId,
+    channelKey: channelHandle || normalizeText(record?.streamerName || record?.channelName).toLowerCase(),
+    streamAnchorMs: explicitAnchorMs !== null
+      ? explicitAnchorMs
+      : inferredAnchorMs,
+    hasExactStreamStart: Boolean(streamCreatedAt && parseUtcMillis(streamCreatedAt) !== null)
+  };
+};
+
+const addAliasTarget = (aliasTargetsByGroupId, alias, canonicalId) => {
+  const normalizedAlias = normalizeId(alias);
+  const normalizedCanonicalId = normalizeId(canonicalId);
+  if (!normalizedAlias || !normalizedCanonicalId) return;
+  const existing = aliasTargetsByGroupId[normalizedAlias] || [];
+  if (existing.includes(normalizedCanonicalId)) return;
+  aliasTargetsByGroupId[normalizedAlias] = [...existing, normalizedCanonicalId];
+};
+
+const sortGroupIdsByLatestCreatedAt = (groupIds = [], groupsById = {}) => (
+  [...groupIds].sort((left, right) => {
+    const delta = (groupsById[right]?.latestCreatedAt || 0) - (groupsById[left]?.latestCreatedAt || 0);
+    if (delta !== 0) return delta;
+    return String(left).localeCompare(String(right));
+  })
+);
+
+export const buildRecordTimeLabelGroupIndex = ({
+  records = [],
+  fallbackPlatform,
+  unknownTitle = DEFAULT_UNKNOWN_TITLE
+} = {}) => {
+  const platform = normalizeFallbackPlatform(fallbackPlatform);
+  const safeRecords = collectNonVirtualRecords(records);
+  const seenIds = new Set();
+  const indexedRecords = [];
+  let skippedMissingIdCount = 0;
+  let skippedDuplicateIdCount = 0;
+
+  safeRecords.forEach((record) => {
+    const recordId = normalizeId(record?.id || record?.recordId);
+    if (!recordId) {
+      skippedMissingIdCount += 1;
+      return;
+    }
+    if (seenIds.has(recordId)) {
+      skippedDuplicateIdCount += 1;
+      return;
+    }
+    seenIds.add(recordId);
+    indexedRecords.push({...record, id: recordId});
+  });
+
+  const identityParts = indexedRecords.map((record) => getTwitchLiveIdentityParts(record, platform));
+  const parents = indexedRecords.map((_, index) => index);
+  const clusterStreamIds = identityParts.map((parts) => new Set(parts.streamId ? [parts.streamId] : []));
+  const clusterVodIds = identityParts.map((parts) => new Set(parts.vodId ? [parts.vodId] : []));
+  let conflictRefusalCount = 0;
+
+  const find = (index) => {
+    let root = index;
+    while (parents[root] !== root) root = parents[root];
+    while (parents[index] !== index) {
+      const next = parents[index];
+      parents[index] = root;
+      index = next;
+    }
+    return root;
+  };
+
+  const union = (left, right) => {
+    const leftRoot = find(left);
+    const rightRoot = find(right);
+    if (leftRoot === rightRoot) return true;
+    const mergedStreamIds = new Set([...clusterStreamIds[leftRoot], ...clusterStreamIds[rightRoot]]);
+    const mergedVodIds = new Set([...clusterVodIds[leftRoot], ...clusterVodIds[rightRoot]]);
+    if (mergedStreamIds.size > 1 || (mergedVodIds.size > 1 && mergedStreamIds.size === 0)) {
+      conflictRefusalCount += 1;
+      return false;
+    }
+    parents[rightRoot] = leftRoot;
+    clusterStreamIds[leftRoot] = mergedStreamIds;
+    clusterVodIds[leftRoot] = mergedVodIds;
+    return true;
+  };
+
+  const canShareTwitchStream = (left, right) => {
+    if (left.streamId && right.streamId && left.streamId !== right.streamId) return false;
+    if (left.vodId && right.vodId && left.vodId !== right.vodId) {
+      return Boolean(left.streamId && left.streamId === right.streamId);
+    }
+    return true;
+  };
+
+  const unionByExactIdentity = (getKey, canUnion = () => true) => {
+    const firstIndexByKey = new Map();
+    identityParts.forEach((parts, index) => {
+      const key = getKey(parts);
+      if (!key) return;
+      if (firstIndexByKey.has(key)) {
+        const firstIndex = firstIndexByKey.get(key);
+        if (canUnion(parts, identityParts[firstIndex])) union(index, firstIndex);
+      } else firstIndexByKey.set(key, index);
+    });
+  };
+
+  unionByExactIdentity((parts) => parts.streamId && `stream:${parts.streamId}`);
+  unionByExactIdentity(
+    (parts) => parts.streamStartKey && `start:${parts.streamStartKey}`,
+    canShareTwitchStream
+  );
+  unionByExactIdentity((parts) => parts.vodId && `vod:${parts.vodId}`, canShareTwitchStream);
+
+  const anchoredIndexesByChannel = new Map();
+  identityParts.forEach((parts, index) => {
+    if (!parts.channelKey || !Number.isFinite(parts.streamAnchorMs)) return;
+    const indexes = anchoredIndexesByChannel.get(parts.channelKey) || [];
+    indexes.push(index);
+    anchoredIndexesByChannel.set(parts.channelKey, indexes);
+  });
+  anchoredIndexesByChannel.forEach((indexes) => {
+    indexes.sort((left, right) => (
+      identityParts[left].streamAnchorMs - identityParts[right].streamAnchorMs
+    ));
+    for (let index = 1; index < indexes.length; index += 1) {
+      const previous = indexes[index - 1];
+      const current = indexes[index];
+      if (
+        canShareTwitchStream(identityParts[current], identityParts[previous]) &&
+        identityParts[current].streamAnchorMs - identityParts[previous].streamAnchorMs <=
+        TWITCH_STREAM_ANCHOR_TOLERANCE_MS
+      ) {
+        union(previous, current);
+      }
+    }
+  });
+
+  const clusterIndexes = new Map();
+  indexedRecords.forEach((_, index) => {
+    const root = find(index);
+    const indexes = clusterIndexes.get(root) || [];
+    indexes.push(index);
+    clusterIndexes.set(root, indexes);
+  });
+
+  const canonicalGroupIdByRoot = new Map();
+  const conflictGroupIds = [];
+  clusterIndexes.forEach((indexes, root) => {
+    const parts = indexes.map((index) => identityParts[index]);
+    const streamIds = [...new Set(parts.map((entry) => entry.streamId).filter(Boolean))];
+    const vodIds = [...new Set(parts.map((entry) => entry.vodId).filter(Boolean))];
+    if (streamIds.length > 1 || (vodIds.length > 1 && streamIds.length === 0)) {
+      conflictGroupIds.push(root);
+    }
+    if (indexes.length < 2) return;
+    const streamId = streamIds.slice().sort()[0];
+    const vodId = vodIds.slice().sort()[0];
+    const streamStartKey = parts.map((entry) => entry.streamStartKey).filter(Boolean).sort()[0];
+    if (streamId) {
+      canonicalGroupIdByRoot.set(root, `${GROUP_ID_PREFIX}twitch:stream:${streamId}`);
+    } else if (vodId) {
+      canonicalGroupIdByRoot.set(root, `${GROUP_ID_PREFIX}twitch:vod:${vodId}`);
+    } else if (streamStartKey) {
+      canonicalGroupIdByRoot.set(root, `${GROUP_ID_PREFIX}${streamStartKey}`);
+    } else {
+      const anchoredPart = parts
+        .filter((entry) => entry.channelKey && Number.isFinite(entry.streamAnchorMs))
+        .sort((left, right) => left.streamAnchorMs - right.streamAnchorMs)[0];
+      if (anchoredPart) {
+        const roundedAnchor = roundDownToUtcMinuteIso(anchoredPart.streamAnchorMs);
+        canonicalGroupIdByRoot.set(
+          root,
+          `${GROUP_ID_PREFIX}twitch:stream-inferred:${encodeURIComponent(anchoredPart.channelKey)}:${roundedAnchor}`
+        );
+      }
+    }
+  });
+
+  const groupIdByRecordId = {};
+  const groupsById = {};
+  const aliasTargetsByGroupId = {};
+  const conflictCanonicalIds = new Set();
+
+  indexedRecords.forEach((record, index) => {
+    const root = find(index);
+    const groupId = canonicalGroupIdByRoot.get(root) ||
+      buildRecordTimeLabelStandaloneGroupId(record, platform, unknownTitle);
+    groupIdByRecordId[record.id] = groupId;
+    const createdAt = toCreatedAtMillis(record);
+    const existing = groupsById[groupId];
+    groupsById[groupId] = {
+      id: groupId,
+      latestCreatedAt: Math.max(existing?.latestCreatedAt || 0, createdAt),
+      recordIds: [...(existing?.recordIds || []), record.id]
+    };
+    if (conflictGroupIds.includes(root)) conflictCanonicalIds.add(groupId);
+
+    addAliasTarget(aliasTargetsByGroupId, groupId, groupId);
+    addAliasTarget(
+      aliasTargetsByGroupId,
+      buildRecordTimeLabelStandaloneGroupId(record, platform, unknownTitle),
+      groupId
+    );
+    addAliasTarget(aliasTargetsByGroupId, buildLegacyRecordTimeLabelGroupId(record, platform, unknownTitle), groupId);
+    addAliasTarget(aliasTargetsByGroupId, buildFallbackRecordGroupId(record, platform, unknownTitle), groupId);
+  });
+
+  const groups = Object.values(groupsById).sort((left, right) => {
+    const delta = (right.latestCreatedAt || 0) - (left.latestCreatedAt || 0);
+    if (delta !== 0) return delta;
+    return left.id.localeCompare(right.id);
+  });
+
+  return {
+    groupIdByRecordId,
+    groups,
+    aliasTargetsByGroupId,
+    diagnostics: {
+      identityVersion: RECORD_GROUP_IDENTITY_VERSION,
+      fallbackPlatform: platform,
+      recordCount: indexedRecords.length,
+      groupCount: groups.length,
+      skippedMissingIdCount,
+      skippedDuplicateIdCount,
+      conflictRefusalCount,
+      conflictGroupIds: [...conflictCanonicalIds].sort()
+    }
+  };
+};
+
+const migrateGroupIdList = (groupIds = [], aliasTargetsByGroupId = {}, groupsById = {}) => {
+  const seen = new Set();
+  const result = [];
+  normalizeIdList(groupIds).forEach((groupId) => {
+    const mappedGroupIds = aliasTargetsByGroupId[groupId] || [groupId];
+    const orderedGroupIds = mappedGroupIds.length > 1
+      ? sortGroupIdsByLatestCreatedAt(mappedGroupIds, groupsById)
+      : mappedGroupIds;
+    orderedGroupIds.forEach((mappedGroupId) => {
+      if (!mappedGroupId || seen.has(mappedGroupId)) return;
+      seen.add(mappedGroupId);
+      result.push(mappedGroupId);
+    });
+  });
+  return result;
+};
+
+const groupsByIdFromIndex = (groupIndex) => {
+  const groupsById = {};
+  (groupIndex?.groups || []).forEach((group) => {
+    if (group?.id) groupsById[group.id] = group;
+  });
+  return groupsById;
+};
+
+export const canonicalizeRecordTimeLabelGroupView = ({
+  records = [],
+  groupIndex = null,
+  groupOrder = [],
+  expandedGroups = [],
+  fallbackPlatform,
+  unknownTitle = DEFAULT_UNKNOWN_TITLE
+} = {}) => {
+  const index = groupIndex || buildRecordTimeLabelGroupIndex({
+    records,
+    fallbackPlatform,
+    unknownTitle
+  });
+  const groupsById = groupsByIdFromIndex(index);
+  const visibleGroupIds = (index.groups || []).map((group) => group.id);
+  const migratedCurrentOrder = migrateGroupIdList(
+    groupOrder,
+    index.aliasTargetsByGroupId,
+    groupsById
+  );
+  const migratedExpandedGroups = migrateGroupIdList(
+    expandedGroups,
+    index.aliasTargetsByGroupId,
+    groupsById
+  );
+
+  let nextGroupOrder = [];
+  if (visibleGroupIds.length === 0) {
+    nextGroupOrder = migratedCurrentOrder.filter((groupId) => groupId.startsWith(GROUP_ID_PREFIX));
+  } else if (migratedCurrentOrder.length === 0) {
+    nextGroupOrder = sortGroupIdsByLatestCreatedAt(visibleGroupIds, groupsById);
+  } else {
+    const orderedVisibleGroups = migratedCurrentOrder.filter((groupId) => groupsById[groupId]);
+    const orderedVisibleSet = new Set(orderedVisibleGroups);
+    const newVisibleGroups = sortGroupIdsByLatestCreatedAt(
+      visibleGroupIds.filter((groupId) => !orderedVisibleSet.has(groupId)),
+      groupsById
+    );
+    const visibleSet = new Set([...newVisibleGroups, ...orderedVisibleGroups]);
+    const hiddenOrder = migratedCurrentOrder.filter((groupId) => (
+      groupId.startsWith(GROUP_ID_PREFIX) && !visibleSet.has(groupId)
+    ));
+    nextGroupOrder = [...newVisibleGroups, ...orderedVisibleGroups, ...hiddenOrder];
+  }
+
+  const previousGroupOrder = normalizeIdList(groupOrder);
+  const previousExpanded = normalizeIdList(expandedGroups);
+  const changed = previousGroupOrder.join('\u0000') !== nextGroupOrder.join('\u0000') ||
+    previousExpanded.join('\u0000') !== migratedExpandedGroups.join('\u0000');
+
+  return {
+    groupOrder: nextGroupOrder,
+    expandedGroups: migratedExpandedGroups,
+    changed,
+    diagnostics: {
+      identityVersion: RECORD_GROUP_IDENTITY_VERSION,
+      migratedAliasCount: previousGroupOrder.filter((groupId) => (
+        Boolean(index.aliasTargetsByGroupId[groupId]) &&
+        index.aliasTargetsByGroupId[groupId].join('\u0000') !== groupId
+      )).length,
+      newVisibleCount: nextGroupOrder.filter((groupId) => groupsById[groupId] && !previousGroupOrder.includes(groupId)).length,
+      retainedHiddenCount: nextGroupOrder.filter((groupId) => !groupsById[groupId]).length,
+      changed
+    }
+  };
+};
+
+export const buildRecordTimeLabelGroupMetadata = ({
+  records = [],
+  fallbackPlatform,
+  unknownTitle = DEFAULT_UNKNOWN_TITLE,
+  unknownChannel = DEFAULT_UNKNOWN_CHANNEL
+} = {}) => {
+  const platform = normalizeFallbackPlatform(fallbackPlatform);
+  let latestRecord = null;
+  let latestCreatedAt = Number.NEGATIVE_INFINITY;
+  collectNonVirtualRecords(records).forEach((record) => {
+    const createdAt = toCreatedAtMillis(record);
+    if (!latestRecord || createdAt >= latestCreatedAt) {
+      latestRecord = record;
+      latestCreatedAt = createdAt;
+    }
+  });
+  const safeRecord = latestRecord || {};
+  return {
+    title: getRecordTitle(safeRecord, unknownTitle),
+    streamerName: normalizeText(safeRecord.streamerName || safeRecord.channelName) || unknownChannel,
+    avatarUrl: safeRecord.avatarUrl || null,
+    platform: normalizeRecordPlatform(safeRecord, platform)
+  };
+};
+
+export const buildRecordTimeLabelGroupReorderOperationId = (previousOrder = [], nextOrder = []) => (
+  `group.reorder:canonical:${fingerprintCanonicalJson(normalizeIdList(previousOrder))}:${fingerprintCanonicalJson(normalizeIdList(nextOrder))}`
+);

package/src/domain/hash.js

@@ -0,0 +1,147 @@
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+
+const rotr = (value, bits) => (value >>> bits) | (value << (32 - bits));
+
+const toUtf8Bytes = (value) => {
+  const text = String(value);
+  if (typeof TextEncoder === 'function') {
+    return new TextEncoder().encode(text);
+  }
+  const bytes = [];
+  for (let index = 0; index < text.length; index += 1) {
+    let code = text.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff && index + 1 < text.length) {
+      const next = text.charCodeAt(index + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        code = ((code - 0xd800) << 10) + (next - 0xdc00) + 0x10000;
+        index += 1;
+      }
+    }
+    if (code < 0x80) bytes.push(code);
+    else if (code < 0x800) bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+    else if (code < 0x10000) {
+      bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+    } else {
+      bytes.push(
+        0xf0 | (code >> 18),
+        0x80 | ((code >> 12) & 0x3f),
+        0x80 | ((code >> 6) & 0x3f),
+        0x80 | (code & 0x3f)
+      );
+    }
+  }
+  return Uint8Array.from(bytes);
+};
+
+export const sha256Hex = (value) => {
+  const message = toUtf8Bytes(value);
+  const bitLength = message.length * 8;
+  const paddedLength = (((message.length + 9 + 63) >> 6) << 6);
+  const bytes = new Uint8Array(paddedLength);
+  bytes.set(message);
+  bytes[message.length] = 0x80;
+  const view = new DataView(bytes.buffer);
+  view.setUint32(paddedLength - 4, bitLength >>> 0);
+
+  let h0 = 0x6a09e667;
+  let h1 = 0xbb67ae85;
+  let h2 = 0x3c6ef372;
+  let h3 = 0xa54ff53a;
+  let h4 = 0x510e527f;
+  let h5 = 0x9b05688c;
+  let h6 = 0x1f83d9ab;
+  let h7 = 0x5be0cd19;
+  const w = new Uint32Array(64);
+
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      w[index] = view.getUint32(offset + (index * 4));
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rotr(w[index - 15], 7) ^ rotr(w[index - 15], 18) ^ (w[index - 15] >>> 3);
+      const s1 = rotr(w[index - 2], 17) ^ rotr(w[index - 2], 19) ^ (w[index - 2] >>> 10);
+      w[index] = (w[index - 16] + s0 + w[index - 7] + s1) >>> 0;
+    }
+
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let index = 0; index < 64; index += 1) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = (e & f) ^ (~e & g);
+      const temp1 = (h + S1 + ch + K[index] + w[index]) >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const temp2 = (S0 + maj) >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = (d + temp1) >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (temp1 + temp2) >>> 0;
+    }
+    h0 = (h0 + a) >>> 0;
+    h1 = (h1 + b) >>> 0;
+    h2 = (h2 + c) >>> 0;
+    h3 = (h3 + d) >>> 0;
+    h4 = (h4 + e) >>> 0;
+    h5 = (h5 + f) >>> 0;
+    h6 = (h6 + g) >>> 0;
+    h7 = (h7 + h) >>> 0;
+  }
+
+  return [h0, h1, h2, h3, h4, h5, h6, h7]
+    .map((word) => word.toString(16).padStart(8, '0'))
+    .join('');
+};
+
+export const canonicalizeJson = (value) => {
+  if (value === null) return 'null';
+  const type = typeof value;
+  if (type === 'number') {
+    if (!Number.isFinite(value)) return 'null';
+    return JSON.stringify(value);
+  }
+  if (type === 'boolean') return value ? 'true' : 'false';
+  if (type === 'string') return JSON.stringify(value);
+  if (type !== 'object') return undefined;
+
+  if (Array.isArray(value)) {
+    const items = value.map((entry) => {
+      const serialized = canonicalizeJson(entry);
+      return serialized === undefined ? 'null' : serialized;
+    });
+    return `[${items.join(',')}]`;
+  }
+
+  const keys = Object.keys(value).filter((key) => value[key] !== undefined).sort();
+  const fields = [];
+  keys.forEach((key) => {
+    const serialized = canonicalizeJson(value[key]);
+    if (serialized === undefined) return;
+    fields.push(`${JSON.stringify(key)}:${serialized}`);
+  });
+  return `{${fields.join(',')}}`;
+};
+
+export const digestCanonicalJson = (value) => sha256Hex(canonicalizeJson(value));
+
+export const fingerprintCanonicalJson = (value, length = 16) => (
+  digestCanonicalJson(value).slice(0, length)
+);