ox 1.0.5 → 1.1.2

package/src/wasm/Mnemonic.ts

@@ -0,0 +1,44 @@
+import type * as Engine from '../core/Engine.js'
+import type * as Errors from '../core/Errors.js'
+import * as crypto25519 from './internal/crypto25519.js'
+import * as internal from './internal/instantiate.js'
+import * as mnemonic from './internal/mnemonic.js'
+
+export * from '../core/Mnemonic.js'
+export { MemoryError } from './internal/instantiate.js'
+
+/**
+ * Compiles the WASM implementation of [`Mnemonic.toSeed`](/api/Mnemonic/toSeed),
+ * without installing it.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { Mnemonic } from 'ox/wasm'
+ *
+ * await Engine.install({ Mnemonic: Mnemonic.engine() })
+ *
+ * Mnemonic.toSeed(
+ *   'test test test test test test test test test test test junk'
+ * )
+ * ```
+ *
+ * @returns The WASM implementation of the `Mnemonic` slot.
+ */
+export async function engine(): Promise<engine.ReturnType> {
+  const module = await crypto25519.load()
+
+  return {
+    toSeed: (value, passphrase) => mnemonic.toSeed(module, value, passphrase),
+  }
+}
+
+export declare namespace engine {
+  /** Every `Mnemonic` primitive this module implements. */
+  type ReturnType = {
+    toSeed: NonNullable<Engine.Mnemonic['toSeed']>
+  }
+
+  type ErrorType = internal.MemoryError | Errors.GlobalErrorType
+}

package/src/wasm/X25519.ts

@@ -0,0 +1,70 @@
+import type * as Engine from '../core/Engine.js'
+import type * as Errors from '../core/Errors.js'
+import * as crypto25519 from './internal/crypto25519.js'
+import * as internal from './internal/instantiate.js'
+import * as x25519 from './internal/x25519.js'
+
+export * from '../core/X25519.js'
+export { MemoryError } from './internal/instantiate.js'
+
+const keySize = 32
+
+/**
+ * Compiles WASM implementations of selected [`X25519`](/api/X25519)
+ * primitives, without installing them.
+ *
+ * Random key generation remains on Ox's default implementation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Engine } from 'ox'
+ * import { X25519 } from 'ox/wasm'
+ *
+ * await Engine.install({ X25519: X25519.engine() })
+ *
+ * X25519.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @returns The WASM implementation of part of the `X25519` slot.
+ */
+export async function engine(): Promise<engine.ReturnType> {
+  const module = await crypto25519.load()
+
+  return {
+    getPublicKey(privateKey) {
+      assertLength(privateKey, 'private')
+      module.reserve(keySize * 2)
+      const privateKeyPtr = module.heapBase
+      const publicKeyPtr = privateKeyPtr + keySize
+      try {
+        module.view().set(privateKey, privateKeyPtr)
+        module.exports.x25519_get_public_key(privateKeyPtr, publicKeyPtr)
+        return module.view().slice(publicKeyPtr, publicKeyPtr + keySize)
+      } finally {
+        module.exports.zero(privateKeyPtr, keySize * 2)
+      }
+    },
+    getSharedSecret(privateKey, publicKey) {
+      assertLength(privateKey, 'private')
+      assertLength(publicKey, 'public')
+      return x25519.getSharedSecret(module, privateKey, publicKey)
+    },
+  }
+}
+
+export declare namespace engine {
+  /** Every `X25519` primitive this module implements. */
+  type ReturnType = {
+    [key in 'getPublicKey' | 'getSharedSecret']-?: NonNullable<Engine.Ecdh[key]>
+  }
+
+  type ErrorType = internal.MemoryError | Errors.GlobalErrorType
+}
+
+function assertLength(key: Uint8Array, type: 'private' | 'public'): void {
+  if (key.length !== keySize)
+    throw new RangeError(
+      `X25519 ${type} key must be ${keySize} bytes, got ${key.length}`,
+    )
+}

package/src/wasm/_test/Crypto25519.conformance.ts

