@pixel-point/toolcraft 0.0.15 → 0.0.16

package/templates/runtime/model-import/canonical/model-document-worker-memory.ts

@@ -0,0 +1,365 @@
+import type { ToolcraftModelDocument } from "./model-document";
+import type { ToolcraftCanonicalModelLimits } from "./model-document-limits";
+import { throwModelDocumentCodecError } from "./model-document-codec-error";
+import {
+  MODEL_DOCUMENT_CODEC_V2,
+  getModelDocumentCodecFormat,
+} from "./model-document-codec-format";
+
+const WORKER_FIXED_OVERHEAD_BYTES = 16n * 1024n;
+const ENCODE_METADATA_PEAK_FACTOR = 42n;
+const DECODE_METADATA_UTF_COPIES = 4n;
+const DECODE_METADATA_OBJECT_COPIES = 36n;
+
+export type ToolcraftCanonicalEncodeWorkerMemoryShape = Readonly<{
+  childReferenceCount: number;
+  maximumNodeId: string;
+  maximumNodeName: string;
+  maximumPrimitiveId: string;
+  nodeCount: number;
+  nodePrimitiveReferenceCount: number;
+  payloadByteLength: number;
+  primitiveCount: number;
+  provenance: ToolcraftModelDocument["provenance"];
+  rootNodeCount: number;
+}>;
+
+function workerLimit(limits: ToolcraftCanonicalModelLimits): bigint {
+  return BigInt(Math.floor(limits.maxEstimatedWorkerBytes));
+}
+
+function assertWithinWorkerLimit(
+  estimatedBytes: bigint,
+  operation: "decode" | "encode",
+  limits: ToolcraftCanonicalModelLimits,
+): void {
+  if (estimatedBytes <= workerLimit(limits)) {
+    return;
+  }
+
+  throwModelDocumentCodecError(
+    "estimated-worker-memory-limit-exceeded",
+    `workerMemory.${operation}`,
+    `Canonical ${operation} requires an estimated ${estimatedBytes.toString()} worker bytes, exceeding maxEstimatedWorkerBytes ${limits.maxEstimatedWorkerBytes}.`,
+  );
+}
+
+export function assertCanonicalWorkerMemoryFloor(
+  operation: "decode" | "encode",
+  limits: ToolcraftCanonicalModelLimits,
+): void {
+  assertWithinWorkerLimit(WORKER_FIXED_OVERHEAD_BYTES, operation, limits);
+}
+
+export function assertToolcraftModelDecodeInputWorkerMemory(
+  envelopeByteLength: number,
+  limits: ToolcraftCanonicalModelLimits,
+): void {
+  assertWithinWorkerLimit(
+    WORKER_FIXED_OVERHEAD_BYTES + BigInt(envelopeByteLength) * 2n,
+    "decode",
+    limits,
+  );
+}
+
+export function exceedsOwnedEncodeGeometryWorkerMemory(
+  payloadByteLength: number,
+  limits: ToolcraftCanonicalModelLimits,
+): boolean {
+  return (
+    WORKER_FIXED_OVERHEAD_BYTES + BigInt(payloadByteLength) * 4n >
+    workerLimit(limits)
+  );
+}
+
+function jsonStringByteUpperBound(value: string): bigint {
+  let bytes = 2n;
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit === 0x22 || codeUnit === 0x5c) {
+      bytes += 2n;
+    } else if (codeUnit <= 0x1f) {
+      bytes += 6n;
+    } else if (codeUnit <= 0x7f) {
+      bytes += 1n;
+    } else if (codeUnit <= 0x7ff) {
+      bytes += 2n;
+    } else if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        bytes += 4n;
+        index += 1;
+      } else {
+        bytes += 6n;
+      }
+    } else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+      bytes += 6n;
+    } else {
+      bytes += 3n;
+    }
+  }
+  return bytes;
+}
+
+function stringStorageBytes(value: string): bigint {
+  return 32n + jsonStringByteUpperBound(value);
+}
+
+function arrayStorageBytes(length: number): bigint {
+  return 64n + BigInt(length) * 16n;
+}
+
+function boundsStorageBytes(): bigint {
+  return 256n + arrayStorageBytes(3) * 2n + 6n * 32n;
+}
+
+function estimateProvenanceStorageBytes(
+  provenance: ToolcraftModelDocument["provenance"],
+): bigint {
+  let bytes = 1024n;
+  bytes += stringStorageBytes(provenance.adapterVersion);
+  bytes += stringStorageBytes(provenance.sourceFormat);
+  bytes += arrayStorageBytes(provenance.operations.length);
+  for (const operation of provenance.operations) {
+    bytes += stringStorageBytes(operation);
+  }
+
+  if (provenance.repair !== undefined) {
+    bytes += 1024n;
+    bytes += stringStorageBytes(provenance.repair.algorithmVersion);
+    bytes += stringStorageBytes(provenance.repair.planDigest);
+    bytes += stringStorageBytes(provenance.repair.recipeId);
+    bytes += arrayStorageBytes(provenance.repair.operations.length);
+    for (const operation of provenance.repair.operations) {
+      bytes += stringStorageBytes(operation);
+    }
+  }
+
+  return bytes;
+}
+
+function estimateAppearanceMetadataStorageBytes(
+  document: ToolcraftModelDocument,
+): bigint {
+  if (document.version === 1) return 0n;
+
+  let bytes = arrayStorageBytes(document.materials.length);
+  bytes += arrayStorageBytes(document.textures.length);
+
+  for (const texture of document.textures) {
+    bytes += 1024n;
+    bytes += stringStorageBytes(texture.id);
+    bytes += stringStorageBytes(texture.mimeType);
+    bytes += stringStorageBytes(texture.colorSpace);
+    bytes += stringStorageBytes(texture.contentDigest);
+    bytes += stringStorageBytes(texture.resourceRef);
+    bytes += 512n;
+  }
+
+  for (const material of document.materials) {
+    bytes += 2048n + stringStorageBytes(material.id);
+    bytes += arrayStorageBytes(material.baseColor.length);
+    bytes += arrayStorageBytes(material.emissive.length);
+    for (const slot of [
+      material.baseColorTexture,
+      material.emissiveTexture,
+      material.metallicRoughnessTexture,
+      material.normalTexture,
+      material.occlusionTexture,
+    ]) {
+      if (slot !== undefined) {
+        bytes += 512n + stringStorageBytes(slot.textureId);
+      }
+    }
+  }
+
+  for (const primitive of document.primitives) {
+    if (primitive.materialId !== undefined) {
+      bytes += stringStorageBytes(primitive.materialId);
+    }
+    if (primitive.colors !== undefined) {
+      bytes += 256n;
+    }
+    if (primitive.textureCoordinates !== undefined) {
+      bytes += arrayStorageBytes(primitive.textureCoordinates.length);
+      bytes += BigInt(primitive.textureCoordinates.length) * 256n;
+    }
+  }
+
+  return bytes;
+}
+
+function estimateMetadataStorageBytes(document: ToolcraftModelDocument): bigint {
+  let bytes = 4n * 1024n + boundsStorageBytes();
+  bytes += arrayStorageBytes(document.nodes.length);
+  bytes += arrayStorageBytes(document.primitives.length);
+  bytes += arrayStorageBytes(document.rootNodeIds.length);
+
+  for (const rootNodeId of document.rootNodeIds) {
+    bytes += stringStorageBytes(rootNodeId);
+  }
+
+  for (const node of document.nodes) {
+    bytes += 512n + stringStorageBytes(node.id) + stringStorageBytes(node.name);
+    bytes += arrayStorageBytes(node.children.length);
+    bytes += arrayStorageBytes(node.primitiveIds.length);
+    bytes += arrayStorageBytes(node.localMatrix.length) + 16n * 32n;
+    for (const child of node.children) {
+      bytes += stringStorageBytes(child);
+    }
+    for (const primitiveId of node.primitiveIds) {
+      bytes += stringStorageBytes(primitiveId);
+    }
+  }
+
+  for (const primitive of document.primitives) {
+    bytes += 1024n + boundsStorageBytes() + stringStorageBytes(primitive.id);
+  }
+
+  bytes += estimateProvenanceStorageBytes(document.provenance);
+  bytes += estimateAppearanceMetadataStorageBytes(document);
+
+  return bytes;
+}
+
+function boundedCount(value: number): bigint {
+  return Number.isSafeInteger(value) && value >= 0
+    ? BigInt(value)
+    : BigInt(Number.MAX_SAFE_INTEGER);
+}
+
+function arrayStorageBytesForCount(length: bigint): bigint {
+  return 64n + length * 16n;
+}
+
+function estimateMetadataStorageBytesForShape(
+  shape: ToolcraftCanonicalEncodeWorkerMemoryShape,
+): bigint {
+  const childReferenceCount = boundedCount(shape.childReferenceCount);
+  const nodeCount = boundedCount(shape.nodeCount);
+  const nodePrimitiveReferenceCount = boundedCount(
+    shape.nodePrimitiveReferenceCount,
+  );
+  const primitiveCount = boundedCount(shape.primitiveCount);
+  const rootNodeCount = boundedCount(shape.rootNodeCount);
+  const nodeIdBytes = stringStorageBytes(shape.maximumNodeId);
+  const nodeNameBytes = stringStorageBytes(shape.maximumNodeName);
+  const primitiveIdBytes = stringStorageBytes(shape.maximumPrimitiveId);
+
+  let bytes = 4n * 1024n + boundsStorageBytes();
+  bytes += arrayStorageBytesForCount(nodeCount);
+  bytes += arrayStorageBytesForCount(primitiveCount);
+  bytes += arrayStorageBytesForCount(rootNodeCount);
+  bytes += rootNodeCount * nodeIdBytes;
+
+  const nodeBaseBytes =
+    512n +
+    nodeIdBytes +
+    nodeNameBytes +
+    arrayStorageBytes(0) * 2n +
+    arrayStorageBytes(16) +
+    16n * 32n;
+  bytes += nodeCount * nodeBaseBytes;
+  bytes += childReferenceCount * (16n + nodeIdBytes);
+  bytes += nodePrimitiveReferenceCount * (16n + primitiveIdBytes);
+  bytes += primitiveCount * (1024n + boundsStorageBytes() + primitiveIdBytes);
+  bytes += estimateProvenanceStorageBytes(shape.provenance);
+  return bytes;
+}
+
+function payloadByteLength(document: ToolcraftModelDocument): bigint {
+  let bytes = 0n;
+  for (const primitive of document.primitives) {
+    bytes += BigInt(primitive.positions.byteLength);
+    bytes += BigInt(primitive.normals?.byteLength ?? 0);
+    bytes += BigInt(primitive.indices.byteLength);
+  }
+  if (document.version === 2) {
+    for (const primitive of document.primitives) {
+      bytes += BigInt(primitive.colors?.values.byteLength ?? 0);
+      for (const coordinates of primitive.textureCoordinates ?? []) {
+        bytes += BigInt(coordinates.values.byteLength);
+      }
+    }
+  }
+  return bytes;
+}
+
+function estimateEncodeWorkerBytes(
+  payloadBytes: bigint,
+  metadataBytes: bigint,
+  payloadOffset: number,
+): bigint {
+  const outputEnvelopeBytes =
+    BigInt(payloadOffset) + metadataBytes + payloadBytes;
+
+  return (
+    WORKER_FIXED_OVERHEAD_BYTES +
+    payloadBytes * 3n +
+    outputEnvelopeBytes +
+    metadataBytes * ENCODE_METADATA_PEAK_FACTOR
+  );
+}
+
+function safeNumber(value: bigint): number {
+  return value > BigInt(Number.MAX_SAFE_INTEGER)
+    ? Number.MAX_SAFE_INTEGER
+    : Number(value);
+}
+
+export function estimateToolcraftModelEncodeWorkerBytes(
+  document: ToolcraftModelDocument,
+): number {
+  return safeNumber(
+    estimateEncodeWorkerBytes(
+      payloadByteLength(document),
+      estimateMetadataStorageBytes(document),
+      getModelDocumentCodecFormat(document.version).payloadOffset,
+    ),
+  );
+}
+
+export function estimateToolcraftCanonicalEncodeWorkerBytesForShape(
+  shape: ToolcraftCanonicalEncodeWorkerMemoryShape,
+): number {
+  return safeNumber(
+    estimateEncodeWorkerBytes(
+      boundedCount(shape.payloadByteLength),
+      estimateMetadataStorageBytesForShape(shape),
+      MODEL_DOCUMENT_CODEC_V2.payloadOffset,
+    ),
+  );
+}
+
+export function assertToolcraftModelEncodeWorkerMemory(
+  document: ToolcraftModelDocument,
+  limits: ToolcraftCanonicalModelLimits,
+): void {
+  // Source geometry, owned snapshot, encoded sections, and final envelope
+  // coexist. Metadata covers both graphs, JSON, UTF-8, and traversal arrays.
+  const estimatedBytes = estimateEncodeWorkerBytes(
+    payloadByteLength(document),
+    estimateMetadataStorageBytes(document),
+    getModelDocumentCodecFormat(document.version).payloadOffset,
+  );
+  assertWithinWorkerLimit(estimatedBytes, "encode", limits);
+}
+
+export function assertToolcraftModelDecodeWorkerMemory(
+  envelopeByteLength: number,
+  metadataByteLength: number,
+  payloadByteLength: number,
+  limits: ToolcraftCanonicalModelLimits,
+): void {
+  const metadataBytes = BigInt(metadataByteLength);
+  const estimatedBytes =
+    WORKER_FIXED_OVERHEAD_BYTES +
+    BigInt(envelopeByteLength) * 2n +
+    BigInt(payloadByteLength) * 2n +
+    metadataBytes * DECODE_METADATA_UTF_COPIES +
+    metadataBytes * DECODE_METADATA_OBJECT_COPIES;
+
+  // Both caller and owned envelope copies coexist. Metadata factors cover
+  // decoded strings, JSON's graph, the canonical clone, and validation copy.
+  assertWithinWorkerLimit(estimatedBytes, "decode", limits);
+}

