@pulse-compute/wasm-contracts 0.0.0 → 1.0.0-beta.2

package/src/schema-json/semantic-trace.js

@@ -0,0 +1,241 @@
+'use strict';
+
+const { sha256Hex, stableStringify } = require('../stable-id.js');
+const { SCHEMA_ID_PATTERN, RESPONSE_CASE_ID_PATTERN } = require('./registry.js');
+
+const JSON_SEMANTIC_TRACE_VERSION = 'pulse.json-semantic-trace.v1';
+const JSON_TRACE_EVENT_KINDS = Object.freeze([
+  'json.decode.request',
+  'json.decode.fetch',
+  'json.encode.response',
+  'json.encode.fetch',
+  'json.decode.error',
+  'json.encode.error'
+]);
+const JSON_BOUNDARIES = Object.freeze(['request', 'fetch-response', 'application-response', 'fetch-request']);
+const JSON_BODY_OWNERSHIP = Object.freeze([
+  'request-snapshot',
+  'fetched-response-snapshot',
+  'application-owned',
+  'host-owned-opaque'
+]);
+const JSON_EVENT_BOUNDARIES = Object.freeze({
+  'json.decode.request': Object.freeze(['request']),
+  'json.decode.fetch': Object.freeze(['fetch-response']),
+  'json.encode.response': Object.freeze(['application-response']),
+  'json.encode.fetch': Object.freeze(['fetch-request']),
+  'json.decode.error': Object.freeze(['request', 'fetch-response']),
+  'json.encode.error': Object.freeze(['application-response', 'fetch-request'])
+});
+
+function traceError(code, message, details = {}) {
+  const error = new TypeError(message);
+  error.code = code;
+  error.details = Object.freeze({ ...details });
+  return error;
+}
+
+function normalizeText(value) {
+  return String(value).normalize('NFC');
+}
+
+function plainObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+function normalizeSemanticValue(value, options = {}, path = '') {
+  const redacted = typeof options.redact === 'function' ? options.redact(value, path) : value;
+  if (redacted !== value) return normalizeSemanticValue(redacted, { ...options, redact: undefined }, path);
+  if (value === null || typeof value === 'boolean') return value;
+  if (typeof value === 'string') return normalizeText(value);
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) {
+      throw traceError('PULSE_JSON_TRACE_NUMBER_NONFINITE', 'Semantic trace values must contain only finite RFC JSON numbers.', {
+        path,
+        value: String(value)
+      });
+    }
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map((entry, index) => normalizeSemanticValue(entry, options, `${path}/${index}`)));
+  }
+  if (plainObject(value)) {
+    const out = {};
+    const normalizedKeys = new Set();
+    for (const key of Object.keys(value).sort()) {
+      const normalizedKey = normalizeText(key);
+      if (normalizedKeys.has(normalizedKey)) {
+        throw traceError(
+          'PULSE_JSON_TRACE_KEY_NORMALIZATION_COLLISION',
+          `Semantic trace object keys collide after NFC normalization at ${path || '/'}.`,
+          { path, key: normalizedKey }
+        );
+      }
+      normalizedKeys.add(normalizedKey);
+      const pointerKey = normalizedKey.replace(/~/g, '~0').replace(/\//g, '~1');
+      out[normalizedKey] = normalizeSemanticValue(value[key], options, `${path}/${pointerKey}`);
+    }
+    return Object.freeze(out);
+  }
+  throw traceError('PULSE_JSON_TRACE_VALUE_UNSUPPORTED', `Semantic trace values cannot contain ${typeof value}.`, {
+    path,
+    valueType: typeof value
+  });
+}
+
+function semanticValueDigest(value, options = {}) {
+  return sha256Hex(stableStringify(normalizeSemanticValue(value, options)));
+}
+
+function normalizeHeaderPairs(input) {
+  const entries = input == null
+    ? []
+    : (Array.isArray(input) ? input : Object.entries(input));
+  return Object.freeze(entries.map((entry, index) => {
+    if (!Array.isArray(entry) || entry.length < 2) {
+      throw traceError('PULSE_JSON_TRACE_HEADERS_INVALID', `headers[${index}] must be a name/value pair.`, { index });
+    }
+    return Object.freeze([
+      normalizeText(entry[0]).trim().toLowerCase(),
+      normalizeText(entry[1]).trim().replace(/[ \t]+/g, ' ')
+    ]);
+  }).sort((left, right) => left[0].localeCompare(right[0]) || left[1].localeCompare(right[1])));
+}
+
+function normalizeJsonPointer(input) {
+  if (input === undefined || input === null || input === '') return null;
+  if (Array.isArray(input)) {
+    return `/${input.map((segment) => normalizeText(segment).replace(/~/g, '~0').replace(/\//g, '~1')).join('/')}`;
+  }
+  const value = normalizeText(input);
+  if (!value.startsWith('/') || /~(?![01])/u.test(value)) {
+    throw traceError('PULSE_JSON_TRACE_POINTER_INVALID', 'errorPath must be a valid JSON Pointer.', { errorPath: value });
+  }
+  return value;
+}
+
+function optionalId(value, pattern, field, code) {
+  if (value === undefined || value === null) return null;
+  const id = normalizeText(value).trim();
+  if (!pattern.test(id)) throw traceError(code, `${field} must be a stable dotted identifier.`, { field, id });
+  return id;
+}
+
+function normalizeJsonTraceEvent(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw traceError('PULSE_JSON_TRACE_EVENT_REQUIRED', 'JSON semantic trace event must be an object.');
+  }
+  const kind = normalizeText(input.kind || '');
+  if (!JSON_TRACE_EVENT_KINDS.includes(kind)) {
+    throw traceError('PULSE_JSON_TRACE_EVENT_KIND_INVALID', `Unsupported JSON trace event kind ${kind}.`, { kind });
+  }
+  const boundary = normalizeText(input.boundary || '');
+  if (!JSON_BOUNDARIES.includes(boundary)) {
+    throw traceError('PULSE_JSON_TRACE_BOUNDARY_INVALID', `Unsupported JSON trace boundary ${boundary}.`, { boundary });
+  }
+  if (!JSON_EVENT_BOUNDARIES[kind].includes(boundary)) {
+    throw traceError(
+      'PULSE_JSON_TRACE_EVENT_BOUNDARY_MISMATCH',
+      `${kind} cannot be emitted for the ${boundary} boundary.`,
+      { kind, boundary, allowed: JSON_EVENT_BOUNDARIES[kind] }
+    );
+  }
+  const bodyOwnership = normalizeText(input.bodyOwnership || '');
+  if (!JSON_BODY_OWNERSHIP.includes(bodyOwnership)) {
+    throw traceError('PULSE_JSON_TRACE_BODY_OWNERSHIP_INVALID', `Unsupported JSON body ownership ${bodyOwnership}.`, {
+      bodyOwnership
+    });
+  }
+  const operationId = normalizeText(input.operationId || '').trim();
+  if (!/^[A-Za-z][A-Za-z0-9_.:-]*$/.test(operationId)) {
+    throw traceError('PULSE_JSON_TRACE_OPERATION_ID_INVALID', 'operationId must be deterministic and identifier-safe.', { operationId });
+  }
+  const status = input.status === undefined || input.status === null ? null : Number(input.status);
+  if (status !== null && (!Number.isSafeInteger(status) || status < 100 || status > 599)) {
+    throw traceError('PULSE_JSON_TRACE_STATUS_INVALID', 'status must be null or an integer from 100 through 599.', { status });
+  }
+  const schemaId = optionalId(input.schemaId, SCHEMA_ID_PATTERN, 'schemaId', 'PULSE_SCHEMA_ID_INVALID');
+  const responseCaseId = optionalId(input.responseCaseId, RESPONSE_CASE_ID_PATTERN, 'responseCaseId', 'PULSE_RESPONSE_CASE_ID_INVALID');
+  const contentType = input.contentType === undefined || input.contentType === null
+    ? null
+    : normalizeText(input.contentType).trim().toLowerCase().replace(/[ \t]+/g, ' ');
+  const event = {
+    version: JSON_SEMANTIC_TRACE_VERSION,
+    kind,
+    boundary,
+    schemaId,
+    responseCaseId,
+    operationId,
+    status,
+    contentType,
+    headers: normalizeHeaderPairs(input.headers),
+    bodyOwnership,
+    valueDigest: input.valueDigest === undefined || input.valueDigest === null
+      ? null
+      : normalizeText(input.valueDigest).toLowerCase(),
+    errorCode: input.errorCode === undefined || input.errorCode === null ? null : normalizeText(input.errorCode),
+    errorPath: normalizeJsonPointer(input.errorPath),
+    expected: input.expected === undefined || input.expected === null ? null : normalizeText(input.expected),
+    actualKind: input.actualKind === undefined || input.actualKind === null ? null : normalizeText(input.actualKind),
+    target: input.target === undefined || input.target === null ? null : normalizeText(input.target),
+    provider: input.provider === undefined || input.provider === null ? null : normalizeText(input.provider),
+    effectId: input.effectId === undefined || input.effectId === null ? null : normalizeText(input.effectId),
+    groupId: input.groupId === undefined || input.groupId === null ? null : normalizeText(input.groupId)
+  };
+  if (event.valueDigest !== null && !/^[0-9a-f]{64}$/.test(event.valueDigest)) {
+    throw traceError('PULSE_JSON_TRACE_DIGEST_INVALID', 'valueDigest must be a lowercase SHA-256 hex digest.', {
+      valueDigest: event.valueDigest
+    });
+  }
+  const isError = kind.endsWith('.error');
+  if (isError && !event.errorCode) {
+    throw traceError('PULSE_JSON_TRACE_ERROR_CODE_REQUIRED', `${kind} requires errorCode.`, { kind });
+  }
+  if (!isError && event.errorCode) {
+    throw traceError('PULSE_JSON_TRACE_ERROR_CODE_UNEXPECTED', `${kind} cannot carry errorCode.`, { kind });
+  }
+  return Object.freeze({
+    ...event,
+    eventDigest: sha256Hex(stableStringify(event))
+  });
+}
+
+function operationIdentity(input) {
+  const semantic = normalizeSemanticValue(input);
+  return `jsonop:${sha256Hex(stableStringify(semantic)).slice(0, 24)}`;
+}
+
+function defaultJsonSemanticTraceContract() {
+  return Object.freeze({
+    version: JSON_SEMANTIC_TRACE_VERSION,
+    eventKinds: JSON_TRACE_EVENT_KINDS,
+    boundaries: JSON_BOUNDARIES,
+    eventBoundaries: JSON_EVENT_BOUNDARIES,
+    bodyOwnership: JSON_BODY_OWNERSHIP,
+    digest: 'sha256(canonical-redacted-semantic-value)',
+    stringNormalization: 'NFC',
+    numberNormalization: 'finite; negative-zero becomes zero',
+    headerNormalization: 'lowercase-name; collapsed-ows-value; sorted-pairs',
+    errorPath: 'RFC-6901 JSON Pointer',
+    parity: 'semantic-not-byte',
+    rawSensitiveValuesAllowed: false
+  });
+}
+
+module.exports = Object.freeze({
+  JSON_SEMANTIC_TRACE_VERSION,
+  JSON_TRACE_EVENT_KINDS,
+  JSON_BOUNDARIES,
+  JSON_BODY_OWNERSHIP,
+  JSON_EVENT_BOUNDARIES,
+  normalizeSemanticValue,
+  semanticValueDigest,
+  normalizeHeaderPairs,
+  normalizeJsonPointer,
+  normalizeJsonTraceEvent,
+  operationIdentity,
+  defaultJsonSemanticTraceContract
+});