@@ -0,0 +1,57 @@
+import { ed25519, x25519 } from '@noble/curves/ed25519.js'
+import { mnemonicToSeedSync } from '@scure/bip39'
+import { describe, expect, test } from 'vp/test'
+import { vectors } from '../../../test/vectors/bip39/index.js'
+import * as Ed25519 from '../Ed25519.js'
+import * as Mnemonic from '../Mnemonic.js'
+import * as X25519 from '../X25519.js'
+
+describe('crypto25519 WASM', () => {
+  test('behavior: Ed25519 works in this runtime', async () => {
+    const engine = await Ed25519.engine()
+    const privateKey = fromHex(
+      '9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60',
+    )
+    const payload = new TextEncoder().encode('browser conformance')
+    const publicKey = engine.getPublicKey(privateKey)
+    const signature = engine.sign(payload, privateKey)
+
+    expect(publicKey).toEqual(ed25519.getPublicKey(privateKey))
+    expect(signature).toEqual(ed25519.sign(payload, privateKey))
+    expect(engine.verify(signature, payload, publicKey)).toBe(true)
+  })
+
+  test('behavior: X25519 works in this runtime', async () => {
+    const engine = await X25519.engine()
+    const privateKey = fromHex(
+      '77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a',
+    )
+    const peerPrivateKey = fromHex(
+      '5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb',
+    )
+    const publicKey = x25519.getPublicKey(peerPrivateKey)
+
+    expect(engine.getPublicKey(privateKey)).toEqual(
+      x25519.getPublicKey(privateKey),
+    )
+    expect(engine.getSharedSecret(privateKey, publicKey)).toEqual(
+      x25519.getSharedSecret(privateKey, publicKey),
+    )
+  })
+
+  test('behavior: Unicode BIP-39 works in this runtime', async () => {
+    const engine = await Mnemonic.engine()
+    const vector = vectors.japanese
+
+    expect(engine.toSeed(vector.mnemonic, vector.passphrase)).toEqual(
+      mnemonicToSeedSync(vector.mnemonic, vector.passphrase),
+    )
+  })
+})
+
+function fromHex(value: string): Uint8Array {
+  const bytes = new Uint8Array(value.length / 2)
+  for (let index = 0; index < bytes.length; index++)
+    bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16)
+  return bytes
+}

package/src/wasm/_test/Crypto25519.fuzz.ts

