@7h3/protocol 0.5.0 → 0.5.2

package/scripts/mcpGatewayCli.test.ts

@@ -1,116 +0,0 @@
-import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
-import { describe, expect, it } from 'vitest'
-
-interface JsonRpcEnvelope {
-  jsonrpc: '2.0'
-  id: string | number | null
-  result?: unknown
-  error?: {
-    code: number
-    message: string
-  }
-}
-
-function waitForLine(child: ChildProcessWithoutNullStreams, timeoutMs = 8_000): Promise<string> {
-  return new Promise((resolve, reject) => {
-    let buffer = ''
-    const timer = setTimeout(() => {
-      cleanup()
-      reject(new Error('Timed out waiting for gateway output'))
-    }, timeoutMs)
-
-    const onData = (chunk: Buffer) => {
-      buffer += chunk.toString('utf8')
-      const newlineIndex = buffer.indexOf('\n')
-      if (newlineIndex >= 0) {
-        const line = buffer.slice(0, newlineIndex).trim()
-        cleanup()
-        resolve(line)
-      }
-    }
-
-    const onError = (error: Error) => {
-      cleanup()
-      reject(error)
-    }
-
-    const onExit = () => {
-      cleanup()
-      reject(new Error('Gateway process exited before producing output'))
-    }
-
-    const cleanup = () => {
-      clearTimeout(timer)
-      child.stdout.off('data', onData)
-      child.off('error', onError)
-      child.off('exit', onExit)
-    }
-
-    child.stdout.on('data', onData)
-    child.on('error', onError)
-    child.on('exit', onExit)
-  })
-}
-
-function startGateway(extraEnv: Record<string, string> = {}): ChildProcessWithoutNullStreams {
-  const child = spawn('npm', ['run', '-s', 'aip:mcp:gateway'], {
-    cwd: process.cwd(),
-    env: {
-      ...process.env,
-      ...extraEnv,
-    },
-    stdio: ['pipe', 'pipe', 'pipe'],
-  })
-
-  child.stderr.on('data', () => {
-    // suppress stderr accumulation in test output
-  })
-
-  return child
-}
-
-async function stopGateway(child: ChildProcessWithoutNullStreams): Promise<void> {
-  if (child.killed) return
-  child.kill('SIGTERM')
-  await new Promise<void>((resolve) => {
-    child.once('exit', () => resolve())
-    setTimeout(() => resolve(), 2_000)
-  })
-}
-
-describe('AIP MCP gateway CLI', () => {
-  it('returns JSON-RPC result for allowed method', async () => {
-    const child = startGateway()
-    try {
-      child.stdin.write(
-        `${JSON.stringify({ jsonrpc: '2.0', id: 99, method: 'tools/call', params: { name: 'planner' } })}\n`,
-      )
-      const line = await waitForLine(child)
-      const response = JSON.parse(line) as JsonRpcEnvelope
-
-      expect(response.jsonrpc).toBe('2.0')
-      expect(response.id).toBe(99)
-      expect(response.error).toBeUndefined()
-      expect(response.result).toBeTruthy()
-    } finally {
-      await stopGateway(child)
-    }
-  })
-
-  it('returns method-not-found for disallowed method from env policy', async () => {
-    const child = startGateway({ AIP_ALLOWED_METHODS: 'tools/call' })
-    try {
-      child.stdin.write(
-        `${JSON.stringify({ jsonrpc: '2.0', id: 'abc', method: 'resources/read', params: { uri: 'file://x' } })}\n`,
-      )
-      const line = await waitForLine(child)
-      const response = JSON.parse(line) as JsonRpcEnvelope
-
-      expect(response.id).toBe('abc')
-      expect(response.result).toBeUndefined()
-      expect(response.error?.code).toBe(-32601)
-    } finally {
-      await stopGateway(child)
-    }
-  })
-})

package/scripts/prepare-aip-package.ts