package/src/schema-json/v1.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const SCHEMA_JSON_SIDECAR_VERSION = 'pulsewasm.schema-json-sidecar.v2';
+const SCHEMA_JSON_PLAN_VERSION = 'pulsewasm.schema-json-plan.v2';
+const SCHEMA_JSON_REPORT_VERSION = 'pulsewasm.schema-json-parser-report.v2';
+const SCHEMA_JSON_SMOKE_VERSION = 'pulsewasm.schema-json-smoke.v2';
+const SCHEMA_JSON_REGISTRY_VERSION = 'pulsewasm.schema-json-registry.v1';
+const SCHEMA_JSON_ABI_VERSION = 'pulsewasm.schema-json-sidecar-abi.v1';
+const SCHEMA_JSON_BODY_POLICY_VERSION = 'pulsewasm.schema-json-body-policy.v1';
+const SCHEMA_JSON_PHASE = '12B.1';
+const PHASE = SCHEMA_JSON_PHASE;
+
+const SUPPORTED_TYPES = new Set(['string', 'i32', 'u32', 'f64', 'bool', 'boolean', 'number']);
+const RESERVED_TYPES = new Set(['any', 'unknown', 'object', 'Object', 'Record<string, unknown>', 'array', 'Array']);
+const CONTENT_TYPE_POLICIES = new Set(['accept-json-or-missing', 'require-json']);
+const RESERVED_CONTENT_TYPE_POLICIES = new Set(['ignore-content-type']);
+const DEFAULT_SCHEMA_JSON_NAMESPACE = 'app';
+const DEFAULT_SCHEMA_JSON_MAX_BYTES = 1_048_576;
+const DEFAULT_SCHEMA_JSON_CONTENT_TYPE_POLICY = 'accept-json-or-missing';
+
+function lowerFieldType(type) {
+  if (type === 'boolean') return 'bool';
+  if (type === 'number') return 'f64';
+  return type;
+}
+
+function isSupportedFieldType(type) {
+  return SUPPORTED_TYPES.has(String(type));
+}
+
+function isReservedFieldType(type) {
+  return RESERVED_TYPES.has(String(type));
+}
+
+function isSupportedContentTypePolicy(policy) {
+  return CONTENT_TYPE_POLICIES.has(String(policy));
+}
+
+function isReservedContentTypePolicy(policy) {
+  return RESERVED_CONTENT_TYPE_POLICIES.has(String(policy));
+}
+
+module.exports = {
+  SCHEMA_JSON_SIDECAR_VERSION,
+  SCHEMA_JSON_PLAN_VERSION,
+  SCHEMA_JSON_REPORT_VERSION,
+  SCHEMA_JSON_SMOKE_VERSION,
+  SCHEMA_JSON_REGISTRY_VERSION,
+  SCHEMA_JSON_ABI_VERSION,
+  SCHEMA_JSON_BODY_POLICY_VERSION,
+  SCHEMA_JSON_PHASE,
+  PHASE,
+  SUPPORTED_TYPES,
+  RESERVED_TYPES,
+  CONTENT_TYPE_POLICIES,
+  RESERVED_CONTENT_TYPE_POLICIES,
+  DEFAULT_SCHEMA_JSON_NAMESPACE,
+  DEFAULT_SCHEMA_JSON_MAX_BYTES,
+  DEFAULT_SCHEMA_JSON_CONTENT_TYPE_POLICY,
+  lowerFieldType,
+  isSupportedFieldType,
+  isReservedFieldType,
+  isSupportedContentTypePolicy,
+  isReservedContentTypePolicy
+};