@@ -0,0 +1,187 @@
+import { fc, test } from '@fast-check/vitest'
+import { ed25519, x25519 } from '@noble/curves/ed25519.js'
+import { mnemonicToSeedSync } from '@scure/bip39'
+import { beforeAll, describe, expect } from 'vp/test'
+import { numRuns } from '../../../test/fuzz/numRuns.js'
+import * as Ed25519 from '../Ed25519.js'
+import * as Mnemonic from '../Mnemonic.js'
+import * as X25519 from '../X25519.js'
+import { x25519LowOrder } from './fixtures.js'
+
+let ed25519Engine: Ed25519.engine.ReturnType
+let mnemonicEngine: Mnemonic.engine.ReturnType
+let x25519Engine: X25519.engine.ReturnType
+
+beforeAll(async () => {
+  ed25519Engine = await Ed25519.engine()
+  mnemonicEngine = await Mnemonic.engine()
+  x25519Engine = await X25519.engine()
+})
+
+const arbitraryKey = fc.uint8Array({ maxLength: 32, minLength: 32 })
+const arbitraryPayload = fc.oneof(
+  fc.uint8Array({ maxLength: 512 }),
+  fc
+    .constantFrom(0, 1, 31, 32, 63, 64, 65, 127, 128, 129, 1024, 4096)
+    .chain((size) => fc.uint8Array({ maxLength: size, minLength: size })),
+)
+const arbitraryWord = fc.oneof(
+  fc
+    .string({ maxLength: 16, minLength: 1 })
+    .filter((value) => !value.normalize('NFKD').includes(' ')),
+  fc.constantFrom('café', 'cafe\u0301', 'あおぞら', '㍍ガバヴァ'),
+)
+const arbitraryMnemonic = fc
+  .tuple(
+    fc.constantFrom(12, 15, 18, 21, 24),
+    fc.array(arbitraryWord, { maxLength: 24, minLength: 24 }),
+  )
+  .map(([count, words]) => words.slice(0, count).join(' '))
+
+describe('Ed25519', () => {
+  test.prop(
+    { payload: arbitraryPayload, privateKey: arbitraryKey },
+    { numRuns },
+  )('matches the default for arbitrary subviews', (options) => {
+    const payload = offsetView(options.payload)
+    const privateKey = offsetView(options.privateKey)
+    const publicKey = ed25519Engine.getPublicKey(privateKey)
+    const signature = ed25519Engine.sign(payload, privateKey)
+
+    expect(publicKey).toEqual(ed25519.getPublicKey(privateKey))
+    expect(signature).toEqual(ed25519.sign(payload, privateKey))
+    expect(ed25519Engine.verify(signature, payload, publicKey)).toBe(true)
+    expect(
+      ed25519Engine.verify(signature, Uint8Array.of(...payload, 1), publicKey),
+    ).toBe(false)
+    expect(ed25519Engine.toMontgomerySecret(privateKey)).toEqual(
+      ed25519.utils.toMontgomerySecret(privateKey),
+    )
+  })
+
+  test.prop(
+    {
+      payload: arbitraryPayload,
+      publicKey: arbitraryKey,
+      signature: fc.uint8Array({ maxLength: 64, minLength: 64 }),
+    },
+    { numRuns },
+  )('verification matches ZIP-215 for arbitrary encodings', (options) => {
+    expect(
+      ed25519Engine.verify(
+        options.signature,
+        options.payload,
+        options.publicKey,
+      ),
+    ).toBe(
+      ed25519.verify(options.signature, options.payload, options.publicKey),
+    )
+  })
+})
+
+describe('X25519', () => {
+  test.prop(
+    { privateKey: arbitraryKey, publicKeySeed: arbitraryKey },
+    { numRuns },
+  )('matches the default for arbitrary subviews', (options) => {
+    const privateKey = offsetView(options.privateKey)
+    const publicKey = offsetView(x25519.getPublicKey(options.publicKeySeed))
+
+    expect(x25519Engine.getPublicKey(privateKey)).toEqual(
+      x25519.getPublicKey(privateKey),
+    )
+    expect(x25519Engine.getSharedSecret(privateKey, publicKey)).toEqual(
+      x25519.getSharedSecret(privateKey, publicKey),
+    )
+  })
+
+  test.prop(
+    {
+      highBit: fc.boolean(),
+      privateKey: arbitraryKey,
+      vector: fc.constantFrom(...x25519LowOrder),
+    },
+    { numRuns },
+  )(
+    'rejects arbitrary private keys paired with low-order points',
+    (options) => {
+      const publicKey = fromHex(options.vector.publicKey)
+      if (options.highBit) publicKey[31]! |= 0x80
+      expect(() =>
+        x25519Engine.getSharedSecret(options.privateKey, publicKey),
+      ).toThrow()
+    },
+  )
+})
+
+describe('Mnemonic', () => {
+  test.prop(
+    {
+      mnemonic: arbitraryMnemonic,
+      passphrase: fc.string({ maxLength: 64 }),
+    },
+    { numRuns },
+  )('matches the default for arbitrary normalized text', (options) => {
+    expect(mnemonicEngine.toSeed(options.mnemonic, options.passphrase)).toEqual(
+      mnemonicToSeedSync(options.mnemonic, options.passphrase),
+    )
+  })
+})
+
+describe('memory', () => {
+  test.prop(
+    {
+      operations: fc.array(
+        fc.record({
+          payload: arbitraryPayload,
+          privateKey: arbitraryKey,
+          publicKeySeed: arbitraryKey,
+        }),
+        { maxLength: 8, minLength: 2 },
+      ),
+    },
+    { numRuns },
+  )(
+    'interleaved providers remain isolated and outputs stay owned',
+    (options) => {
+      const held: Uint8Array[] = []
+      const snapshots: Uint8Array[] = []
+
+      for (const operation of options.operations) {
+        const edPublicKey = ed25519Engine.getPublicKey(operation.privateKey)
+        const signature = ed25519Engine.sign(
+          operation.payload,
+          operation.privateKey,
+        )
+        const xPublicKey = x25519.getPublicKey(operation.publicKeySeed)
+        const sharedSecret = x25519Engine.getSharedSecret(
+          operation.privateKey,
+          xPublicKey,
+        )
+        expect(
+          ed25519Engine.verify(signature, operation.payload, edPublicKey),
+        ).toBe(true)
+        expect(sharedSecret).toEqual(
+          x25519.getSharedSecret(operation.privateKey, xPublicKey),
+        )
+        held.push(signature, sharedSecret)
+        snapshots.push(signature.slice(), sharedSecret.slice())
+      }
+
+      expect(held).toEqual(snapshots)
+    },
+  )
+})
+
+function offsetView(value: Uint8Array): Uint8Array {
+  const bytes = new Uint8Array(value.length + 4).fill(0xff)
+  bytes.set(value, 2)
+  return bytes.subarray(2, -2)
+}
+
+function fromHex(value: string): Uint8Array {
+  const bytes = new Uint8Array(value.length / 2)
+  for (let index = 0; index < bytes.length; index++)
+    bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16)
+  return bytes
+}

