@pulse-compute/crypto 1.0.0-beta.4 → 1.0.0-beta.5

package/README.md

@@ -2,20 +2,43 @@
 
 <!-- pulse-package-status:start -->
 > **Support tier:** Supported provider/extension surface<br>
-> **Audience:** Applications and first-party packages using provider-neutral cryptographic verification.<br>
-> **Install directly:** Yes, when an application uses the crypto verification surface directly; JWT applications receive it transitively.<br>
+> **Audience:** Applications and first-party packages using provider-neutral verification and exact-text SHA-256.<br>
+> **Install directly:** Yes, when an application uses verification or digestText directly; JWT applications receive it transitively.<br>
 > **Supported entry points:** `@pulse-compute/crypto`<br>
-> **Stability:** The package root is the supported bounded verification contract; realization and Native integration subpaths remain toolchain-only.<br>
+> **Stability:** The package root supports bounded verification and request-owned exact-text digests; provider, manifest/compiler and Native integration subpaths remain toolchain-only.<br>
 > **npm:** [`@pulse-compute/crypto`](https://www.npmjs.com/package/@pulse-compute/crypto)<br>
-> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.4/packages/crypto/)
+> **Canonical documentation:** [Package guide](https://pulsecompute.io/v1.0.0-beta.5/packages/crypto/)
 >
-> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.4` package policy.
+> This release-status block is generated from the synchronized `Pulse 1.0.0-beta.5` package policy.
 <!-- pulse-package-status:end -->
 
-Provider-neutral cryptographic verification contracts for Pulse.
+Provider-neutral verification and bounded exact-text SHA-256 for Pulse.
 
 This package and `@pulse-compute/jwt` are members of the synchronized
-`1.0.0-beta.4` release catalog.
+`1.0.0-beta.5` release catalog.
+
+## Exact-text SHA-256
+
+```ts
+import { crypto } from '@pulse-compute/crypto'
+
+const digest = await crypto.digestText(ctx, text)
+```
+
+Select `pulse.crypto: ['SHA-256']`. The current HTTP context owns this effect;
+use a directly awaited local variable or keyed `ctx.parallel` member.
+Success is `{ status: 'ok', sha256, byteLength }`: 64 lowercase hex characters
+and the exact UTF-8 length. The public `DIGEST_TEXT_MAX_BYTES` is 2097152, empty
+input is accepted, and unpaired surrogates are rejected without replacement.
+No normalization, parsing, BOM stripping, or newline conversion occurs.
+Failures are `{ status: 'failed', reason }`, where reason is `invalid-text`,
+`too-large`, `unavailable`, or `realization-failure`; cancellation terminates
+the invocation. The named `digestText` export has the same contract.
+
+Node/Fastly Native reuse the selected Crypto SHA-256 guest source. Node/Fastly
+JavaScript use selected Web Crypto. Neither falls back. This bound matches
+current S3 text capacity and leaves larger Catalog envelopes for capacity work.
+See the [exact-text digest contract](https://pulsecompute.io/v1.0.0-beta.5/packages/crypto/#exact-text-digest).
 
 ## Verification contract
 
@@ -132,9 +155,15 @@ deployment.
 S3 uses Crypto-owned SHA-256 and HMAC-SHA256 byte outputs. Native composes the
 existing guest-source unit; Node JavaScript explicitly binds Web Crypto through
 `@pulse-compute/crypto/provider`. The trusted seam snapshots Uint8Array input,
-allows at most 32768 data bytes and 8192 HMAC key bytes, returns exactly 32 bytes,
+allows at most 2097152 SHA-256 data bytes, 32768 HMAC data bytes and 8192 HMAC
+key bytes, returns exactly 32 bytes,
 and wipes input staging on success or failure. It rejects unavailable selected
 primitives and does not fall back. Empty HMAC keys use the equivalent padded
 zero block required by HMAC, preserving Native semantics despite Web Crypto's
 zero-length import restriction. This provider seam does not add an author-facing
 signing API or change JWT key limits.
+
+Large hashes use a separate lazy 2,097,184-byte Native staging frame; small
+hashes and HMAC keep the 40,992-byte frame. Primary-memory Native digest/S3
+modules have a 256 MiB Wasm maximum. Fixed-memory linked guests retain their
+separate ABI and do not establish the 2 MiB text capacity profile.

package/as/digest-text.as.ts

@@ -0,0 +1,34 @@
+// Crypto-owned text framing over the existing SHA-256 implementation.
+class __PulseTextDigestResult {
+  status: string = 'failed'
+  reason: string = ''
+  sha256: string = ''
+  byteLength: i32 = 0
+}
+function __pulse_crypto_digest_text(text: string | null): __PulseTextDigestResult {
+  const result = new __PulseTextDigestResult()
+  if (text === null) { result.reason = 'invalid-text'; return result }
+  if (text.length > 2097152) { result.reason = 'too-large'; return result }
+  let length = 0
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i)
+    if (c >= 0xd800 && c <= 0xdbff) {
+      i += 1
+      if (i >= text.length) { result.reason = 'invalid-text'; return result }
+      const low = text.charCodeAt(i)
+      if (low < 0xdc00 || low > 0xdfff) { result.reason = 'invalid-text'; return result }
+      length += 4
+    } else if (c >= 0xdc00 && c <= 0xdfff) { result.reason = 'invalid-text'; return result }
+    else length += c < 0x80 ? 1 : c < 0x800 ? 2 : 3
+  }
+  if (length > 2097152) { result.reason = 'too-large'; return result }
+  const data = Uint8Array.wrap(String.UTF8.encode(text)), digest = new Uint8Array(32)
+  const code = pulse_crypto_sha256_bytes_v1(data.dataStart, data.length, digest.dataStart, 32)
+  data.fill(0)
+  if (code != 1) { digest.fill(0); result.reason = 'realization-failure'; return result }
+  const alphabet = '0123456789abcdef'
+  for (let i = 0; i < 32; i++) result.sha256 += alphabet.charAt(digest[i] >> 4) + alphabet.charAt(digest[i] & 15)
+  digest.fill(0)
+  result.status = 'ok'; result.byteLength = length
+  return result
+}

package/as/pulse-hmac-as.ts

@@ -318,12 +318,18 @@ export function pulse_crypto_hs256_verify(
 // by Crypto; host callers may stage synchronously, copy the output, then wipe.
 // It does not grow Wasm memory per operation or overlap allocator-owned memory.
 const __pulse_crypto_bytes_frame = new Uint8Array(8192 + 32768 + 32)
+// Allocate the larger digest-only frame only when a host stages a large hash.
+// Small digest/MAC callers and fixed-memory JWT guests keep the original frame.
+@lazy const __pulse_crypto_digest_frame = new Uint8Array(2097152 + 32)
+export function pulse_crypto_digest_frame_v1(): i32 {
+  return <i32>__pulse_crypto_digest_frame.dataStart
+}
 export function pulse_crypto_bytes_frame_v1(): i32 {
   return <i32>__pulse_crypto_bytes_frame.dataStart
 }
 
 export function pulse_crypto_sha256_bytes_v1(dataPointer: i32, dataLength: i32, outputPointer: i32, outputLength: i32): i32 {
-  if (dataLength < 0 || dataLength > 32768 || outputLength != 32
+  if (dataLength < 0 || dataLength > 2097152 || outputLength != 32
     || !__pulse_crypto_memory_range_valid(dataPointer, dataLength)
     || !__pulse_crypto_memory_range_valid(outputPointer, outputLength)) return __PULSE_CRYPTO_INVALID_INPUT
   const digest = __pulse_crypto_sha256_memory(<usize><u32>dataPointer, dataLength)

package/conformance/digest-text.json

@@ -0,0 +1,38 @@
+{
+  "version": "pulse.crypto-text-digest-corpus.v1",
+  "algorithm": "SHA-256",
+  "encoding": "lowercase-hex",
+  "maxUtf8Bytes": 2097152,
+  "vectors": [
+    {
+      "text": "",
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "byteLength": 0
+    },
+    {
+      "text": "abc",
+      "sha256": "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
+      "byteLength": 3
+    },
+    {
+      "text": "\ufeff\u00e9\ud83d\ude00\u0000\r\n",
+      "sha256": "894e231659c59a0e7c35180fbca175d0fb836eb20485a8d0dd02bf5ff8c2a4e7",
+      "byteLength": 12
+    },
+    {
+      "text": "\u00e9",
+      "sha256": "4a99557e4033c3539de2eb65472017cad5f9557f7a0625a09f1c3f6e2ba69c4c",
+      "byteLength": 2
+    },
+    {
+      "text": "e\u0301",
+      "sha256": "bf12767b0f2a56b2190075bae8169f656e3ce8d6357d4aff184bc6c7ea48f9f6",
+      "byteLength": 3
+    },
+    {
+      "text": "{ \"b\":2, \"a\":1 }",
+      "sha256": "a782da44b228c14de003efcebc359fbe0a5bc35d90d5da70513e54e25fa5428a",
+      "byteLength": 16
+    }
+  ]
+}

package/conformance/hs256.json

@@ -0,0 +1,85 @@
+{
+  "version": "pulse.crypto.hs256-conformance.v2",
+  "sources": {
+    "sha256": "NIST FIPS 180-4",
+    "hmac": "RFC 2104",
+    "vectors": "RFC 4231 test cases 6 and 7"
+  },
+  "resultStatuses": [
+    "valid",
+    "invalid-authenticator",
+    "invalid-key",
+    "invalid-input",
+    "realization-failure"
+  ],
+  "resourceLimits": {
+    "hmacKeyBytesMinimum": 32,
+    "hmacKeyBytesMaximum": 4096,
+    "macDataBytesMaximum": 1048576,
+    "hs256TagBytes": 32
+  },
+  "publishedVectors": [
+    {
+      "id": "rfc4231-6",
+      "keyByte": 170,
+      "keyLength": 131,
+      "dataHex": "54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374",
+      "tagHex": "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54"
+    },
+    {
+      "id": "rfc4231-7",
+      "keyByte": 170,
+      "keyLength": 131,
+      "dataHex": "5468697320697320612074657374207573696e672061206c6172676572207468616e20626c6f636b2d73697a65206b657920616e642061206c6172676572207468616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565647320746f20626520686173686564206265666f7265206265696e6720757365642062792074686520484d414320616c676f726974686d2e",
+      "tagHex": "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2"
+    }
+  ],
+  "boundaryVectors": {
+    "emptyData": {
+      "keyByte": 42,
+      "keyLength": 32,
+      "dataLength": 0,
+      "dataByte": 0,
+      "tagHex": "25e570b039a294705747f0783f32e9b538be395f8713fbcbf346844d84bc78ad"
+    },
+    "maximumData": {
+      "keyByte": 42,
+      "keyLength": 32,
+      "dataLength": 1048576,
+      "dataByte": 165,
+      "tagHex": "c897712d87b7a5649ec1115c6d7461372ff21fdebdc8711b23ddefc0a52e74a3"
+    }
+  },
+  "verificationCases": [
+    { "id": "valid-tag", "fixture": "rfc4231-6", "mutation": "none", "expected": "valid" },
+    { "id": "invalid-tag", "fixture": "rfc4231-6", "mutation": "zero-tag", "expected": "invalid-authenticator" },
+    { "id": "first-byte-mismatch", "fixture": "rfc4231-6", "mutation": "tag-byte-0", "expected": "invalid-authenticator" },
+    { "id": "middle-byte-mismatch", "fixture": "rfc4231-6", "mutation": "tag-byte-15", "expected": "invalid-authenticator" },
+    { "id": "last-byte-mismatch", "fixture": "rfc4231-6", "mutation": "tag-byte-31", "expected": "invalid-authenticator" },
+    { "id": "altered-data", "fixture": "rfc4231-6", "mutation": "data-byte-0", "expected": "invalid-authenticator" },
+    { "id": "wrong-key", "fixture": "rfc4231-6", "mutation": "key-byte-0", "expected": "invalid-authenticator" },
+    { "id": "undersized-key", "fixture": "rfc4231-6", "mutation": "key-length-31", "expected": "invalid-key" },
+    { "id": "malformed-key", "fixture": "rfc4231-6", "mutation": "malformed-key", "expected": "invalid-key" },
+    { "id": "empty-data", "fixture": "empty-data", "mutation": "none", "expected": "valid" },
+    { "id": "bounded-maximum-data", "fixture": "maximum-data", "mutation": "none", "expected": "valid" },
+    { "id": "over-limit-data", "fixture": "maximum-data", "mutation": "data-over-limit", "expected": "invalid-input" },
+    { "id": "malformed-tag", "fixture": "rfc4231-6", "mutation": "malformed-tag", "expected": "invalid-input" },
+    { "id": "wrong-length-tag", "fixture": "rfc4231-6", "mutation": "tag-length-31", "expected": "invalid-input" }
+  ],
+  "configurationCases": [
+    "inherited-global-crypto",
+    "named-profile-replacement",
+    "no-array-merging",
+    "no-object-merging",
+    "empty-array",
+    "empty-object",
+    "duplicate-array-entry",
+    "unknown-key",
+    "unknown-algorithm",
+    "unknown-realization",
+    "profile-missing-hs256",
+    "target-without-hs256",
+    "unavailable-exact-realization-pin",
+    "no-fallback-after-realization-failure"
+  ]
+}

package/dist/digest.d.ts

@@ -0,0 +1,14 @@
+import type { PulseContext, PulseParallelEffect } from '@pulse-compute/runtime';
+/** Exact UTF-8 text bound, independent of HMAC and JWT limits. */
+export declare const DIGEST_TEXT_MAX_BYTES: 2097152;
+export type TextDigestResult = {
+    readonly status: 'ok';
+    readonly sha256: string;
+    readonly byteLength: number;
+} | {
+    readonly status: 'failed';
+    readonly reason: 'invalid-text' | 'too-large' | 'unavailable' | 'realization-failure';
+};
+/** Hash exact, well-formed text without normalization, parsing or uploading. */
+export declare function digestText(ctx: PulseContext, text: string): PulseParallelEffect<TextDigestResult>;
+//# sourceMappingURL=digest.d.ts.map

package/dist/digest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"digest.d.ts","sourceRoot":"","sources":["../src/digest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAIhF,kEAAkE;AAClE,eAAO,MAAM,qBAAqB,EAAG,OAAgB,CAAC;AACtD,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,GAAG,aAAa,GAAG,qBAAqB,CAAA;CAAE,CAAC;AAOzH,gFAAgF;AAChF,wBAAgB,UAAU,CAAC,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAAC,gBAAgB,CAAC,CAMjG"}

package/dist/digest.js

@@ -0,0 +1,17 @@
+import packageRuntime from '@pulse-compute/runtime/package';
+import digestProvider from '../src/provider.cjs';
+/** Exact UTF-8 text bound, independent of HMAC and JWT limits. */
+export const DIGEST_TEXT_MAX_BYTES = 2097152;
+const runtime = packageRuntime.createPackageRuntime({
+    package: '@pulse-compute/crypto', contractId: 'pulse.crypto', providerKind: 'crypto',
+    operations: { digestText: { kind: 'crypto.digestText', capability: 'crypto.digestText', result: 'text-digest-result' } },
+});
+/** Hash exact, well-formed text without normalization, parsing or uploading. */
+export function digestText(ctx, text) {
+    // Preserve the over-limit signal without copying unbounded text into the
+    // shared effect envelope. This prefix is itself over the code-unit bound
+    // and is rejected before UTF-8 encoding or hashing on every realization.
+    const boundedText = typeof text === 'string' ? text.slice(0, DIGEST_TEXT_MAX_BYTES + 1) : null;
+    return runtime.effect(ctx, 'digestText', { text: boundedText }, digestProvider.normalizeTextDigestResult);
+}
+//# sourceMappingURL=digest.js.map

package/dist/digest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"digest.js","sourceRoot":"","sources":["../src/digest.ts"],"names":[],"mappings":"AACA,OAAO,cAAc,MAAM,gCAAgC,CAAC;AAC5D,OAAO,cAAc,MAAM,qBAAqB,CAAC;AAEjD,kEAAkE;AAClE,MAAM,CAAC,MAAM,qBAAqB,GAAG,OAAgB,CAAC;AAKtD,MAAM,OAAO,GAAG,cAAc,CAAC,oBAAoB,CAAC;IAClD,OAAO,EAAE,uBAAuB,EAAE,UAAU,EAAE,cAAc,EAAE,YAAY,EAAE,QAAQ;IACpF,UAAU,EAAE,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,mBAAmB,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,EAAE,oBAAoB,EAAE,EAAE;CAChH,CAAC,CAAC;AAEZ,gFAAgF;AAChF,MAAM,UAAU,UAAU,CAAC,GAAiB,EAAE,IAAY;IACxD,yEAAyE;IACzE,yEAAyE;IACzE,yEAAyE;IACzE,MAAM,WAAW,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC/F,OAAO,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,cAAc,CAAC,yBAAyB,CAAC,CAAC;AAC5G,CAAC"}

package/dist/index.d.ts

@@ -11,7 +11,10 @@ export declare const mac: Readonly<{
 export declare const signature: Readonly<{
     verify: typeof verifySignature;
 }>;
+export { DIGEST_TEXT_MAX_BYTES, digestText, type TextDigestResult } from './digest.js';
+import { digestText } from './digest.js';
 export declare const crypto: Readonly<{
+    digestText: typeof digestText;
     mac: Readonly<{
         verify: typeof verifyMac;
     }>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wCAAwC,EACxC,qCAAqC,EACrC,2CAA2C,EAC3C,kCAAkC,EAClC,sBAAsB,EACtB,qCAAqC,EACrC,4BAA4B,EAC5B,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC5B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,+BAA+B,EAE/B,iCAAiC,EAGlC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wCAAwC,EACxC,qCAAqC,EACrC,2CAA2C,EAC3C,kCAAkC,EAClC,sBAAsB,EACtB,qCAAqC,EACrC,4BAA4B,GAC7B,CAAC;AACF,YAAY,EACV,eAAe,EACf,wBAAwB,EACxB,wBAAwB,EACxB,oBAAoB,EACpB,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EAClB,sBAAsB,GACvB,CAAC;AAEF,OAAO,EACL,+BAA+B,EAC/B,iCAAiC,GAClC,CAAC;AAEF,wBAAsB,SAAS,CAC7B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,wBAAwB,CAAC,CAcnC;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,wBAAwB,CAAC,CAenC;AAED,eAAO,MAAM,GAAG;;EAEd,CAAC;AAEH,eAAO,MAAM,SAAS;;EAEpB,CAAC;AAEH,eAAO,MAAM,MAAM;;;;;;;EAGjB,CAAC;AAEH,eAAe,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wCAAwC,EACxC,qCAAqC,EACrC,2CAA2C,EAC3C,kCAAkC,EAClC,sBAAsB,EACtB,qCAAqC,EACrC,4BAA4B,EAC5B,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC5B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,+BAA+B,EAE/B,iCAAiC,EAGlC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wCAAwC,EACxC,qCAAqC,EACrC,2CAA2C,EAC3C,kCAAkC,EAClC,sBAAsB,EACtB,qCAAqC,EACrC,4BAA4B,GAC7B,CAAC;AACF,YAAY,EACV,eAAe,EACf,wBAAwB,EACxB,wBAAwB,EACxB,oBAAoB,EACpB,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,wBAAwB,EACxB,kBAAkB,EAClB,sBAAsB,GACvB,CAAC;AAEF,OAAO,EACL,+BAA+B,EAC/B,iCAAiC,GAClC,CAAC;AAEF,wBAAsB,SAAS,CAC7B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,wBAAwB,CAAC,CAcnC;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,wBAAwB,CAAC,CAenC;AAED,eAAO,MAAM,GAAG;;EAEd,CAAC;AAEH,eAAO,MAAM,SAAS;;EAEpB,CAAC;AAEH,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,MAAM;;;;;;;;EAIjB,CAAC;AAEH,eAAe,MAAM,CAAC"}

package/dist/index.js

@@ -44,7 +44,10 @@ export const mac = Object.freeze({
 export const signature = Object.freeze({
     verify: verifySignature,
 });
+export { DIGEST_TEXT_MAX_BYTES, digestText } from './digest.js';
+import { digestText } from './digest.js';
 export const crypto = Object.freeze({
+    digestText,
     mac,
     signature,
 });

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wCAAwC,EACxC,qCAAqC,EACrC,2CAA2C,EAC3C,kCAAkC,EAClC,sBAAsB,EACtB,qCAAqC,EACrC,4BAA4B,GAa7B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,EACzB,iCAAiC,EACjC,+BAA+B,EAC/B,2BAA2B,GAC5B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wCAAwC,EACxC,qCAAqC,EACrC,2CAA2C,EAC3C,kCAAkC,EAClC,sBAAsB,EACtB,qCAAqC,EACrC,4BAA4B,GAC7B,CAAC;AAgBF,OAAO,EACL,+BAA+B,EAC/B,iCAAiC,GAClC,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,OAAyB;IAEzB,IAAI,UAAwD,CAAC;IAC7D,IAAI,CAAC;QACH,UAAU,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;IAClD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,2BAA2B,CAAC,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,IAAI,CAAC,UAAU,CAAC,EAAE;QAAE,OAAO,UAAU,CAAC,MAAM,CAAC;IAE7C,IAAI,CAAC;QACH,OAAO,2BAA2B,CAAC,MAAM,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,2BAA2B,CAAC,SAAS,CAAC,CAAC;IAChD,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,OAA+B;IAE/B,IAAI,UAA8D,CAAC;IACnE,IAAI,CAAC;QACH,UAAU,GAAG,+BAA+B,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,2BAA2B,CAAC,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,IAAI,CAAC,UAAU,CAAC,EAAE;QAAE,OAAO,UAAU,CAAC,MAAM,CAAC;IAE7C,IAAI,CAAC;QACH,OAAO,2BAA2B,CAAC,MAAM,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5E,CAAC;IAAC,MAAM,CAAC;QACP,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrC,OAAO,2BAA2B,CAAC,SAAS,CAAC,CAAC;IAChD,CAAC;AACH,CAAC;AAED,MAAM,CAAC,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC;IAC/B,MAAM,EAAE,SAAS;CAClB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;IACrC,MAAM,EAAE,eAAe;CACxB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAClC,GAAG;IACH,SAAS;CACV,CAAC,CAAC;AAEH,eAAe,MAAM,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wCAAwC,EACxC,qCAAqC,EACrC,2CAA2C,EAC3C,kCAAkC,EAClC,sBAAsB,EACtB,qCAAqC,EACrC,4BAA4B,GAa7B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,EACzB,iCAAiC,EACjC,+BAA+B,EAC/B,2BAA2B,GAC5B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,wCAAwC,EACxC,qCAAqC,EACrC,2CAA2C,EAC3C,kCAAkC,EAClC,sBAAsB,EACtB,qCAAqC,EACrC,4BAA4B,GAC7B,CAAC;AAgBF,OAAO,EACL,+BAA+B,EAC/B,iCAAiC,GAClC,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,OAAyB;IAEzB,IAAI,UAAwD,CAAC;IAC7D,IAAI,CAAC;QACH,UAAU,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;IAClD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,2BAA2B,CAAC,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,IAAI,CAAC,UAAU,CAAC,EAAE;QAAE,OAAO,UAAU,CAAC,MAAM,CAAC;IAE7C,IAAI,CAAC;QACH,OAAO,2BAA2B,CAAC,MAAM,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,2BAA2B,CAAC,SAAS,CAAC,CAAC;IAChD,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,OAA+B;IAE/B,IAAI,UAA8D,CAAC;IACnE,IAAI,CAAC;QACH,UAAU,GAAG,+BAA+B,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,2BAA2B,CAAC,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,IAAI,CAAC,UAAU,CAAC,EAAE;QAAE,OAAO,UAAU,CAAC,MAAM,CAAC;IAE7C,IAAI,CAAC;QACH,OAAO,2BAA2B,CAAC,MAAM,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5E,CAAC;IAAC,MAAM,CAAC;QACP,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrC,OAAO,2BAA2B,CAAC,SAAS,CAAC,CAAC;IAChD,CAAC;AACH,CAAC;AAED,MAAM,CAAC,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC;IAC/B,MAAM,EAAE,SAAS;CAClB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;IACrC,MAAM,EAAE,eAAe;CACxB,CAAC,CAAC;AAEH,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAyB,MAAM,aAAa,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAClC,UAAU;IACV,GAAG;IACH,SAAS;CACV,CAAC,CAAC;AAEH,eAAe,MAAM,CAAC"}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@pulse-compute/crypto",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.5",
   "license": "Apache-2.0",
   "engines": {
     "node": "^22.14.0 || ^24.0.0"
   },
-  "description": "Provider-neutral cryptographic verification contracts for Pulse.",
+  "description": "Provider-neutral cryptographic verification and bounded exact-text digests for Pulse.",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -15,7 +15,9 @@
       "default": "./dist/index.js"
     },
     "./pulsewasm-native": "./pulsewasm.native.cjs",
-    "./provider": "./src/provider.cjs"
+    "./provider": "./src/provider.cjs",
+    "./pulsewasm/manifest": "./pulsewasm.manifest.cjs",
+    "./pulsewasm/compiler": "./pulsewasm.compiler.cjs"
   },
   "files": [
     "as",
@@ -23,6 +25,10 @@
     "pulsewasm.native.cjs",
     "README.md",
     "src/provider.cjs",
+    "pulse.package.json",
+    "pulsewasm.manifest.cjs",
+    "pulsewasm.compiler.cjs",
+    "conformance",
     "LICENSE",
     "NOTICE"
   ],
@@ -37,9 +43,19 @@
   "bugs": {
     "url": "https://github.com/pulse-compute/pulse/issues"
   },
-  "homepage": "https://pulsecompute.io/v1.0.0-beta.4/packages/crypto/",
+  "homepage": "https://pulsecompute.io/v1.0.0-beta.5/packages/crypto/",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "pulse": {
+    "contract": "./pulse.package.json"
+  },
+  "pulsewasm": {
+    "manifest": "./pulsewasm.manifest.cjs"
+  },
+  "dependencies": {
+    "@pulse-compute/runtime": "1.0.0-beta.5",
+    "@pulse-compute/wasm-contracts": "1.0.0-beta.5"
+  },
   "scripts": {
     "build": "tsc -b",
     "test": "corepack pnpm --dir ../.. exec vitest run packages/crypto/test",

package/pulse.package.json

@@ -0,0 +1,64 @@
+{
+  "version": "pulse.package-contract.v1",
+  "kind": "pulse.package-contract",
+  "contractId": "pulse.crypto",
+  "npmPackage": "@pulse-compute/crypto",
+  "description": "Bounded exact-text SHA-256 through an execution-owned effect.",
+  "authoring": {
+    "namespace": "crypto",
+    "import": "@pulse-compute/crypto",
+    "symbols": [
+      "digestText"
+    ]
+  },
+  "ownership": {
+    "profileFragment": "crypto",
+    "helperImports": [],
+    "reExportImports": []
+  },
+  "composition": {
+    "status": "reserved",
+    "helperSymbol": "crypto",
+    "profileToken": "opaque-direct-use",
+    "reasonCode": "PULSE_PACKAGE_COMPOSITION_HELPER_NOT_REALIZED"
+  },
+  "targets": {
+    "native": {
+      "status": "provider-dependent",
+      "realization": "canonical-package-lowering",
+      "lowerableSubpath": "@pulse-compute/crypto",
+      "providerRequirements": [
+        "crypto.digestText"
+      ],
+      "reasonCode": "PULSE_PACKAGE_PROVIDER_CAPABILITY_REQUIRED"
+    },
+    "javascript": {
+      "status": "supported",
+      "realization": "javascript-package-runtime",
+      "entry": "./dist/index.js",
+      "providerRequirements": [
+        "crypto.digestText"
+      ]
+    }
+  },
+  "lowering": {
+    "manifest": "./pulsewasm.manifest.cjs",
+    "trust": "first-party",
+    "canonicalOperationVersion": "pulse.canonical-package-operation.v1",
+    "bundleVersion": "pulse.package-lowering-bundle.v1",
+    "providerRequirementVersion": "pulse.provider-requirement-record.v1"
+  },
+  "conformance": {
+    "status": "target-overlap",
+    "fixtureRoots": [
+      "./conformance"
+    ],
+    "semanticCases": [
+      "crypto.digestText"
+    ]
+  },
+  "docs": {
+    "readme": "./README.md",
+    "contract": "./pulse.package.json"
+  }
+}

package/pulsewasm.compiler.cjs

@@ -0,0 +1,89 @@
+'use strict';
+const { normalizeDiagnostic, sourceLoc } = require('@pulse-compute/wasm-contracts/diagnostics');
+const { CANONICAL_PACKAGE_EFFECT_VERSION } = require('@pulse-compute/wasm-contracts/handler/canonical-runtime');
+const { PACKAGE_CRYPTO_REQUIREMENT_VERSION } = require('@pulse-compute/wasm-contracts/package/package-contract');
+const PACKAGE = '@pulse-compute/crypto';
+function buildCryptoLoweringPlan(input = {}) {
+  const ts = input.typescript || require('typescript');
+  const source = input.sourceFile || ts.createSourceFile(input.sourcePath || 'index.ts', input.sourceText || '', ts.ScriptTarget.ES2022, true);
+  const namespaces = new Set(), direct = new Set(), diagnostics = [], effects = [];
+  const error = (node, suffix, message) => diagnostics.push(normalizeDiagnostic({
+    phase: 'crypto-lowering', severity: 'error', code: `PULSEWASM_CRYPTO_DIGEST_${suffix}`, message,
+    hint: 'Await crypto.digestText(ctx, text) into a local variable or use it as a direct keyed ctx.parallel member.', loc: sourceLoc(source, node)
+  }));
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement) || statement.moduleSpecifier.text !== PACKAGE || statement.importClause?.isTypeOnly) continue;
+    if (statement.importClause?.name) namespaces.add(statement.importClause.name.text);
+    const named = statement.importClause?.namedBindings;
+    if (named && ts.isNamedImports(named)) for (const entry of named.elements) {
+      if (entry.isTypeOnly) continue;
+      const name = (entry.propertyName || entry.name).text;
+      if (name === 'crypto') namespaces.add(entry.name.text);
+      if (name === 'digestText') direct.add(entry.name.text);
+    }
+  }
+  function checkBinding(name) {
+    if (ts.isIdentifier(name)) {
+      if (namespaces.has(name.text) || direct.has(name.text)) error(name, 'SHADOWED', 'Imported Crypto bindings cannot be shadowed.');
+    } else if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+      for (const element of name.elements) if (ts.isBindingElement(element)) checkBinding(element.name);
+    }
+  }
+  function isDigest(expression) {
+    return ts.isIdentifier(expression) && direct.has(expression.text)
+      || ts.isPropertyAccessExpression(expression) && expression.name.text === 'digestText'
+        && ts.isIdentifier(expression.expression) && namespaces.has(expression.expression.text);
+  }
+  // Verification remains an ordinary JavaScript API. Its existing facade
+  // aliases and helpers must not acquire digest-specific authoring restrictions.
+  let hasDigestUse = false;
+  function findDigestUse(node) {
+    if (ts.isImportDeclaration(node) || ts.isTypeNode(node)) return;
+    if (isDigest(node)
+      || ts.isPropertyAccessExpression(node) && node.name.text === 'digestText'
+      || ts.isElementAccessExpression(node) && node.argumentExpression && ts.isStringLiteralLike(node.argumentExpression) && node.argumentExpression.text === 'digestText') hasDigestUse = true;
+    ts.forEachChild(node, findDigestUse);
+  }
+  findDigestUse(source);
+  function visit(node) {
+    if (ts.isTypeNode(node)) return;
+    if ((ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) && node.name) checkBinding(node.name);
+    if (ts.isIdentifier(node) && namespaces.has(node.text)
+      && !ts.isImportClause(node.parent) && !ts.isImportSpecifier(node.parent)
+      && !(ts.isPropertyAccessExpression(node.parent))) error(node, 'DETACHED', 'The Crypto facade cannot be detached or accessed dynamically.');
+    if (isDigest(node) && !ts.isImportSpecifier(node.parent)
+      && !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node)
+      && (!ts.isCallExpression(node.parent) || node.parent.expression !== node)) error(node, 'DETACHED', 'Digest operations cannot be detached or aliased.');
+    if (ts.isCallExpression(node) && isDigest(node.expression)) {
+      let fn = node.parent;
+      while (fn && !ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn)) fn = fn.parent;
+      const ctx = fn && fn.parameters[0] && fn.parameters[0].name;
+      if (node.arguments.length !== 2 || !ctx || !ts.isIdentifier(ctx)
+        || !ts.isIdentifier(node.arguments[0]) || node.arguments[0].text !== ctx.text) {
+        error(node, 'ARGUMENTS', 'Digest requires the current handler context and one text input.'); return;
+      }
+      let placement = '';
+      const parent = node.parent;
+      if (ts.isAwaitExpression(parent) && ts.isVariableDeclaration(parent.parent)) placement = 'variable';
+      if (ts.isPropertyAssignment(parent) && ts.isObjectLiteralExpression(parent.parent)) {
+        const call = parent.parent.parent;
+        if (ts.isCallExpression(call) && ts.isPropertyAccessExpression(call.expression)
+          && ts.isIdentifier(call.expression.expression) && call.expression.expression.text === ctx.text
+          && call.expression.name.text === 'parallel' && ts.isAwaitExpression(call.parent)) placement = 'statement';
+      }
+      if (!placement) { error(node, 'PLACEMENT', 'Digest must be directly awaited or grouped.'); return; }
+      effects.push({ version: CANONICAL_PACKAGE_EFFECT_VERSION, contractId: 'pulse.crypto', package: PACKAGE, import: PACKAGE,
+        kind: 'crypto.digestText', capability: 'crypto.digestText', result: 'text-digest-result', providerKind: 'crypto', operation: 'digestText', placement,
+        range: { start: node.getStart(source), end: node.getEnd() }, resource: {}, payload: {},
+        runtimeInputs: [{ name: 'text', argumentIndex: 1, source: 'package-call-argument' }],
+        providerRequirements: ['crypto.digestText'], schemaReferences: [], redaction: ['text', 'sha256'], loc: sourceLoc(source, node) });
+    }
+    ts.forEachChild(node, visit);
+  }
+  if (hasDigestUse) visit(source);
+  const cryptoRequirements = effects.length ? [{ version: PACKAGE_CRYPTO_REQUIREMENT_VERSION, algorithms: ['SHA-256'], reachable: true, requestedBy: PACKAGE, semanticOwner: PACKAGE }] : [];
+  return { artifact: { version: 'pulse.crypto-text-lowering-plan.v1', contractId: 'pulse.crypto', package: PACKAGE, lowerableSubpath: PACKAGE,
+    status: diagnostics.length ? 'error' : 'ok', canonicalEffects: effects, cryptoRequirements },
+    canonicalEffects: effects, cryptoRequirements, diagnostics, hasErrors: diagnostics.length > 0 };
+}
+module.exports = { buildCryptoLoweringPlan };

package/pulsewasm.manifest.cjs

@@ -0,0 +1,15 @@
+'use strict';
+module.exports = Object.freeze({
+  version: 'pulsewasm.lowerable-library-manifest.v2', kind: 'pulsewasm.lowerable-library-manifest',
+  contractId: 'pulse.crypto', npmPackage: '@pulse-compute/crypto', lowerableSubpath: '@pulse-compute/crypto',
+  facade: { namespace: 'crypto', import: '@pulse-compute/crypto', symbols: ['digestText'] },
+  publicApi: { package: '@pulse-compute/crypto', symbols: ['crypto', 'digestText'], compatibilitySubpaths: [], loweringIntentionallyNarrow: true },
+  compiler: { version: 'pulsewasm.lowerable-compiler-builder.v1', entry: './pulsewasm.compiler.cjs', export: 'buildCryptoLoweringPlan', artifact: 'crypto-lowering-plan.json', builderOwner: '@pulse-compute/crypto', trust: 'first-party', inputs: ['typescript.SourceFile'] },
+  modes: {
+    typescript: { entry: './dist/index.js' }, jsEngine: { entry: './dist/index.js', behavior: 'provider-dependent' },
+    wasm: { mode: 'wasm-sidecar', sidecar: './as/digest-text.as.ts',
+      lowerings: [{ tsSymbol: 'crypto.digestText', asSymbol: '__pulse_crypto_digest_text', callShape: 'context-runtime-text', hostCapabilities: ['result'] }],
+      hostCapabilities: ['result'] }
+  },
+  policy: { packageOwnsFacadeMapping: true, canonicalRootLowering: true, automaticFallback: false }
+});

package/pulsewasm.native.cjs

@@ -45,6 +45,7 @@ function pulseHmacAssemblyScriptSource(algorithm = 'HS256') {
       'pulse_crypto_hs256_verify',
       'pulse_crypto_sha256_digest',
       'pulse_crypto_bytes_frame_v1',
+      'pulse_crypto_digest_frame_v1',
       'pulse_crypto_sha256_bytes_v1',
       'pulse_crypto_hmac_sha256_bytes_v1'
     ]),
@@ -55,8 +56,10 @@ function pulseHmacAssemblyScriptSource(algorithm = 'HS256') {
       hs256TagBytes: 32,
       byteOperationKeyBytesMaximum: 8192,
       byteOperationDataBytesMaximum: 32768,
+      digestDataBytesMaximum: 2097152,
       byteOperationOutputBytes: 32,
-      byteOperationFrameBytes: 40992
+      byteOperationFrameBytes: 40992,
+      digestFrameBytes: 2097184
     }),
     resultCodes: Object.freeze({
       valid: 1,
@@ -76,20 +79,23 @@ function pulseHmacAssemblyScriptSource(algorithm = 'HS256') {
 
 function bindNativeDigestMac(moduleExports) {
   const memory = moduleExports && moduleExports.memory;
-  const names = ['pulse_crypto_bytes_frame_v1', 'pulse_crypto_sha256_bytes_v1', 'pulse_crypto_hmac_sha256_bytes_v1'];
+  const names = ['pulse_crypto_bytes_frame_v1', 'pulse_crypto_digest_frame_v1', 'pulse_crypto_sha256_bytes_v1', 'pulse_crypto_hmac_sha256_bytes_v1'];
   if (!(memory instanceof WebAssembly.Memory) || names.some((name) => typeof moduleExports[name] !== 'function')) {
     throw new TypeError('Native Crypto digest/MAC exports are unavailable.');
   }
-  const frameBytes = 8192 + 32768 + 32;
   function run(data, key) {
-    if (!(data instanceof Uint8Array) || data.length > 32768
+    if (!(data instanceof Uint8Array) || data.length > (key === undefined ? 2097152 : 32768)
       || (key !== undefined && (!(key instanceof Uint8Array) || key.length > 8192))) {
       throw new TypeError('Native Crypto digest/MAC input exceeds its byte contract.');
     }
-    const pointer = moduleExports.pulse_crypto_bytes_frame_v1() >>> 0;
+    const largeDigest = key === undefined && data.length > 32768;
+    const dataBytes = largeDigest ? 2097152 : 32768;
+    const keyBytes = largeDigest ? 0 : 8192;
+    const frameBytes = keyBytes + dataBytes + 32;
+    const pointer = (largeDigest ? moduleExports.pulse_crypto_digest_frame_v1() : moduleExports.pulse_crypto_bytes_frame_v1()) >>> 0;
     if (pointer + frameBytes > memory.buffer.byteLength) throw new TypeError('Native Crypto frame is outside memory.');
-    const dataPointer = pointer + 8192;
-    const outputPointer = dataPointer + 32768;
+    const dataPointer = pointer + keyBytes;
+    const outputPointer = dataPointer + dataBytes;
     try {
       const view = new Uint8Array(memory.buffer);
       view.set(data, dataPointer);

package/src/provider.cjs

@@ -19,7 +19,7 @@ function bindJavascriptDigestMac(algorithms, subtle = globalThis.crypto && globa
     || algorithms.includes('HMAC-SHA256') && (typeof subtle.sign !== 'function' || typeof subtle.importKey !== 'function')) throw new TypeError('Selected Web Crypto byte realization is unavailable.');
   const bytes = {};
   if (algorithms.includes('SHA-256')) bytes.sha256 = async (input) => {
-    const data = snapshot(input, 32768);
+    const data = snapshot(input, 2097152);
     try { return result(await subtle.digest({ name: 'SHA-256' }, data)); }
     finally { data.fill(0); }
   };
@@ -40,4 +40,73 @@ function bindJavascriptDigestMac(algorithms, subtle = globalThis.crypto && globa
     algorithms: Object.freeze(algorithms.map((algorithm) => Object.freeze({ algorithm, realization: 'runtime-builtin', implementation: IMPLEMENTATIONS[algorithm], available: true, automaticFallback: false })))
   }) });
 }
-module.exports = Object.freeze({ IMPLEMENTATIONS, bindJavascriptDigestMac });
+const DIGEST_TEXT_MAX_BYTES = 2097152;
+const digestFailures = Object.freeze(Object.fromEntries(
+  ['invalid-text', 'too-large', 'unavailable', 'realization-failure'].map(reason => [reason, Object.freeze({ status: 'failed', reason })])
+));
+// Count scalar UTF-8 bytes before allocating staging; do not replace surrogates.
+function textDigestByteLength(text) {
+  if (typeof text !== 'string') return -1;
+  if (text.length > DIGEST_TEXT_MAX_BYTES) return -2;
+  let bytes = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c >= 0xd800 && c <= 0xdbff) {
+      const low = text.charCodeAt(++i);
+      if (!(low >= 0xdc00 && low <= 0xdfff)) return -1;
+      bytes += 4;
+    } else if (c >= 0xdc00 && c <= 0xdfff) return -1;
+    else bytes += c < 0x80 ? 1 : c < 0x800 ? 2 : 3;
+  }
+  return bytes > DIGEST_TEXT_MAX_BYTES ? -2 : bytes;
+}
+function normalizeTextDigestResult(value) {
+  const failed = digestFailures['realization-failure'];
+  if (!value || typeof value !== 'object' || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return failed;
+  const properties = Object.getOwnPropertyDescriptors(value), keys = Reflect.ownKeys(properties);
+  if (keys.some(key => typeof key !== 'string' || !properties[key].enumerable || !Object.hasOwn(properties[key], 'value'))) return failed;
+  const status = properties.status?.value, reason = properties.reason?.value;
+  if (status === 'failed' && keys.length === 2 && typeof reason === 'string' && Object.hasOwn(digestFailures, reason)) return digestFailures[reason];
+  const sha256 = properties.sha256?.value, byteLength = properties.byteLength?.value;
+  if (status !== 'ok' || keys.length !== 3 || typeof sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(sha256)
+    || !Number.isInteger(byteLength) || byteLength < 0 || byteLength > DIGEST_TEXT_MAX_BYTES) return failed;
+  return Object.freeze({ status: 'ok', sha256, byteLength });
+}
+function checkDigestCancellation(signal) {
+  if (signal?.aborted) throw signal.reason || new Error('Pulse digest invocation cancelled.');
+}
+async function executeTextDigest(effect, options = {}) {
+  if (!effect || effect.package !== '@pulse-compute/crypto' || effect.contractId !== 'pulse.crypto'
+    || effect.providerKind !== 'crypto' || effect.operation !== 'digestText'
+    || effect.kind !== 'crypto.digestText' || effect.capability !== 'crypto.digestText') throw new TypeError('Invalid Crypto digest effect authority.');
+  checkDigestCancellation(options.signal);
+  const text = effect.payload?.text, byteLength = textDigestByteLength(text);
+  if (byteLength < 0) return digestFailures[byteLength === -1 ? 'invalid-text' : 'too-large'];
+  const realization = options.cryptoTarget === 'javascript' ? 'runtime-builtin' : 'guest-source:pulse-hmac-as';
+  const bytes = options.cryptoVerifier?.bytes, algorithms = options.cryptoRealization?.algorithms;
+  if (typeof bytes?.sha256 !== 'function' || !Array.isArray(algorithms)
+    || !algorithms.some(entry => entry.algorithm === 'SHA-256' && entry.available === true && entry.realization === realization)) return digestFailures.unavailable;
+  const data = new TextEncoder().encode(text);
+  let digest;
+  try {
+    digest = await bytes.sha256(data);
+    checkDigestCancellation(options.signal);
+    if (!(digest instanceof Uint8Array) || digest.length !== 32) return digestFailures['realization-failure'];
+    const sha256 = Array.from(digest, byte => byte.toString(16).padStart(2, '0')).join('');
+    return Object.freeze({ status: 'ok', sha256, byteLength });
+  } catch (error) {
+    checkDigestCancellation(options.signal);
+    return digestFailures['realization-failure'];
+  } finally { data.fill(0); if (digest instanceof Uint8Array) digest.fill(0); }
+}
+function createJavascriptTextDigest(options = {}) {
+  return (effect, execution = {}) => {
+    let selected;
+    try { selected = bindJavascriptDigestMac(['SHA-256'], options.digestSubtle === undefined ? globalThis.crypto?.subtle : options.digestSubtle); }
+    catch { selected = undefined; }
+    return executeTextDigest(effect, { signal: execution.signal, cryptoTarget: 'javascript',
+      cryptoVerifier: selected, cryptoRealization: selected?.realization });
+  };
+}
+module.exports = Object.freeze({ IMPLEMENTATIONS, bindJavascriptDigestMac, DIGEST_TEXT_MAX_BYTES,
+  textDigestByteLength, normalizeTextDigestResult, executeTextDigest, createJavascriptTextDigest });