package/src/schema-json/v2.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const SCHEMA_JSON_SIDECAR_VERSION = 'pulsewasm.schema-json-sidecar.v3';
+const SCHEMA_JSON_PLAN_VERSION = 'pulsewasm.schema-json-plan.v3';
+const SCHEMA_JSON_REPORT_VERSION = 'pulsewasm.schema-json-parser-report.v3';
+const SCHEMA_JSON_SMOKE_VERSION = 'pulsewasm.schema-json-smoke.v3';
+const SCHEMA_JSON_REGISTRY_VERSION = 'pulsewasm.schema-json-registry.v2';
+const SCHEMA_JSON_ABI_VERSION = 'pulsewasm.schema-json-sidecar-abi.v2';
+const SCHEMA_JSON_BODY_POLICY_VERSION = 'pulsewasm.schema-json-body-policy.v1';
+const SCHEMA_JSON_PHASE = '14';
+const PHASE = SCHEMA_JSON_PHASE;
+
+const SCALAR_ALIASES = new Map([
+  ['boolean', 'bool'],
+  ['number', 'f64']
+]);
+const SCALAR_TYPES = new Set(['string', 'bool', 'boolean', 'i32', 'u32', 'f64', 'number']);
+const RESERVED_SCALAR_TYPES = new Set(['any', 'unknown', 'object', 'Object', 'Record<string, unknown>', 'array', 'Array']);
+const CONTENT_TYPE_POLICIES = new Set(['accept-json-or-missing', 'require-json']);
+const RESERVED_CONTENT_TYPE_POLICIES = new Set(['ignore-content-type']);
+const DEFAULT_SCHEMA_JSON_NAMESPACE = 'app';
+const DEFAULT_SCHEMA_JSON_CONTENT_TYPE_POLICY = 'accept-json-or-missing';
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function plainObject(value) {
+  return isPlainObject(value) ? value : {};
+}
+
+function jsonConfig(config) {
+  const runtime = plainObject(config && config.runtime);
+  const payload = plainObject(runtime.payload);
+  return plainObject(payload.json || (config && config.json));
+}
+
+function lowerScalar(type) {
+  return SCALAR_ALIASES.get(type) || type;
+}
+
+function normalizeScalarType(type) {
+  const raw = String(type || '');
+  return lowerScalar(raw);
+}
+
+function isSupportedScalarType(type) {
+  const raw = String(type || '');
+  const lowered = lowerScalar(raw);
+  return SCALAR_TYPES.has(raw) || SCALAR_TYPES.has(lowered);
+}
+
+function isReservedScalarType(type) {
+  return RESERVED_SCALAR_TYPES.has(String(type || ''));
+}
+
+function isSupportedContentTypePolicy(policy) {
+  return CONTENT_TYPE_POLICIES.has(String(policy));
+}
+
+function descriptorNeedsV2(value) {
+  if (Array.isArray(value)) return true;
+  if (!value || typeof value !== 'object') return false;
+  if (Object.prototype.hasOwnProperty.call(value, 'fields')) return true;
+  if (Object.prototype.hasOwnProperty.call(value, 'enum')) return true;
+  if (Object.prototype.hasOwnProperty.call(value, 'required')) return true;
+  if (Object.prototype.hasOwnProperty.call(value, 'nullable')) return true;
+  if (value.type === 'object') return true;
+  if (Array.isArray(value.type)) return true;
+  if (isPlainObject(value.type)) return true;
+  return false;
+}
+
+function configArtifact(config) {
+  return config && typeof config === 'object' && config.artifact ? config.artifact : config;
+}
+
+function shouldUseSchemaJsonV2(config) {
+  const json = jsonConfig(configArtifact(config));
+  if ((json.schemaVersion || '') === 'v2') return true;
+  const schemas = Array.isArray(json.schemas) ? json.schemas : [];
+  return schemas.some((schema) => descriptorNeedsV2(schema.fields) || Object.values(plainObject(schema.fields)).some((field) => descriptorNeedsV2(field)));
+}
+
+module.exports = {
+  SCHEMA_JSON_SIDECAR_VERSION,
+  SCHEMA_JSON_PLAN_VERSION,
+  SCHEMA_JSON_REPORT_VERSION,
+  SCHEMA_JSON_SMOKE_VERSION,
+  SCHEMA_JSON_REGISTRY_VERSION,
+  SCHEMA_JSON_ABI_VERSION,
+  SCHEMA_JSON_BODY_POLICY_VERSION,
+  SCHEMA_JSON_PHASE,
+  PHASE,
+  SCALAR_ALIASES,
+  SCALAR_TYPES,
+  RESERVED_SCALAR_TYPES,
+  CONTENT_TYPE_POLICIES,
+  RESERVED_CONTENT_TYPE_POLICIES,
+  DEFAULT_SCHEMA_JSON_NAMESPACE,
+  DEFAULT_SCHEMA_JSON_CONTENT_TYPE_POLICY,
+  lowerScalar,
+  normalizeScalarType,
+  isSupportedScalarType,
+  isReservedScalarType,
+  isSupportedContentTypePolicy,
+  configArtifact,
+  descriptorNeedsV2,
+  shouldUseSchemaJsonV2
+};