package/src/wasm/_test/Ed25519.test-d.ts

@@ -0,0 +1,28 @@
+import { expectTypeOf, test } from 'vp/test'
+import type * as Engine from '../../core/Engine.js'
+import * as core_Ed25519 from '../../core/Ed25519.js'
+import * as Ed25519 from '../Ed25519.js'
+
+type Slot = Awaited<ReturnType<typeof Ed25519.engine>>
+
+test('return type exposes only implemented Ed25519 primitives', () => {
+  expectTypeOf<Slot['getPublicKey']>().toEqualTypeOf<
+    NonNullable<Engine.Eddsa['getPublicKey']>
+  >()
+  expectTypeOf<Slot['sign']>().toEqualTypeOf<
+    NonNullable<Engine.Eddsa['sign']>
+  >()
+  expectTypeOf<Slot['toMontgomerySecret']>().toEqualTypeOf<
+    NonNullable<Engine.Eddsa['toMontgomerySecret']>
+  >()
+  expectTypeOf<Slot['verify']>().toEqualTypeOf<
+    NonNullable<Engine.Eddsa['verify']>
+  >()
+  expectTypeOf<Slot>().not.toHaveProperty('randomSecretKey')
+  expectTypeOf<Slot>().not.toHaveProperty('toMontgomery')
+})
+
+test('the WASM namespace exposes the public Ed25519 API', () => {
+  expectTypeOf(Ed25519.getPublicKey).toEqualTypeOf(core_Ed25519.getPublicKey)
+  expectTypeOf<typeof Ed25519>().not.toHaveProperty('create')
+})

package/src/wasm/_test/Ed25519.test.ts