@@ -1,88 +0,0 @@
-import { mkdir, readFile, writeFile, copyFile, readdir } from 'node:fs/promises'
-import process from 'node:process'
-
-interface RootPackageJson {
-  version?: string
-}
-
-function parseVersionArg(argv: string[]): string | undefined {
-  const idx = argv.indexOf('--version')
-  if (idx < 0) return undefined
-  return argv[idx + 1]
-}
-
-async function readRootVersion(): Promise<string> {
-  const raw = await readFile('package.json', 'utf8')
-  const parsed = JSON.parse(raw) as RootPackageJson
-  return parsed.version ?? '0.0.0'
-}
-
-async function main(): Promise<void> {
-  const version = parseVersionArg(process.argv) ?? (await readRootVersion())
-  const outDir = 'dist/npm-protocol'
-
-  await mkdir(outDir, { recursive: true })
-  await copyFile('dist/protocol/index.js', `${outDir}/index.js`)
-
-  // Copy all .d.ts files — index.d.ts re-exports from the individual module files,
-  // so all of them must be present for TypeScript consumers to resolve types.
-  const distFiles = await readdir('dist/protocol')
-  for (const file of distFiles) {
-    if (file.endsWith('.d.ts')) {
-      await copyFile(`dist/protocol/${file}`, `${outDir}/${file}`)
-    }
-  }
-
-  const packageJson = {
-    name: '@7h3/protocol',
-    version,
-    description: '7h3 Protocol: deterministic, signed, replay-safe AI-to-AI message envelopes (wire 7h3/0.1).',
-    type: 'module',
-    main: './index.js',
-    types: './index.d.ts',
-    exports: {
-      '.': {
-        import: './index.js',
-        types: './index.d.ts',
-      },
-    },
-    files: ['index.js', '*.d.ts', 'README.md'],
-    license: 'MIT',
-    repository: {
-      type: 'git',
-      url: 'https://github.com/IceMasterT/7h3-protocol-aip.git',
-    },
-  }
-
-  const readme = [
-    '# @7h3/protocol',
-    '',
-    '7h3 Protocol (wire version `7h3/0.1`):',
-    'deterministic, signed, replay-safe AI-to-AI message envelopes.',
-    '',
-    'Install:',
-    '',
-    '```bash',
-    'npm install @7h3/protocol',
-    '```',
-    '',
-    'Import:',
-    '',
-    '```ts',
-    "import { createAipAgentAdapter, receiveEnvelope } from '@7h3/protocol'",
-    '```',
-    '',
-  ].join('\n')
-
-  await writeFile(`${outDir}/package.json`, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8')
-  await writeFile(`${outDir}/README.md`, readme, 'utf8')
-
-  console.log(`Prepared publishable package in ${outDir}`)
-  console.log(`Version: ${version}`)
-}
-
-main().catch((error: unknown) => {
-  const message = error instanceof Error ? error.stack ?? error.message : String(error)
-  console.error(message)
-  process.exitCode = 1
-})

package/scripts/regen-conformance-sigs.ts

@@ -1,18 +0,0 @@
-import { signCanonicalPayloadHmac, signCanonicalPayloadEd25519 } from '../src/protocol'
-import { AIP_V01_CONFORMANCE_VECTORS, AIP_V01_ED25519_CONFORMANCE_VECTORS } from '../src/conformanceVectors'
-
-async function main() {
-  console.log('=== HMAC vectors ===')
-  for (const v of AIP_V01_CONFORMANCE_VECTORS) {
-    const sig = await signCanonicalPayloadHmac(v.canonical, v.secret)
-    console.log(`${v.id}: '${sig}'`)
-  }
-
-  console.log('\n=== Ed25519 vectors ===')
-  for (const v of AIP_V01_ED25519_CONFORMANCE_VECTORS) {
-    const sig = await signCanonicalPayloadEd25519(v.canonical, v.privateKey)
-    console.log(`${v.id}: '${sig}'`)
-  }
-}
-
-main().catch(e => { console.error(e); process.exit(1) })

package/scripts/release-gate.ts

@@ -1,19 +0,0 @@
-import { spawnSync } from 'node:child_process'
-
-const commands: Array<[string, string[]]> = [
-  ['npm', ['run', 'policy:validate']],
-  ['npm', ['run', 'test']],
-  ['npm', ['run', 'build:protocol']],
-  ['npm', ['run', 'lint']],
-  ['npm', ['run', 'bench:wire:quick']],
-  ['npm', ['run', 'bench:openloop:adaptive:ci']],
-]
-
-for (const [command, args] of commands) {
-  console.log(`\n$ ${command} ${args.join(' ')}`)
-  const result = spawnSync(command, args, { stdio: 'inherit', shell: false })
-  if (result.status !== 0) {
-    process.exitCode = result.status ?? 1
-    break
-  }
-}

package/scripts/validate-runtime-policy.ts

@@ -1,18 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { parseRuntimePolicyJson } from '../src/runtimePolicy'
-
-async function main(): Promise<void> {
-  const path = process.argv[2] ?? 'AI_RUNTIME_POLICY.json'
-  const text = await readFile(path, 'utf8')
-  const policy = parseRuntimePolicyJson(text)
-  if (!policy.hard_invariants || !policy.slo_defaults || !policy.tuning) {
-    throw new Error('Runtime policy is missing one or more required sections: hard_invariants, slo_defaults, tuning')
-  }
-  console.log(`Runtime policy validated: ${policy.name}@${policy.version} (${policy.status})`)
-}
-
-main().catch((error: unknown) => {
-  const message = error instanceof Error ? error.stack ?? error.message : String(error)
-  console.error(message)
-  process.exitCode = 1
-})

package/sdk/browser/index.test.ts

@@ -1,162 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  generateKeypair,
-  canonicalizeEnvelope,
-  createEnvelope,
-  signEnvelope,
-  verifyEnvelope,
-  signRequest,
-  isEnvelopeExpired,
-  ENVELOPE_HEADER,
-  WIRE_VERSION,
-  type BrowserEnvelopeHeader,
-  type BrowserEnvelopeBody,
-} from './index.ts'
-
-describe('Browser SDK', () => {
-  // Test 1: generateKeypair produces non-empty strings
-  it('generateKeypair produces non-empty strings', async () => {
-    const kp = await generateKeypair()
-    expect(typeof kp.publicKey).toBe('string')
-    expect(kp.publicKey.length).toBeGreaterThan(0)
-    expect(typeof kp.privateKey).toBe('string')
-    expect(kp.privateKey.length).toBeGreaterThan(0)
-  })
-
-  // Test 2: canonicalizeEnvelope matches exact conformance vector
-  it('canonicalizeEnvelope matches conformance vector', () => {
-    const header: BrowserEnvelopeHeader = {
-      version: '7h3/0.1',
-      messageId: 'vec-1',
-      nonce: 'nonce-vec-1',
-      sender: 'agent.alpha',
-      recipient: 'agent.beta',
-      timestampMs: 1712500000000,
-      ttlMs: 60000,
-    }
-    const body: BrowserEnvelopeBody = {
-      intent: 'TASK',
-      content: 'route:alpha->beta',
-      capability: 'task.plan',
-      correlationId: 'corr-1',
-    }
-    const expected =
-      '{"body":{"capability":"task.plan","content":"route:alpha->beta","correlationId":"corr-1","intent":"TASK"},"header":{"messageId":"vec-1","nonce":"nonce-vec-1","recipient":"agent.beta","sender":"agent.alpha","timestampMs":1712500000000,"ttlMs":60000,"version":"7h3/0.1"}}'
-    expect(canonicalizeEnvelope({ header, body })).toBe(expected)
-  })
-
-  // Test 3: canonicalizeEnvelope with no optional fields
-  it('canonicalizeEnvelope omits undefined optional fields', () => {
-    const header: BrowserEnvelopeHeader = {
-      version: '7h3/0.1',
-      messageId: 'msg-1',
-      nonce: 'n1',
-      sender: 'agent.x',
-      timestampMs: 1712500000000,
-      ttlMs: 30000,
-    }
-    const body: BrowserEnvelopeBody = {
-      intent: 'PING',
-      content: 'hello',
-    }
-    const result = canonicalizeEnvelope({ header, body })
-    const parsed = JSON.parse(result)
-    expect(parsed.header.recipient).toBeUndefined()
-    expect(parsed.body.capability).toBeUndefined()
-    expect(parsed.body.correlationId).toBeUndefined()
-    // Verify the raw string doesn't include those keys
-    expect(result).not.toContain('"recipient"')
-    expect(result).not.toContain('"capability"')
-    expect(result).not.toContain('"correlationId"')
-  })
-
-  // Test 4: createEnvelope produces correct structure
-  it('createEnvelope produces correct structure', () => {
-    const env = createEnvelope({
-      sender: 'agent.test',
-      body: { intent: 'TASK', content: 'do work' },
-    })
-    expect(env.header.version).toBe(WIRE_VERSION)
-    expect(typeof env.header.messageId).toBe('string')
-    expect(env.header.messageId.length).toBeGreaterThan(0)
-    expect(env.body.intent).toBe('TASK')
-    expect(env.header.sender).toBe('agent.test')
-    expect(env.header.ttlMs).toBe(60_000)
-  })
-
-  // Test 5: signEnvelope + verifyEnvelope round trip
-  it('signEnvelope + verifyEnvelope round trip', async () => {
-    const kp = await generateKeypair()
-    const env = createEnvelope({
-      sender: 'agent.a',
-      body: { intent: 'PING', content: 'test' },
-    })
-    const signed = await signEnvelope(env, kp.privateKey)
-    expect(signed.signature).toBeDefined()
-    expect(signed.signature?.alg).toBe('ED25519')
-    const valid = await verifyEnvelope(signed, kp.publicKey)
-    expect(valid).toBe(true)
-  })
-
-  // Test 6: verifyEnvelope: tampered body returns false
-  it('verifyEnvelope: tampered body returns false', async () => {
-    const kp = await generateKeypair()
-    const env = createEnvelope({
-      sender: 'agent.a',
-      body: { intent: 'PING', content: 'original' },
-    })
-    const signed = await signEnvelope(env, kp.privateKey)
-    const tampered = {
-      ...signed,
-      body: { ...signed.body, content: 'tampered' },
-    }
-    const valid = await verifyEnvelope(tampered, kp.publicKey)
-    expect(valid).toBe(false)
-  })
-
-  // Test 7: verifyEnvelope: wrong key returns false
-  it('verifyEnvelope: wrong key returns false', async () => {
-    const kp1 = await generateKeypair()
-    const kp2 = await generateKeypair()
-    const env = createEnvelope({
-      sender: 'agent.a',
-      body: { intent: 'PING', content: 'test' },
-    })
-    const signed = await signEnvelope(env, kp1.privateKey)
-    const valid = await verifyEnvelope(signed, kp2.publicKey)
-    expect(valid).toBe(false)
-  })
-
-  // Test 8: signRequest: produces Request with x-7h3-envelope header set
-  it('signRequest: produces Request with x-7h3-envelope header', async () => {
-    const kp = await generateKeypair()
-    const req = new Request('https://example.com/api')
-    const signed = await signRequest(req, {
-      sender: 'agent.client',
-      privateKey: kp.privateKey,
-    })
-    const headerVal = signed.headers.get(ENVELOPE_HEADER)
-    expect(headerVal).not.toBeNull()
-    expect(typeof headerVal).toBe('string')
-    const parsed = JSON.parse(headerVal!)
-    expect(parsed.signature).toBeDefined()
-    expect(parsed.header.sender).toBe('agent.client')
-  })
-
-  // Test 9: isEnvelopeExpired: returns true for past timestamp
-  it('isEnvelopeExpired: returns true for past timestamp', () => {
-    const past = Date.now() - 120_000
-    const env = {
-      header: {
-        version: '7h3/0.1' as const,
-        messageId: 'x',
-        nonce: 'y',
-        sender: 'agent.z',
-        timestampMs: past,
-        ttlMs: 60_000,
-      },
-      body: { intent: 'PING' as const, content: 'old' },
-    }
-    expect(isEnvelopeExpired(env)).toBe(true)
-  })
-})