package/templates/runtime/model-import/canonical/model-document.ts

@@ -0,0 +1,187 @@
+import type { ToolcraftModelFormat } from "../../schema/types";
+
+export type ToolcraftModelBounds = {
+  max: readonly [number, number, number];
+  min: readonly [number, number, number];
+};
+
+export type ToolcraftModelCanonicalizationOperation =
+  | "deterministic-triangulation"
+  | "sequential-indexing";
+
+export type ToolcraftModelRepairOperationType =
+  | "compact-unused-vertices"
+  | "recalculate-bounds"
+  | "regenerate-normals"
+  | "remove-duplicate-triangles"
+  | "remove-invalid-triangles"
+  | "repair-local-winding";
+
+export const TOOLCRAFT_MODEL_CANONICALIZATION_OPERATIONS = Object.freeze([
+  "deterministic-triangulation",
+  "sequential-indexing",
+] as const satisfies readonly ToolcraftModelCanonicalizationOperation[]);
+
+export const TOOLCRAFT_MODEL_REPAIR_OPERATIONS = Object.freeze([
+  "compact-unused-vertices",
+  "recalculate-bounds",
+  "regenerate-normals",
+  "remove-duplicate-triangles",
+  "remove-invalid-triangles",
+  "repair-local-winding",
+] as const satisfies readonly ToolcraftModelRepairOperationType[]);
+
+export const TOOLCRAFT_MODEL_SOURCE_FORMATS = Object.freeze([
+  "fbx",
+  "glb",
+  "gltf",
+  "obj",
+  "ply",
+  "stl",
+] as const satisfies readonly ToolcraftModelFormat[]);
+
+type ToolcraftModelCanonicalizationProvenanceBase<Version extends 1 | 2> = {
+  adapterVersion: string;
+  canonicalSchemaVersion: Version;
+  operations: readonly ToolcraftModelCanonicalizationOperation[];
+  repair?: {
+    algorithmVersion: string;
+    operations: readonly ToolcraftModelRepairOperationType[];
+    planDigest: string;
+    recipeId: string;
+  };
+  sourceFormat: ToolcraftModelFormat;
+};
+
+export type ToolcraftModelCanonicalizationProvenanceV1 =
+  ToolcraftModelCanonicalizationProvenanceBase<1>;
+export type ToolcraftModelCanonicalizationProvenanceV2 =
+  ToolcraftModelCanonicalizationProvenanceBase<2>;
+export type ToolcraftModelCanonicalizationProvenance =
+  | ToolcraftModelCanonicalizationProvenanceV1
+  | ToolcraftModelCanonicalizationProvenanceV2;
+
+export type ToolcraftModelNode = {
+  children: readonly string[];
+  id: string;
+  localMatrix: readonly [
+    number, number, number, number,
+    number, number, number, number,
+    number, number, number, number,
+    number, number, number, number,
+  ];
+  name: string;
+  primitiveIds: readonly string[];
+};
+
+type ToolcraftModelPrimitiveGeometry = {
+  bounds: ToolcraftModelBounds;
+  id: string;
+  indices: Uint32Array;
+  normals?: Float32Array;
+  positions: Float32Array;
+};
+
+export type ToolcraftModelPrimitiveV1 = ToolcraftModelPrimitiveGeometry;
+
+export type ToolcraftModelTextureColorSpace = "linear" | "srgb";
+export type ToolcraftModelAlphaMode = "blend" | "mask" | "opaque";
+
+export type ToolcraftModelTextureSampler = Readonly<{
+  magFilter: "linear" | "nearest";
+  minFilter:
+    | "linear"
+    | "linear-mipmap-linear"
+    | "linear-mipmap-nearest"
+    | "nearest"
+    | "nearest-mipmap-linear"
+    | "nearest-mipmap-nearest";
+  wrapS: "clamp-to-edge" | "mirrored-repeat" | "repeat";
+  wrapT: "clamp-to-edge" | "mirrored-repeat" | "repeat";
+}>;
+
+export type ToolcraftModelTexture = Readonly<{
+  colorSpace: ToolcraftModelTextureColorSpace;
+  contentDigest: string;
+  height: number;
+  id: string;
+  mimeType: "image/avif" | "image/jpeg" | "image/png" | "image/webp";
+  resourceRef: string;
+  sampler: ToolcraftModelTextureSampler;
+  width: number;
+}>;
+
+export type ToolcraftModelTextureSlot = Readonly<{
+  scale?: number;
+  strength?: number;
+  texCoord: 0 | 1;
+  textureId: string;
+}>;
+
+export type ToolcraftModelMaterial = Readonly<{
+  alphaCutoff: number;
+  alphaMode: ToolcraftModelAlphaMode;
+  baseColor: readonly [number, number, number];
+  baseColorTexture?: ToolcraftModelTextureSlot;
+  doubleSided: boolean;
+  emissive: readonly [number, number, number];
+  emissiveTexture?: ToolcraftModelTextureSlot;
+  id: string;
+  metallic: number;
+  metallicRoughnessTexture?: ToolcraftModelTextureSlot;
+  normalTexture?: ToolcraftModelTextureSlot;
+  occlusionTexture?: ToolcraftModelTextureSlot;
+  opacity: number;
+  roughness: number;
+  usesVertexColor: boolean;
+}>;
+
+export type ToolcraftModelVertexColors = Readonly<{
+  components: 3 | 4;
+  values: Float32Array;
+}>;
+
+export type ToolcraftModelTextureCoordinates = Readonly<{
+  set: 0 | 1;
+  values: Float32Array;
+}>;
+
+export type ToolcraftModelPrimitiveV2 = ToolcraftModelPrimitiveV1 & Readonly<{
+  colors?: ToolcraftModelVertexColors;
+  materialId?: string;
+  textureCoordinates?: readonly ToolcraftModelTextureCoordinates[];
+}>;
+
+export type ToolcraftModelPrimitive = ToolcraftModelPrimitiveV1;
+
+export type ToolcraftModelDocumentV1 = {
+  bounds: ToolcraftModelBounds;
+  nodes: readonly ToolcraftModelNode[];
+  primitives: readonly ToolcraftModelPrimitive[];
+  provenance: ToolcraftModelCanonicalizationProvenanceV1;
+  rootNodeIds: readonly string[];
+  version: 1;
+};
+
+export type ToolcraftModelDocumentV2 = Readonly<{
+  bounds: ToolcraftModelBounds;
+  materials: readonly ToolcraftModelMaterial[];
+  nodes: readonly ToolcraftModelNode[];
+  primitives: readonly ToolcraftModelPrimitiveV2[];
+  provenance: ToolcraftModelCanonicalizationProvenanceV2;
+  rootNodeIds: readonly string[];
+  textures: readonly ToolcraftModelTexture[];
+  version: 2;
+}>;
+
+export type ToolcraftModelDocument =
+  | ToolcraftModelDocumentV1
+  | ToolcraftModelDocumentV2;
+
+export const TOOLCRAFT_MODEL_FALLBACK_APPEARANCE = Object.freeze({
+  alpha: 1,
+  baseColorLinear: Object.freeze([0.8, 0.8, 0.8] as const),
+  emissiveLinear: Object.freeze([0, 0, 0] as const),
+  metallic: 0,
+  roughness: 0.5,
+});