@@ -0,0 +1,168 @@
+import { ed25519 } from '@noble/curves/ed25519.js'
+import { describe, expect, test } from 'vp/test'
+import * as Ed25519 from '../Ed25519.js'
+import * as crypto25519 from '../internal/crypto25519.js'
+import { wasmBase64 } from '../internal/crypto25519.wasm.js'
+import * as ed25519_internal from '../internal/ed25519.js'
+import * as internal from '../internal/instantiate.js'
+
+const privateKey = fromHex(
+  '9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60',
+)
+
+describe('engine', () => {
+  test('behavior: exposes only semantics-compatible primitives', async () => {
+    const engine = await Ed25519.engine()
+
+    expect(Object.keys(engine).sort()).toMatchInlineSnapshot(`
+      [
+        "getPublicKey",
+        "sign",
+        "toMontgomerySecret",
+        "verify",
+      ]
+    `)
+  })
+
+  test('behavior: signs and verifies boundary-sized messages', async () => {
+    const engine = await Ed25519.engine()
+
+    for (const size of [0, 1, 31, 32, 63, 64, 65, 127, 128, 129, 1024]) {
+      const payload = Uint8Array.from(
+        { length: size },
+        (_, index) => (index * 29 + size) % 251,
+      )
+      const signature = engine.sign(payload, privateKey)
+      const publicKey = engine.getPublicKey(privateKey)
+
+      expect(signature).toEqual(ed25519.sign(payload, privateKey))
+      expect(engine.verify(signature, payload, publicKey)).toBe(true)
+      expect(
+        engine.verify(signature, Uint8Array.of(...payload, 1), publicKey),
+      ).toBe(false)
+    }
+  })
+
+  test('behavior: matches private-key conversion', async () => {
+    const engine = await Ed25519.engine()
+
+    expect(engine.toMontgomerySecret(privateKey)).toEqual(
+      ed25519.utils.toMontgomerySecret(privateKey),
+    )
+  })
+
+  test('behavior: respects subviews and leaves inputs immutable', async () => {
+    const engine = await Ed25519.engine()
+    const key = offsetView(privateKey)
+    const payload = offsetView(new Uint8Array(257).fill(0xa5))
+    const keyBefore = key.slice()
+    const payloadBefore = payload.slice()
+    const publicKey = offsetView(engine.getPublicKey(key))
+    const signature = offsetView(engine.sign(payload, key))
+    const publicKeyBefore = publicKey.slice()
+    const signatureBefore = signature.slice()
+
+    expect(engine.getPublicKey(key)).toEqual(ed25519.getPublicKey(key))
+    expect(engine.verify(signature, payload, publicKey)).toBe(true)
+    expect(engine.toMontgomerySecret(key)).toEqual(
+      ed25519.utils.toMontgomerySecret(key),
+    )
+    expect({ key, payload, publicKey, signature }).toEqual({
+      key: keyBefore,
+      payload: payloadBefore,
+      publicKey: publicKeyBefore,
+      signature: signatureBefore,
+    })
+  })
+
+  test('behavior: rejects malformed key and signature lengths', async () => {
+    const engine = await Ed25519.engine()
+    const publicKey = engine.getPublicKey(privateKey)
+
+    for (const size of [0, 1, 31, 33, 63, 64]) {
+      if (size !== 32) {
+        expect(() => engine.getPublicKey(new Uint8Array(size))).toThrowError(
+          `Ed25519 private key must be 32 bytes, got ${size}`,
+        )
+        expect(() =>
+          engine.sign(new Uint8Array(), new Uint8Array(size)),
+        ).toThrowError(`Ed25519 private key must be 32 bytes, got ${size}`)
+      }
+      if (size !== 64)
+        expect(() =>
+          engine.verify(new Uint8Array(size), new Uint8Array(), publicKey),
+        ).toThrowError(`Ed25519 signature must be 64 bytes, got ${size}`)
+    }
+
+    expect(() =>
+      engine.verify(new Uint8Array(64), new Uint8Array(), new Uint8Array(31)),
+    ).toThrowError('Ed25519 public key must be 32 bytes, got 31')
+  })
+
+  test('behavior: outputs are owned across calls and memory growth', async () => {
+    const engine = await Ed25519.engine()
+    const publicKey = engine.getPublicKey(privateKey)
+    const signature = engine.sign(new Uint8Array(), privateKey)
+    const snapshots = [publicKey.slice(), signature.slice()]
+
+    engine.sign(new Uint8Array(1024 * 1024).fill(0x5a), privateKey)
+
+    expect([publicKey, signature]).toEqual(snapshots)
+    expect(engine.getPublicKey(privateKey) === publicKey).toBe(false)
+  })
+
+  test('behavior: clears the shared staging region', async () => {
+    const engine = await Ed25519.engine()
+    const payload = new Uint8Array(1024).fill(0xa5)
+    engine.sign(payload, privateKey)
+
+    const module = await crypto25519.load()
+    const size = 32 + payload.length + 64
+    expect(
+      module
+        .view()
+        .subarray(module.heapBase, module.heapBase + size)
+        .every((byte) => byte === 0),
+    ).toBe(true)
+  })
+
+  test('behavior: clears the complete region after a late trap', async () => {
+    const module = await internal.instantiate<crypto25519.Exports>(wasmBase64)
+    const payload = new Uint8Array(1024).fill(0xa5)
+    const exports: crypto25519.Exports = {
+      ...module.exports,
+      ed25519_sign(...parameters) {
+        module.exports.ed25519_sign(...parameters)
+        throw new WebAssembly.RuntimeError('forced late trap')
+      },
+    }
+
+    expect(() =>
+      ed25519_internal.sign({ ...module, exports }, payload, privateKey),
+    ).toThrow(WebAssembly.RuntimeError)
+    expect(
+      module
+        .view()
+        .subarray(module.heapBase, module.heapBase + 32 + payload.length + 64)
+        .every((byte) => byte === 0),
+    ).toBe(true)
+  })
+
+  test('behavior: rejects a workspace beyond wasm32 without growing', async () => {
+    const module = await internal.instantiate<crypto25519.Exports>(wasmBase64)
+    const memory = module.view().length
+
+    expect(() => module.reserve(0x1_0000_0000)).toThrow(internal.MemoryError)
+    expect(module.view()).toHaveLength(memory)
+  })
+})
+
+function fromHex(value: string): Uint8Array {
+  return Uint8Array.from(Buffer.from(value, 'hex'))
+}
+
+function offsetView(value: Uint8Array): Uint8Array {
+  const bytes = new Uint8Array(value.length + 4).fill(0xff)
+  bytes.set(value, 2)
+  return bytes.subarray(2, -2)
+}