package/sdk/browser/index.ts

@@ -1,257 +0,0 @@
-// 7h3 Protocol - Browser/Edge SDK
-// Pure Web Crypto API. Zero dependencies.
-// Works in browsers, Deno, Cloudflare Workers, Bun, and Node 20+.
-
-export const WIRE_VERSION = '7h3/0.1'
-export const ENVELOPE_HEADER = 'x-7h3-envelope'
-export const RESPONSE_HEADER = 'x-7h3-response'
-
-export type IntentKind = 'PING' | 'PONG' | 'CAPS' | 'TASK' | 'RESULT' | 'ERROR'
-
-export interface BrowserEnvelopeHeader {
-  version: typeof WIRE_VERSION
-  messageId: string
-  timestampMs: number
-  ttlMs: number
-  sender: string
-  recipient?: string
-  nonce: string
-}
-
-export interface BrowserEnvelopeBody {
-  intent: IntentKind
-  content: string
-  capability?: string
-  correlationId?: string
-}
-
-export interface BrowserSignature {
-  alg: 'ED25519'
-  keyId: string
-  value: string
-}
-
-export interface BrowserEnvelope {
-  header: BrowserEnvelopeHeader
-  body: BrowserEnvelopeBody
-  signature?: BrowserSignature
-}
-
-export interface BrowserKeyPair {
-  publicKey: string  // base64url SPKI, no padding
-  privateKey: string // base64url PKCS8, no padding
-}
-
-// ─── Internal helpers (NOT exported) ─────────────────────────────────────────
-
-function toBase64Url(buf: ArrayBuffer | Uint8Array): string {
-  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf)
-  let binary = ''
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i])
-  }
-  return btoa(binary)
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=+$/g, '')
-}
-
-function fromBase64Url(str: string): Uint8Array {
-  const padded = str
-    .replace(/-/g, '+')
-    .replace(/_/g, '/')
-    .padEnd(Math.ceil(str.length / 4) * 4, '=')
-  const binary = atob(padded)
-  const bytes = new Uint8Array(binary.length)
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i)
-  }
-  return bytes
-}
-
-function generateNonce(): string {
-  const bytes = new Uint8Array(16)
-  crypto.getRandomValues(bytes)
-  return toBase64Url(bytes)
-}
-
-function canonicalBody(b: BrowserEnvelopeBody): string {
-  const parts: string[] = []
-  if (b.capability !== undefined) {
-    parts.push(`"capability":${JSON.stringify(b.capability)}`)
-  }
-  parts.push(`"content":${JSON.stringify(b.content)}`)
-  if (b.correlationId !== undefined) {
-    parts.push(`"correlationId":${JSON.stringify(b.correlationId)}`)
-  }
-  parts.push(`"intent":${JSON.stringify(b.intent)}`)
-  return `{${parts.join(',')}}`
-}
-
-function canonicalHeader(h: BrowserEnvelopeHeader): string {
-  const parts: string[] = [
-    `"messageId":${JSON.stringify(h.messageId)}`,
-    `"nonce":${JSON.stringify(h.nonce)}`,
-  ]
-  if (h.recipient !== undefined) {
-    parts.push(`"recipient":${JSON.stringify(h.recipient)}`)
-  }
-  parts.push(`"sender":${JSON.stringify(h.sender)}`)
-  parts.push(`"timestampMs":${h.timestampMs}`)
-  parts.push(`"ttlMs":${h.ttlMs}`)
-  parts.push(`"version":${JSON.stringify(h.version)}`)
-  return `{${parts.join(',')}}`
-}
-
-// ─── Public API ───────────────────────────────────────────────────────────────
-
-export function canonicalizeEnvelope(envelope: Omit<BrowserEnvelope, 'signature'>): string {
-  return `{"body":${canonicalBody(envelope.body)},"header":${canonicalHeader(envelope.header)}}`
-}
-
-export async function generateKeypair(): Promise<BrowserKeyPair> {
-  const pair = await crypto.subtle.generateKey(
-    { name: 'Ed25519' } as AlgorithmIdentifier,
-    true,
-    ['sign', 'verify'],
-  ) as CryptoKeyPair
-
-  const privateKeyRaw = await crypto.subtle.exportKey('pkcs8', pair.privateKey)
-  const publicKeyRaw = await crypto.subtle.exportKey('spki', pair.publicKey)
-
-  return {
-    publicKey: toBase64Url(publicKeyRaw),
-    privateKey: toBase64Url(privateKeyRaw),
-  }
-}
-
-export async function signEnvelope(
-  envelope: Omit<BrowserEnvelope, 'signature'>,
-  privateKeyPkcs8Base64Url: string,
-  keyId?: string,
-): Promise<BrowserEnvelope> {
-  const der = fromBase64Url(privateKeyPkcs8Base64Url)
-  const cryptoKey = await crypto.subtle.importKey(
-    'pkcs8',
-    der.buffer.slice(der.byteOffset, der.byteOffset + der.byteLength) as ArrayBuffer,
-    { name: 'Ed25519' } as AlgorithmIdentifier,
-    false,
-    ['sign'],
-  )
-
-  const payload = canonicalizeEnvelope(envelope)
-  const sigBuffer = await crypto.subtle.sign(
-    'Ed25519',
-    cryptoKey,
-    new TextEncoder().encode(payload),
-  )
-
-  return {
-    ...envelope,
-    signature: {
-      alg: 'ED25519',
-      keyId: keyId ?? generateNonce().slice(0, 16),
-      value: toBase64Url(sigBuffer),
-    },
-  }
-}
-
-export async function verifyEnvelope(
-  envelope: BrowserEnvelope,
-  publicKeySpkiBase64Url: string,
-): Promise<boolean> {
-  if (!envelope.signature) return false
-  if (envelope.signature.alg !== 'ED25519') return false
-
-  const der = fromBase64Url(publicKeySpkiBase64Url)
-  const cryptoKey = await crypto.subtle.importKey(
-    'spki',
-    der.buffer.slice(der.byteOffset, der.byteOffset + der.byteLength) as ArrayBuffer,
-    { name: 'Ed25519' } as AlgorithmIdentifier,
-    false,
-    ['verify'],
-  )
-
-  const unsigned: Omit<BrowserEnvelope, 'signature'> = {
-    header: envelope.header,
-    body: envelope.body,
-  }
-  const payload = canonicalizeEnvelope(unsigned)
-  const sigBytes = fromBase64Url(envelope.signature.value)
-
-  return crypto.subtle.verify(
-    'Ed25519',
-    cryptoKey,
-    sigBytes.buffer.slice(sigBytes.byteOffset, sigBytes.byteOffset + sigBytes.byteLength) as ArrayBuffer,
-    new TextEncoder().encode(payload),
-  )
-}
-
-export function createEnvelope(opts: {
-  sender: string
-  recipient?: string
-  ttlMs?: number
-  body: BrowserEnvelopeBody
-}): Omit<BrowserEnvelope, 'signature'> {
-  return {
-    header: {
-      version: WIRE_VERSION,
-      messageId: generateNonce(),
-      timestampMs: Date.now(),
-      ttlMs: opts.ttlMs ?? 60_000,
-      sender: opts.sender,
-      recipient: opts.recipient,
-      nonce: generateNonce(),
-    },
-    body: opts.body,
-  }
-}
-
-export async function signRequest(
-  request: Request,
-  opts: {
-    sender: string
-    recipient?: string
-    ttlMs?: number
-    privateKey: string
-    keyId?: string
-  },
-): Promise<Request> {
-  const envelope = createEnvelope({
-    sender: opts.sender,
-    recipient: opts.recipient,
-    ttlMs: opts.ttlMs,
-    body: {
-      intent: 'TASK',
-      content: request.url,
-    },
-  })
-
-  const signed = await signEnvelope(envelope, opts.privateKey, opts.keyId)
-
-  const headers = new Headers(request.headers)
-  headers.set(ENVELOPE_HEADER, JSON.stringify(signed))
-
-  return new Request(request, { headers })
-}
-
-export async function verifyResponseHeader(
-  response: Response,
-  publicKey: string,
-): Promise<boolean> {
-  const headerValue = response.headers.get(RESPONSE_HEADER)
-  if (!headerValue) return false
-
-  let parsed: BrowserEnvelope
-  try {
-    parsed = JSON.parse(headerValue) as BrowserEnvelope
-  } catch {
-    return false
-  }
-
-  return verifyEnvelope(parsed, publicKey)
-}
-
-export function isEnvelopeExpired(envelope: BrowserEnvelope): boolean {
-  return envelope.header.timestampMs + envelope.header.ttlMs < Date.now()
-}

package/sdk/browser/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "@7h3/protocol-browser",
-  "version": "0.5.0",
-  "description": "7h3 Protocol - Browser/Edge SDK. Pure Web Crypto API. Zero dependencies.",
-  "type": "module",
-  "main": "./index.js",
-  "module": "./index.js",
-  "types": "./index.d.ts",
-  "exports": { ".": { "types": "./index.d.ts", "import": "./index.js" } },
-  "keywords": ["7h3","protocol","browser","webcrypto","ed25519","signing","mcp"],
-  "license": "MIT",
-  "sideEffects": false
-}