package/templates/runtime/model-import/canonical/sha256.ts

@@ -0,0 +1,144 @@
+const SHA256_CONSTANTS = 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,
+]);
+
+function rotateRight(value: number, bits: number): number {
+  return (value >>> bits) | (value << (32 - bits));
+}
+
+function processBlock(
+  bytes: Uint8Array,
+  offset: number,
+  state: Uint32Array,
+  words: Uint32Array,
+): void {
+  for (let index = 0; index < 16; index += 1) {
+    const wordOffset = offset + index * 4;
+    words[index] = (
+      (bytes[wordOffset]! << 24) |
+      (bytes[wordOffset + 1]! << 16) |
+      (bytes[wordOffset + 2]! << 8) |
+      bytes[wordOffset + 3]!
+    ) >>> 0;
+  }
+
+  for (let index = 16; index < 64; index += 1) {
+    const previous15 = words[index - 15]!;
+    const previous2 = words[index - 2]!;
+    const sigma0 =
+      rotateRight(previous15, 7) ^
+      rotateRight(previous15, 18) ^
+      (previous15 >>> 3);
+    const sigma1 =
+      rotateRight(previous2, 17) ^
+      rotateRight(previous2, 19) ^
+      (previous2 >>> 10);
+    words[index] = (
+      words[index - 16]! +
+      sigma0 +
+      words[index - 7]! +
+      sigma1
+    ) >>> 0;
+  }
+
+  let a = state[0]!;
+  let b = state[1]!;
+  let c = state[2]!;
+  let d = state[3]!;
+  let e = state[4]!;
+  let f = state[5]!;
+  let g = state[6]!;
+  let h = state[7]!;
+
+  for (let index = 0; index < 64; index += 1) {
+    const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+    const choice = (e & f) ^ (~e & g);
+    const temporary1 = (
+      h +
+      sum1 +
+      choice +
+      SHA256_CONSTANTS[index]! +
+      words[index]!
+    ) >>> 0;
+    const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+    const majority = (a & b) ^ (a & c) ^ (b & c);
+    const temporary2 = (sum0 + majority) >>> 0;
+
+    h = g;
+    g = f;
+    f = e;
+    e = (d + temporary1) >>> 0;
+    d = c;
+    c = b;
+    b = a;
+    a = (temporary1 + temporary2) >>> 0;
+  }
+
+  state[0] = (state[0]! + a) >>> 0;
+  state[1] = (state[1]! + b) >>> 0;
+  state[2] = (state[2]! + c) >>> 0;
+  state[3] = (state[3]! + d) >>> 0;
+  state[4] = (state[4]! + e) >>> 0;
+  state[5] = (state[5]! + f) >>> 0;
+  state[6] = (state[6]! + g) >>> 0;
+  state[7] = (state[7]! + h) >>> 0;
+}
+
+export function sha256(bytes: Uint8Array): Uint8Array {
+  const state = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  ]);
+  const words = new Uint32Array(64);
+  const completeBytes = bytes.byteLength - (bytes.byteLength % 64);
+
+  for (let offset = 0; offset < completeBytes; offset += 64) {
+    processBlock(bytes, offset, state, words);
+  }
+
+  const remainder = bytes.byteLength - completeBytes;
+  const tailLength = remainder < 56 ? 64 : 128;
+  const tail = new Uint8Array(tailLength);
+  tail.set(bytes.subarray(completeBytes));
+  tail[remainder] = 0x80;
+  new DataView(tail.buffer).setBigUint64(
+    tailLength - 8,
+    BigInt(bytes.byteLength) * 8n,
+    false,
+  );
+
+  for (let offset = 0; offset < tailLength; offset += 64) {
+    processBlock(tail, offset, state, words);
+  }
+
+  const digest = new Uint8Array(32);
+  const digestView = new DataView(digest.buffer);
+  for (let index = 0; index < state.length; index += 1) {
+    digestView.setUint32(index * 4, state[index]!, false);
+  }
+  return digest;
+}
+
+export function bytesToHex(bytes: Uint8Array): string {
+  let result = "";
+  for (const byte of bytes) {
+    result += byte.toString(16).padStart(2, "0");
+  }
+  return result;
+}
+