package/src/wasm/_test/Ed25519.vectors.test.ts

@@ -0,0 +1,73 @@
+import * as fs from 'node:fs'
+import { describe, expect, test } from 'vp/test'
+import * as Ed25519 from '../Ed25519.js'
+
+type Zip215Vector = {
+  sig_bytes: string
+  valid_legacy: boolean
+  valid_zip215: boolean
+  vk_bytes: string
+}
+
+const zip215 = JSON.parse(
+  fs.readFileSync(
+    new URL('../../../test/vectors/ed25519/zip215.json', import.meta.url),
+    'utf8',
+  ),
+) as readonly Zip215Vector[]
+
+const rfc8032 = [
+  {
+    message: '',
+    publicKey:
+      'd75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a',
+    seed: '9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60',
+    signature:
+      'e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b',
+  },
+  {
+    message: '72',
+    publicKey:
+      '3d4017c3e843895a92b70aa74d1b7ebc9c982ccf2ec4968cc0cd55f12af4660c',
+    seed: '4ccd089b28ff96da9db6c346ec114e0f5b8a319f35aba624da8cf6ed4fb8a6fb',
+    signature:
+      '92a009a9f0d4cab8720e820b5f642540a2b27b5416503f8fb3762223ebdb69da085ac1e43e15996e458f3613d0f11d8c387b2eaeb4302aeeb00d291612bb0c00',
+  },
+] as const
+
+describe('engine', () => {
+  test('vectors: matches RFC 8032 key, signature, and verification cases', async () => {
+    const engine = await Ed25519.engine()
+
+    for (const vector of rfc8032) {
+      const seed = fromHex(vector.seed)
+      const message = fromHex(vector.message)
+      const publicKey = fromHex(vector.publicKey)
+      const signature = fromHex(vector.signature)
+
+      expect(engine.getPublicKey(seed)).toEqual(publicKey)
+      expect(engine.sign(message, seed)).toEqual(signature)
+      expect(engine.verify(signature, message, publicKey)).toBe(true)
+    }
+  })
+
+  test('vectors: matches all 196 ZIP-215 compliance cases', async () => {
+    const engine = await Ed25519.engine()
+    const message = new TextEncoder().encode('Zcash')
+
+    expect(zip215).toHaveLength(196)
+    for (const vector of zip215)
+      expect(
+        engine.verify(
+          fromHex(vector.sig_bytes),
+          message,
+          fromHex(vector.vk_bytes),
+        ),
+        JSON.stringify(vector),
+      ).toBe(vector.valid_zip215)
+  })
+})
+
+function fromHex(value: string): Uint8Array {
+  return Uint8Array.from(Buffer.from(value, 'hex'))
+}

package/src/wasm/_test/Engine.test-d.ts

@@ -0,0 +1,28 @@
+import { Engine } from 'ox/wasm'
+import { expectTypeOf, test } from 'vp/test'
+import * as CoreEngine from '../../core/Engine.js'
+
+type Installed = Awaited<ReturnType<typeof Engine.install>>
+type Uninstalled = Awaited<ReturnType<typeof Engine.engine>>
+
+test('install and engine expose the same precise engine', () => {
+  expectTypeOf<Installed>().toEqualTypeOf<Uninstalled>()
+  expectTypeOf<Installed['Hash']['sha256']>().toEqualTypeOf<
+    (input: Uint8Array) => Uint8Array
+  >()
+})
+
+test('the WASM Engine namespace exposes synchronous core operations', () => {
+  expectTypeOf(Engine.get).toEqualTypeOf(CoreEngine.get)
+  expectTypeOf(Engine.InvalidSlotValueError).toEqualTypeOf(
+    CoreEngine.InvalidSlotValueError,
+  )
+  expectTypeOf(Engine.reset).toEqualTypeOf(CoreEngine.reset)
+  expectTypeOf(Engine.set).toEqualTypeOf(CoreEngine.set)
+  expectTypeOf(Engine.with).toEqualTypeOf(CoreEngine.with)
+})
+
+test('the replaced aliases are absent', () => {
+  expectTypeOf<typeof Engine>().not.toHaveProperty('create')
+  expectTypeOf<typeof Engine>().not.toHaveProperty('load')
+})