velocious 1.0.643 → 1.0.645

package/src/testing/velocious-runner-reporter.js

@@ -0,0 +1,264 @@
+// @ts-check
+
+import { addTrackedStackToError } from "../utils/with-tracked-stack.js"
+import BacktraceCleaner from "../utils/backtrace-cleaner-node.js"
+import picocolors from "picocolors"
+import restArgsError from "../utils/rest-args-error.js"
+import { testEvents } from "./test.js"
+
+/** @typedef {import("@velocious/testing/runner").TestDeclaration} PackageTestDeclaration */
+
+/** Stops package traversal after framework-owned connection quarantine. */
+export class AbortRemainingTestsError extends Error {}
+
+export default class VelociousRunnerReporter {
+  /**
+   * Creates the legacy event and result projection adapter.
+   * @param {object} args - Constructor arguments.
+   * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+   */
+  constructor({testRunner, ...restArgs}) {
+    restArgsError(restArgs)
+    this.testRunner = testRunner
+    /** @type {WeakMap<PackageTestDeclaration, import("./test-runner.js").AttemptConsoleOutput[]>} */
+    this.attemptConsoleOutputs = new WeakMap()
+    /** @type {PackageTestDeclaration | undefined} */
+    this.activeTest = undefined
+  }
+
+  /**
+   * Translates one awaited package runner event into the legacy contract.
+   * @param {import("@velocious/testing/runner").RunnerEvent} event - Structured package event.
+   * @returns {Promise<void>} - Resolves after legacy listeners finish.
+   */
+  async onEvent(event) {
+    if (event.type === "test:start") {
+      this.activeTest = this.testRunner.findTestDeclaration(event.fullName)
+      if (this.activeTest) {
+        const metadata = this.testRunner.testMetadata(this.activeTest)
+        console.log(`${" ".repeat(metadata.descriptions.length * 2)}it ${metadata.testDescription}`)
+      }
+      return
+    }
+
+    if (event.type === "attempt:finish") {
+      await this.reportAttemptEvent(event)
+      return
+    }
+
+    if (event.type === "test:finish") {
+      await this.reportTestEvent(event)
+      return
+    }
+
+    if (event.type === "run:finish") this.testRunner.recordPackageResult(event.result)
+  }
+
+  /**
+   * Projects attempt failure/retry events while retaining the raw thrown value.
+   * @param {import("@velocious/testing/runner").RunnerEvent} event - Attempt event.
+   * @returns {Promise<void>} - Resolves after listeners finish.
+   */
+  async reportAttemptEvent(event) {
+    const test = this.activeTest || this.testRunner.findTestDeclaration(event.fullName)
+
+    if (!test) throw new Error(`Package runner attempt did not match a declaration: ${event.fullName}`)
+
+    // Narrows the structured event payload for this event discriminator.
+    const attempt = /** @type {import("@velocious/testing/runner").TestAttemptResult} */ (event.attempt)
+    const outcome = this.testRunner.attemptOutcome(test, attempt.attemptNumber)
+    const attemptConsoleOutputs = this.attemptConsoleOutputs.get(test) || []
+
+    if (attempt.consoleOutput) {
+      attemptConsoleOutputs.push({attemptNumber: attempt.attemptNumber, output: attempt.consoleOutput.trimEnd()})
+      this.attemptConsoleOutputs.set(test, attemptConsoleOutputs)
+    }
+
+    const retryCount = this.testRunner.retryCount(test)
+    const failed = outcome?.failed ?? Boolean(attempt.error)
+    const error = outcome?.error
+    const retriesUsed = Math.min(attempt.attemptNumber, retryCount)
+    const willRetry = failed && !outcome?.abortRemainingTests && attempt.attemptNumber <= retryCount
+    const {descriptions, testDescription} = this.testRunner.testMetadata(test)
+    const compatibility = this.testRunner.testData(test)
+
+    if (failed) {
+      await this.emitEvent("testAttemptFailed", {
+        configuration: this.testRunner.getConfiguration(),
+        descriptions,
+        error,
+        attemptNumber: attempt.attemptNumber,
+        nextAttempt: willRetry ? attempt.attemptNumber + 1 : undefined,
+        retriesUsed,
+        retryCount,
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
+        testDescription,
+        testRunner: this.testRunner,
+        willRetry
+      })
+    }
+
+    if (willRetry) {
+      console.warn(picocolors.red(`${" ".repeat(descriptions.length * 2)}  Retrying (${retriesUsed}/${retryCount}) after error: ${error instanceof Error ? error.message : String(error)}`))
+      await this.emitEvent("testRetrying", {
+        configuration: this.testRunner.getConfiguration(),
+        descriptions,
+        error,
+        nextAttempt: attempt.attemptNumber + 1,
+        retriesUsed,
+        retryCount,
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
+        testDescription,
+        testRunner: this.testRunner
+      })
+    }
+
+    if (attempt.attemptNumber > 1) {
+      await this.emitEvent("testRetried", {
+        configuration: this.testRunner.getConfiguration(),
+        descriptions,
+        error,
+        attemptNumber: attempt.attemptNumber,
+        retriesUsed,
+        retryCount,
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
+        testDescription,
+        testRunner: this.testRunner
+      })
+    }
+
+    if (outcome?.abortRemainingTests) {
+      const metadata = this.testRunner.testMetadata(test)
+
+      this.testRunner.recordTestDuration({
+        durationMs: attempt.durationMs,
+        filePath: compatibility.testData.filePath ?? "<unknown>",
+        fullDescription: metadata.fullDescription,
+        line: compatibility.testData.line ?? 0
+      })
+      await this.reportFailedTest({
+        attemptConsoleOutputs,
+        descriptions,
+        error,
+        leftPadding: " ".repeat(descriptions.length * 2),
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
+        testDescription
+      })
+      this.testRunner.completeTestDeclaration(test)
+      this.activeTest = undefined
+      throw new AbortRemainingTestsError("Velocious quarantined an attempt-owned database connection")
+    }
+  }
+
+  /**
+   * Projects final package result accounting and failures.
+   * @param {import("@velocious/testing/runner").RunnerEvent} event - Test result event.
+   * @returns {Promise<void>} - Resolves after listeners finish.
+   */
+  async reportTestEvent(event) {
+    // Narrows the structured event payload for this event discriminator.
+    const packageTestResult = /** @type {import("@velocious/testing/runner").TestResult} */ (event.test)
+    const test = this.activeTest || this.testRunner.findTestDeclaration(packageTestResult.fullName)
+
+    if (!test) throw new Error(`Package runner result did not match a declaration: ${packageTestResult.fullName}`)
+
+    const metadata = this.testRunner.testMetadata(test)
+    const compatibility = this.testRunner.testData(test)
+    const durationMs = packageTestResult.attempts.reduce((total, attempt) => total + attempt.durationMs, 0)
+
+    if (packageTestResult.attempts.length > 0) {
+      this.testRunner.recordTestDuration({
+        durationMs,
+        filePath: compatibility.testData.filePath ?? "<unknown>",
+        fullDescription: metadata.fullDescription,
+        line: compatibility.testData.line ?? 0
+      })
+    }
+
+    if (packageTestResult.status === "passed") {
+      this.testRunner.recordSuccessfulTest()
+    } else {
+      const finalAttempt = packageTestResult.attempts.at(-1)
+      const outcome = finalAttempt
+        ? this.testRunner.attemptOutcome(test, finalAttempt.attemptNumber)
+        : undefined
+      const error = outcome?.failed
+        ? outcome.error
+        : this.testRunner.setupFailureFor(test)
+
+      await this.reportFailedTest({
+        attemptConsoleOutputs: this.attemptConsoleOutputs.get(test) || [],
+        descriptions: metadata.descriptions,
+        error,
+        leftPadding: " ".repeat(metadata.descriptions.length * 2),
+        testArgs: compatibility.testArgs,
+        testData: compatibility.testData,
+        testDescription: metadata.testDescription
+      })
+    }
+
+    this.testRunner.completeTestDeclaration(test)
+    this.activeTest = undefined
+  }
+
+  /**
+   * Records and emits one final failed test result.
+   * @param {object} args - Final failure metadata.
+   * @param {import("./test-runner.js").AttemptConsoleOutput[]} args.attemptConsoleOutputs - Captured output across attempts.
+   * @param {string[]} args.descriptions - Parent description stack.
+   * @param {ReturnType<typeof JSON.parse>} args.error - Raw final failure.
+   * @param {string} args.leftPadding - Console indentation.
+   * @param {import("./test-runner.js").TestArgs} args.testArgs - Stable test arguments.
+   * @param {import("./test-runner.js").TestData} args.testData - Test registration.
+   * @param {string} args.testDescription - Test description.
+   * @returns {Promise<void>} - Resolves after the final-failure listener completes.
+   */
+  async reportFailedTest({attemptConsoleOutputs, descriptions, error, leftPadding, testArgs, testData, testDescription}) {
+    const testRunner = this.testRunner
+    const consoleOutput = testRunner.buildConsoleOutput(attemptConsoleOutputs)
+
+    if (error instanceof Error) {
+      console.error(picocolors.red(`${leftPadding}  Test failed: ${error.message}`))
+      addTrackedStackToError(error)
+
+      const backtraceCleaner = new BacktraceCleaner(error)
+      const cleanedStack = backtraceCleaner.getCleanedStack()
+      const stackLines = cleanedStack?.split("\n")
+
+      if (stackLines) {
+        for (const stackLine of stackLines) console.error(picocolors.red(`${leftPadding}  ${stackLine}`))
+      }
+    } else {
+      console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof error}: ${String(error)}`))
+    }
+
+    testRunner.printFailedConsoleOutput({consoleOutput, leftPadding})
+    testRunner.recordFailedTest({descriptions, error, consoleOutput, testData, testDescription})
+
+    await this.emitEvent("testFailed", {
+      configuration: testRunner.getConfiguration(),
+      descriptions,
+      error,
+      testArgs,
+      testData,
+      testDescription,
+      testRunner
+    })
+
+    testRunner.printRerunCommand({descriptions, testDescription, testData, leftPadding})
+  }
+
+  /**
+   * Emits one legacy event and awaits listeners in registration order.
+   * @param {string} eventName - Event name.
+   * @param {object} payload - Event payload.
+   * @returns {Promise<void>} - Resolves when all listeners complete.
+   */
+  async emitEvent(eventName, payload) {
+    for (const listener of testEvents.listeners(eventName)) await listener(payload)
+  }
+}

package/src/testing/velocious-suite-hook-executor.js

@@ -0,0 +1,43 @@
+// @ts-check
+
+import restArgsError from "../utils/rest-args-error.js"
+
+export default class VelociousSuiteHookExecutor {
+  /**
+   * Creates an executor for Velocious suite hooks.
+   * @param {object} args - Constructor arguments.
+   * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+   */
+  constructor({testRunner, ...restArgs}) {
+    restArgsError(restArgs)
+    this.testRunner = testRunner
+  }
+
+  /**
+   * Supplies the framework configuration while package traversal owns ordering,
+   * timeout enforcement, aggregation, and active-scope cleanup.
+   * @param {import("@velocious/testing/runner").SuiteHookExecutorInput} input - Package hook input.
+   * @returns {Promise<void>} - Resolves after the hook completes.
+   */
+  async execute({context, defaultExecute, fullName, hook, phase, suite, timeoutMs, ...restArgs}) {
+    restArgsError(restArgs)
+    void context
+    void fullName
+    void timeoutMs
+    const metadata = this.testRunner.hookMetadata(hook)
+
+    try {
+      await this.testRunner.runProfileSpan({
+        phase,
+        declarationIndex: metadata.declarationIndex,
+        declarationScopeId: metadata.declarationScopeId,
+        filePath: metadata.ownerFilePath
+      }, async () => {
+        await defaultExecute([{configuration: this.testRunner.getConfiguration()}])
+      })
+    } catch (error) {
+      this.testRunner.recordSuiteHookFailure({suite, phase, error})
+      throw error
+    }
+  }
+}

package/src/testing/velocious-test-arguments.js

@@ -0,0 +1,64 @@
+// @ts-check
+
+import restArgsError from "../utils/rest-args-error.js"
+
+/** @typedef {import("./test-runner.js").TestArgs} TestArgs */
+/** @typedef {import("./test-runner.js").TestData} TestData */
+/** @typedef {import("@velocious/testing/runner").TestDeclaration} PackageTestDeclaration */
+
+export default class VelociousTestArguments {
+  /**
+   * Creates the framework-owned test argument adapter.
+   * @param {object} args - Constructor arguments.
+   * @param {import("./test-runner.js").default} args.testRunner - Owning Velocious runner.
+   */
+  constructor({testRunner, ...restArgs}) {
+    restArgsError(restArgs)
+    this.testRunner = testRunner
+  }
+
+  /**
+   * Resolves stable Velocious arguments after package-owned table arguments.
+   * @param {object} input - Package resolver input.
+   * @param {PackageTestDeclaration} input.test - Selected declaration.
+   * @returns {Promise<ReturnType<typeof JSON.parse>[]>} - Callback arguments.
+   */
+  async resolve({test}) {
+    const compatibility = await this.testRunner.testCompatibility(test)
+
+    return [...test.rowArguments, compatibility.testArgs]
+  }
+
+  /**
+   * Copies declaration metadata before selection can inspect it.
+   * @param {PackageTestDeclaration} testData - Test registration.
+   * @returns {TestArgs} - Independent test arguments.
+   */
+  copy(testData) {
+    const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.options))
+
+    if (testArgs.retry === undefined && typeof testData.options.retries === "number") {
+      testArgs.retry = testData.options.retries
+    }
+    if (testArgs.timeoutSeconds === undefined && typeof testData.options.timeoutMs === "number") {
+      testArgs.timeoutSeconds = testData.options.timeoutMs / 1000
+    }
+
+    return testArgs
+  }
+
+  /**
+   * Injects type-specific framework collaborators after selection.
+   * @param {TestArgs} testArgs - Selected test arguments.
+   * @returns {Promise<void>} - Resolves after required collaborators are ready.
+   */
+  async inject(testArgs) {
+    if (testArgs.type == "model" || testArgs.type == "request") {
+      testArgs.application = await this.testRunner.application()
+    }
+
+    if (testArgs.type == "request") {
+      testArgs.client = await this.testRunner.requestClient()
+    }
+  }
+}

package/src/utils/model-primary-key.js

@@ -0,0 +1,171 @@
+// @ts-check
+
+import isPlainObject from "./plain-object.js"
+
+/** @typedef {string | number} ModelPrimaryKeyScalar */
+/** @typedef {string | string[]} ModelPrimaryKeyDefinition */
+/** @typedef {Record<string, ModelPrimaryKeyScalar>} CompositeModelPrimaryKeyValue */
+/** @typedef {ModelPrimaryKeyScalar | CompositeModelPrimaryKeyValue} ModelPrimaryKeyValue */
+
+/**
+ * Validates an untrusted composite identity and returns its definition-ordered values.
+ * @param {string[]} primaryKey - Composite primary-key definition.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate identity.
+ * @returns {CompositeModelPrimaryKeyValue} - Validated identity.
+ */
+export function validatedCompositePrimaryKeyValue(primaryKey, value) {
+  if (!isPlainObject(value)) {
+    throw new TypeError("Expected composite primary key identity to be a plain object.")
+  }
+
+  const valueKeys = Object.keys(value)
+
+  if (valueKeys.length !== primaryKey.length || primaryKey.some((key) => !Object.prototype.hasOwnProperty.call(value, key))) {
+    throw new TypeError(`Expected composite primary key identity fields: ${primaryKey.join(", ")}.`)
+  }
+
+  /** @type {CompositeModelPrimaryKeyValue} */
+  const validatedValue = {}
+
+  for (const key of primaryKey) {
+    const keyValue = value[key]
+
+    if (typeof keyValue !== "string" && typeof keyValue !== "number") {
+      throw new TypeError(`Expected composite primary key identity field '${key}' to be a string or number.`)
+    }
+
+    validatedValue[key] = keyValue
+  }
+
+  return validatedValue
+}
+
+/**
+ * Returns a scalar primary-key definition or fails at a feature boundary that cannot represent composite identities.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {string} operation - Operation requiring a scalar identity.
+ * @returns {string} - Scalar primary-key column or attribute name.
+ */
+export function scalarModelPrimaryKey(primaryKey, operation) {
+  if (Array.isArray(primaryKey)) {
+    throw new Error(`${operation} does not support composite primary keys.`)
+  }
+
+  return primaryKey
+}
+
+/**
+ * Returns a scalar identity or fails at a feature boundary that cannot represent composite identities.
+ * @param {ModelPrimaryKeyValue} value - Model identity.
+ * @param {string} operation - Operation requiring a scalar identity.
+ * @returns {ModelPrimaryKeyScalar} - Scalar identity.
+ */
+export function scalarModelPrimaryKeyValue(value, operation) {
+  if (typeof value !== "string" && typeof value !== "number") {
+    throw new Error(`${operation} does not support composite primary keys.`)
+  }
+
+  return value
+}
+
+/**
+ * Builds query conditions from a scalar or composite model identity.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate identity.
+ * @returns {Record<string, ModelPrimaryKeyScalar>} - Primary-key query conditions.
+ */
+export function modelPrimaryKeyConditions(primaryKey, value) {
+  if (Array.isArray(primaryKey)) return validatedCompositePrimaryKeyValue(primaryKey, value)
+
+  return {[primaryKey]: /** @type {ModelPrimaryKeyScalar} */ (value)}
+}
+
+/**
+ * Builds a qualified SQL predicate matching any supplied composite identity.
+ * @param {object} args - Arguments.
+ * @param {typeof import("../database/record/index.js").default} args.modelClass - Model class owning the identity attributes.
+ * @param {string[]} args.primaryKey - Composite primary-key definition.
+ * @param {import("../database/query/model-class-query.js").default<typeof import("../database/record/index.js").default>} args.query - Query receiving the predicate.
+ * @param {ModelPrimaryKeyValue[]} args.values - Candidate identities.
+ * @returns {string} - Qualified SQL predicate.
+ */
+export function compositeModelPrimaryKeyCohortSql({modelClass, primaryKey, query, values}) {
+  if (values.length === 0) return "(1 = 0)"
+
+  const tableSql = query.driver.quoteTable(query.getTableReferenceForJoin())
+
+  return `(${values.map((value) => {
+    const conditions = modelPrimaryKeyConditions(primaryKey, value)
+    const identitySql = primaryKey.map((attributeName) => {
+      const columnName = modelClass.getColumnNameForAttributeName(attributeName)
+
+      return `${tableSql}.${query.driver.quoteColumn(columnName)} = ${query.driver.quote(conditions[attributeName])}`
+    }).join(" AND ")
+
+    return `(${identitySql})`
+  }).join(" OR ")})`
+}
+
+/**
+ * Reads a scalar or composite identity through the owning model's value reader.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {(key: string) => ReturnType<typeof JSON.parse>} read - Primary-key value reader.
+ * @returns {ModelPrimaryKeyValue} - Model identity.
+ */
+export function readModelPrimaryKeyValue(primaryKey, read) {
+  if (!Array.isArray(primaryKey)) return /** @type {ModelPrimaryKeyScalar} */ (read(primaryKey))
+
+  /** @type {CompositeModelPrimaryKeyValue} */
+  const value = {}
+
+  for (const key of primaryKey) value[key] = /** @type {ModelPrimaryKeyScalar} */ (read(key))
+
+  return validatedCompositePrimaryKeyValue(primaryKey, value)
+}
+
+/**
+ * Returns an unambiguous map key while preserving legacy scalar map keys.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {ReturnType<typeof JSON.parse>} value - Candidate identity.
+ * @returns {string} - Canonical identity key.
+ */
+export function modelPrimaryKeyCacheKey(primaryKey, value) {
+  if (!Array.isArray(primaryKey)) return String(value)
+
+  const validatedValue = validatedCompositePrimaryKeyValue(primaryKey, value)
+
+  return JSON.stringify(primaryKey.map((key) => validatedValue[key]))
+}
+
+/**
+ * Restores a model identity from its canonical string representation.
+ * @param {ModelPrimaryKeyDefinition} primaryKey - Primary-key definition.
+ * @param {string} cacheKey - Canonical identity key.
+ * @returns {ModelPrimaryKeyValue} - Restored identity.
+ */
+export function modelPrimaryKeyValueFromCacheKey(primaryKey, cacheKey) {
+  if (!Array.isArray(primaryKey)) return cacheKey
+
+  let parsed
+
+  try {
+    parsed = JSON.parse(cacheKey)
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error
+
+    throw new TypeError("Expected composite primary key cache value to be valid JSON.", {cause: error})
+  }
+
+  if (!Array.isArray(parsed) || parsed.length !== primaryKey.length) {
+    throw new TypeError(`Expected composite primary key cache value with ${primaryKey.length} fields.`)
+  }
+
+  /** @type {CompositeModelPrimaryKeyValue} */
+  const value = {}
+
+  for (let index = 0; index < primaryKey.length; index += 1) {
+    value[primaryKey[index]] = parsed[index]
+  }
+
+  return validatedCompositePrimaryKeyValue(primaryKey, value)
+}

package/src/utils/sha256-bytes-hex.js

@@ -0,0 +1,132 @@
+// @ts-check
+
+/**
+ * Computes a SHA-256 hex digest for arbitrary bytes without Node-only imports.
+ * @param {Uint8Array} bytes - Bytes to digest.
+ * @returns {string} Hex digest.
+ */
+export default function sha256BytesHex(bytes) {
+  const bitLength = bytes.length * 8
+  const blockCount = Math.ceil((bytes.length + 9) / 64)
+  const block = new Uint8Array(64)
+  const hash = SHA256_INITIAL_HASH.slice()
+  /** @type {number[]} */
+  const words = new Array(64)
+
+  const highLength = Math.floor(bitLength / 0x100000000)
+  const lowLength = bitLength >>> 0
+
+  for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {
+    const offset = blockIndex * 64
+    const chunkLength = Math.min(64, Math.max(0, bytes.length - offset))
+
+    block.fill(0)
+    if (chunkLength > 0) block.set(bytes.subarray(offset, offset + chunkLength))
+    if (bytes.length >= offset && bytes.length < offset + 64) block[bytes.length - offset] = 0x80
+
+    if (blockIndex === blockCount - 1) {
+      block[56] = (highLength >>> 24) & 0xff
+      block[57] = (highLength >>> 16) & 0xff
+      block[58] = (highLength >>> 8) & 0xff
+      block[59] = highLength & 0xff
+      block[60] = (lowLength >>> 24) & 0xff
+      block[61] = (lowLength >>> 16) & 0xff
+      block[62] = (lowLength >>> 8) & 0xff
+      block[63] = lowLength & 0xff
+    }
+
+    for (let index = 0; index < 16; index++) {
+      const byteIndex = index * 4
+
+      words[index] = ((block[byteIndex] << 24) | (block[byteIndex + 1] << 16) | (block[byteIndex + 2] << 8) | block[byteIndex + 3]) >>> 0
+    }
+
+    for (let index = 16; index < 64; index++) {
+      const s0 = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ (words[index - 15] >>> 3)
+      const s1 = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ (words[index - 2] >>> 10)
+
+      words[index] = add32(words[index - 16], s0, words[index - 7], s1)
+    }
+
+    let a = hash[0]
+    let b = hash[1]
+    let c = hash[2]
+    let d = hash[3]
+    let e = hash[4]
+    let f = hash[5]
+    let g = hash[6]
+    let h = hash[7]
+
+    for (let index = 0; index < 64; index++) {
+      const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25)
+      const ch = (e & f) ^ ((~e) & g)
+      const temp1 = add32(h, s1, ch, SHA256_K[index], words[index])
+      const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22)
+      const maj = (a & b) ^ (a & c) ^ (b & c)
+      const temp2 = add32(s0, maj)
+
+      h = g
+      g = f
+      f = e
+      e = add32(d, temp1)
+      d = c
+      c = b
+      b = a
+      a = add32(temp1, temp2)
+    }
+
+    hash[0] = add32(hash[0], a)
+    hash[1] = add32(hash[1], b)
+    hash[2] = add32(hash[2], c)
+    hash[3] = add32(hash[3], d)
+    hash[4] = add32(hash[4], e)
+    hash[5] = add32(hash[5], f)
+    hash[6] = add32(hash[6], g)
+    hash[7] = add32(hash[7], h)
+  }
+
+  return hash.map((value) => value.toString(16).padStart(8, "0")).join("")
+}
+
+const SHA256_INITIAL_HASH = [
+  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+  0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+]
+
+const SHA256_K = [
+  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
+]
+
+/**
+ * Rotates an unsigned value right.
+ * @param {number} value Unsigned value.
+ * @param {number} bits Rotation count.
+ * @returns {number} Rotated value.
+ */
+function rotateRight(value, bits) {
+  return (value >>> bits) | (value << (32 - bits))
+}
+
+/**
+ * Adds numbers with unsigned 32-bit overflow.
+ * @param {...number} values Values to add.
+ * @returns {number} Unsigned sum.
+ */
+function add32(...values) {
+  return values.reduce((sum, value) => (sum + value) >>> 0, 0)
+}