package/src/sha256.js

@@ -0,0 +1,104 @@
+'use strict';
+
+// Synchronous, platform-neutral SHA-256 for deterministic contract identities.
+// Contract code is shared by Node tooling and provider JavaScript closures, so
+// it cannot depend on a Node builtin or an asynchronous host crypto surface.
+const K = Object.freeze([
+  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, amount) {
+  return (value >>> amount) | (value << (32 - amount));
+}
+
+function inputBytes(value) {
+  if (typeof value === 'string') return new TextEncoder().encode(value);
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  return new TextEncoder().encode(String(value));
+}
+
+function sha256Bytes(input) {
+  const bytes = inputBytes(input);
+  const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
+  const message = new Uint8Array(paddedLength);
+  message.set(bytes);
+  message[bytes.byteLength] = 0x80;
+  const bitLength = BigInt(bytes.byteLength) * 8n;
+  for (let index = 0; index < 8; index += 1) {
+    message[paddedLength - 1 - index] = Number((bitLength >> BigInt(index * 8)) & 0xffn);
+  }
+
+  const state = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+  ]);
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < message.byteLength; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const position = offset + index * 4;
+      words[index] = (
+        (message[position] << 24)
+        | (message[position + 1] << 16)
+        | (message[position + 2] << 8)
+        | message[position + 3]
+      ) >>> 0;
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const left = words[index - 15];
+      const right = words[index - 2];
+      const s0 = rotateRight(left, 7) ^ rotateRight(left, 18) ^ (left >>> 3);
+      const s1 = rotateRight(right, 17) ^ rotateRight(right, 19) ^ (right >>> 10);
+      words[index] = (words[index - 16] + s0 + words[index - 7] + s1) >>> 0;
+    }
+
+    let [a, b, c, d, e, f, g, h] = state;
+    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 + K[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;
+  }
+
+  const digest = new Uint8Array(32);
+  for (let index = 0; index < state.length; index += 1) {
+    digest[index * 4] = state[index] >>> 24;
+    digest[index * 4 + 1] = state[index] >>> 16;
+    digest[index * 4 + 2] = state[index] >>> 8;
+    digest[index * 4 + 3] = state[index];
+  }
+  return digest;
+}
+
+function sha256Hex(input) {
+  return Array.from(sha256Bytes(input), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+
+module.exports = Object.freeze({ sha256Bytes, sha256Hex });