@7h3/protocol 0.5.0 → 0.5.1

package/scripts/bench-replay-cache.ts

@@ -1,76 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises'
-import { performance } from 'node:perf_hooks'
-import process from 'node:process'
-import { createEnvelope, type ProtocolEnvelope } from '../src/protocol'
-import { InMemoryReplayCache } from '../src/protocolReplay'
-
-type ProfileName = 'quick' | 'full'
-
-const PROFILES: Record<ProfileName, { iterations: number; batchSize: number }> = {
-  quick: { iterations: 50_000, batchSize: 32 },
-  full: { iterations: 500_000, batchSize: 128 },
-}
-
-function parseProfile(argv: string[]): ProfileName {
-  const idx = argv.indexOf('--profile')
-  const value = idx >= 0 ? argv[idx + 1] : undefined
-  return value === 'full' ? 'full' : 'quick'
-}
-
-function buildEnvelope(sequence: number): ProtocolEnvelope {
-  return createEnvelope({
-    sender: 'bench.replay',
-    intent: 'PING',
-    content: 'replay-bench',
-    messageId: `replay-${sequence}`,
-    nonce: `nonce-${sequence}`,
-    nowMs: 1_700_000_000_000,
-    ttlMs: 60_000,
-  })
-}
-
-function round3(value: number): number {
-  return Number(value.toFixed(3))
-}
-
-async function run(): Promise<void> {
-  const profileName = parseProfile(process.argv)
-  const profile = PROFILES[profileName]
-  const cache = new InMemoryReplayCache(profile.iterations * 2)
-  const envelopes = Array.from({ length: profile.iterations }, (_, index) => buildEnvelope(index))
-
-  const singleStart = performance.now()
-  for (const envelope of envelopes) {
-    const result = cache.consume(envelope, 1_700_000_000_001)
-    if (!result.ok) throw new Error('single replay benchmark unexpectedly rejected envelope')
-  }
-  const singleMs = performance.now() - singleStart
-
-  const batchCache = new InMemoryReplayCache(profile.iterations * 2)
-  const batchStart = performance.now()
-  for (let offset = 0; offset < envelopes.length; offset += profile.batchSize) {
-    const results = batchCache.consumeMany(envelopes.slice(offset, offset + profile.batchSize), 1_700_000_000_001)
-    if (results.some((result) => !result.ok)) throw new Error('batch replay benchmark unexpectedly rejected envelope')
-  }
-  const batchMs = performance.now() - batchStart
-
-  const output = {
-    generatedAt: new Date().toISOString(),
-    profile: profileName,
-    iterations: profile.iterations,
-    batchSize: profile.batchSize,
-    singleOpsPerSecond: round3((profile.iterations * 1000) / singleMs),
-    batchOpsPerSecond: round3((profile.iterations * 1000) / batchMs),
-    singleUsPerOp: round3((singleMs * 1000) / profile.iterations),
-    batchUsPerOp: round3((batchMs * 1000) / profile.iterations),
-  }
-
-  console.log(JSON.stringify(output, null, 2))
-  await mkdir('bench-results', { recursive: true })
-  await writeFile(`bench-results/replay-cache-${profileName}-${Date.now()}.json`, `${JSON.stringify(output, null, 2)}\n`, 'utf8')
-}
-
-run().catch((error: unknown) => {
-  console.error(error instanceof Error ? error.stack ?? error.message : String(error))
-  process.exitCode = 1
-})

package/scripts/bench-signature-profiles.ts

@@ -1,180 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises'
-import { performance } from 'node:perf_hooks'
-import process from 'node:process'
-import {
-  canonicalizeEnvelope,
-  createEnvelope,
-  generateEd25519KeypairBase64Url,
-  signCanonicalPayloadEd25519,
-  signCanonicalPayloadHmac,
-  verifyCanonicalPayloadEd25519,
-  verifyCanonicalPayloadHmac,
-} from '../src/protocol'
-
-type ProfileName = 'quick' | 'full'
-type SignatureAlg = 'HS256' | 'ED25519'
-
-interface Profile {
-  iterations: number
-}
-
-interface ScenarioResult {
-  profile: ProfileName
-  payloadBytes: number
-  algorithm: SignatureAlg
-  signUsPerOp: number
-  verifyUsPerOp: number
-  signOpsPerSecond: number
-  verifyOpsPerSecond: number
-}
-
-const PROFILES: Record<ProfileName, Profile> = {
-  quick: { iterations: 2_000 },
-  full: { iterations: 20_000 },
-}
-
-const PAYLOAD_SIZES = [256, 1024, 4096, 16384]
-
-function parseProfile(argv: string[]): ProfileName {
-  const idx = argv.indexOf('--profile')
-  if (idx >= 0) {
-    const value = argv[idx + 1]
-    if (value === 'quick' || value === 'full') return value
-  }
-  return 'quick'
-}
-
-function payloadOfSize(bytes: number): string {
-  if (bytes <= 0) return ''
-  return 'x'.repeat(bytes)
-}
-
-function round3(value: number): number {
-  return Number(value.toFixed(3))
-}
-
-async function measureSignVerify(
-  algorithm: SignatureAlg,
-  canonical: string,
-  iterations: number,
-  material: { secret: string } | { privateKey: string; publicKey: string },
-): Promise<Pick<ScenarioResult, 'signUsPerOp' | 'verifyUsPerOp' | 'signOpsPerSecond' | 'verifyOpsPerSecond'>> {
-  const signStart = performance.now()
-  let lastSignature = ''
-  for (let i = 0; i < iterations; i += 1) {
-    if (algorithm === 'HS256') {
-      lastSignature = await signCanonicalPayloadHmac(canonical, material.secret)
-    } else {
-      lastSignature = await signCanonicalPayloadEd25519(canonical, material.privateKey)
-    }
-  }
-  const signMs = performance.now() - signStart
-
-  const verifyStart = performance.now()
-  let verifiedCount = 0
-  for (let i = 0; i < iterations; i += 1) {
-    const ok =
-      algorithm === 'HS256'
-        ? await verifyCanonicalPayloadHmac(canonical, lastSignature, material.secret)
-        : await verifyCanonicalPayloadEd25519(canonical, lastSignature, material.publicKey)
-    if (ok) verifiedCount += 1
-  }
-  const verifyMs = performance.now() - verifyStart
-  if (verifiedCount !== iterations) {
-    throw new Error(`Verification mismatch for ${algorithm}: ${verifiedCount}/${iterations}`)
-  }
-
-  return {
-    signUsPerOp: round3((signMs * 1000) / iterations),
-    verifyUsPerOp: round3((verifyMs * 1000) / iterations),
-    signOpsPerSecond: round3((iterations * 1000) / signMs),
-    verifyOpsPerSecond: round3((iterations * 1000) / verifyMs),
-  }
-}
-
-function printResults(results: ScenarioResult[]): void {
-  console.log('\nAIP signature profile benchmark results\n')
-  for (const result of results) {
-    console.log(
-      [
-        `profile=${result.profile}`,
-        `payload=${result.payloadBytes}B`,
-        `alg=${result.algorithm}`,
-        `sign_us_op=${result.signUsPerOp}`,
-        `verify_us_op=${result.verifyUsPerOp}`,
-        `sign_ops_s=${result.signOpsPerSecond}`,
-        `verify_ops_s=${result.verifyOpsPerSecond}`,
-      ].join(' | '),
-    )
-  }
-}
-
-async function run(): Promise<void> {
-  const profileName = parseProfile(process.argv)
-  const profile = PROFILES[profileName]
-  const sharedSecret = 'bench-signature-secret'
-  const ed25519Keys = await generateEd25519KeypairBase64Url()
-
-  const results: ScenarioResult[] = []
-
-  for (const payloadBytes of PAYLOAD_SIZES) {
-    const unsigned = createEnvelope({
-      sender: 'agent.bench',
-      recipient: 'agent.worker',
-      intent: 'TASK',
-      content: payloadOfSize(payloadBytes),
-      capability: 'task.bench',
-      correlationId: `bench-${payloadBytes}`,
-      messageId: `bench-${payloadBytes}`,
-      nonce: `n-${payloadBytes}`,
-      nowMs: 1_700_000_000_000,
-      ttlMs: 60_000,
-    })
-    const canonical = canonicalizeEnvelope(unsigned)
-
-    const hs = await measureSignVerify('HS256', canonical, profile.iterations, { secret: sharedSecret })
-    results.push({
-      profile: profileName,
-      payloadBytes,
-      algorithm: 'HS256',
-      ...hs,
-    })
-
-    const ed = await measureSignVerify('ED25519', canonical, profile.iterations, {
-      privateKey: ed25519Keys.privateKey,
-      publicKey: ed25519Keys.publicKey,
-    })
-    results.push({
-      profile: profileName,
-      payloadBytes,
-      algorithm: 'ED25519',
-      ...ed,
-    })
-  }
-
-  printResults(results)
-  await mkdir('bench-results', { recursive: true })
-  const outputPath = `bench-results/signature-profiles-${profileName}-${Date.now()}.json`
-  await writeFile(
-    outputPath,
-    `${JSON.stringify(
-      {
-        generatedAt: new Date().toISOString(),
-        profile: profileName,
-        iterations: profile.iterations,
-        payloadSizes: PAYLOAD_SIZES,
-        results,
-      },
-      null,
-      2,
-    )}\n`,
-    'utf8',
-  )
-  console.log(`\nSaved benchmark results to ${outputPath}`)
-}
-
-run().catch((error: unknown) => {
-  const message = error instanceof Error ? error.stack ?? error.message : String(error)
-  console.error(message)
-  process.exitCode = 1
-})

package/scripts/bench-wire-codecs.ts

@@ -1,161 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises'
-import { performance } from 'node:perf_hooks'
-import process from 'node:process'
-import { createEnvelope, signEnvelopeHmac } from '../src/protocol'
-import { decodeEnvelope, encodeEnvelope } from '../src/protocolTransport'
-import { decodeEnvelopeBinary, encodeEnvelopeBinary } from '../src/protocolBinary'
-
-type ProfileName = 'quick' | 'full'
-
-interface Profile {
-  iterations: number
-}
-
-interface CodecResult {
-  profile: ProfileName
-  payloadBytes: number
-  format: 'compact-json' | 'binary'
-  encodedBytes: number
-  encodeUsPerOp: number
-  decodeUsPerOp: number
-  encodeOpsPerSecond: number
-  decodeOpsPerSecond: number
-}
-
-const PROFILES: Record<ProfileName, Profile> = {
-  quick: { iterations: 10_000 },
-  full: { iterations: 100_000 },
-}
-
-const PAYLOAD_SIZES = [256, 1024, 4096, 16384]
-
-function parseProfile(argv: string[]): ProfileName {
-  const idx = argv.indexOf('--profile')
-  if (idx >= 0) {
-    const value = argv[idx + 1]
-    if (value === 'quick' || value === 'full') return value
-  }
-  return 'quick'
-}
-
-function payloadOfSize(bytes: number): string {
-  return 'x'.repeat(bytes)
-}
-
-function round3(value: number): number {
-  return Number(value.toFixed(3))
-}
-
-async function run(): Promise<void> {
-  const profileName = parseProfile(process.argv)
-  const profile = PROFILES[profileName]
-
-  const results: CodecResult[] = []
-
-  for (const payloadBytes of PAYLOAD_SIZES) {
-    const envelope = await signEnvelopeHmac(
-      createEnvelope({
-        sender: 'agent.bench',
-        recipient: 'agent.verify',
-        intent: 'TASK',
-        content: payloadOfSize(payloadBytes),
-        capability: 'task.bench',
-        correlationId: `corr-${payloadBytes}`,
-        messageId: `m-${payloadBytes}`,
-        nonce: `n-${payloadBytes}`,
-        nowMs: 1_700_000_000_000,
-        ttlMs: 60_000,
-      }),
-      'bench-secret',
-      'k1',
-    )
-
-    const compactEncoded = encodeEnvelope(envelope, 'compact')
-    const compactSize = Buffer.byteLength(compactEncoded, 'utf8')
-    const compactEncodeStart = performance.now()
-    for (let i = 0; i < profile.iterations; i += 1) {
-      encodeEnvelope(envelope, 'compact')
-    }
-    const compactEncodeMs = performance.now() - compactEncodeStart
-
-    const compactDecodeStart = performance.now()
-    for (let i = 0; i < profile.iterations; i += 1) {
-      const decoded = decodeEnvelope(compactEncoded)
-      if (!decoded.ok) throw new Error('Compact decode failed')
-    }
-    const compactDecodeMs = performance.now() - compactDecodeStart
-
-    results.push({
-      profile: profileName,
-      payloadBytes,
-      format: 'compact-json',
-      encodedBytes: compactSize,
-      encodeUsPerOp: round3((compactEncodeMs * 1000) / profile.iterations),
-      decodeUsPerOp: round3((compactDecodeMs * 1000) / profile.iterations),
-      encodeOpsPerSecond: round3((profile.iterations * 1000) / compactEncodeMs),
-      decodeOpsPerSecond: round3((profile.iterations * 1000) / compactDecodeMs),
-    })
-
-    const binaryEncoded = encodeEnvelopeBinary(envelope)
-    const binaryEncodeStart = performance.now()
-    for (let i = 0; i < profile.iterations; i += 1) {
-      encodeEnvelopeBinary(envelope)
-    }
-    const binaryEncodeMs = performance.now() - binaryEncodeStart
-
-    const binaryDecodeStart = performance.now()
-    for (let i = 0; i < profile.iterations; i += 1) {
-      const decoded = decodeEnvelopeBinary(binaryEncoded)
-      if (!decoded.ok) throw new Error('Binary decode failed')
-    }
-    const binaryDecodeMs = performance.now() - binaryDecodeStart
-
-    results.push({
-      profile: profileName,
-      payloadBytes,
-      format: 'binary',
-      encodedBytes: binaryEncoded.byteLength,
-      encodeUsPerOp: round3((binaryEncodeMs * 1000) / profile.iterations),
-      decodeUsPerOp: round3((binaryDecodeMs * 1000) / profile.iterations),
-      encodeOpsPerSecond: round3((profile.iterations * 1000) / binaryEncodeMs),
-      decodeOpsPerSecond: round3((profile.iterations * 1000) / binaryDecodeMs),
-    })
-  }
-
-  console.log('\nWire codec benchmark results\n')
-  for (const row of results) {
-    console.log(
-      [
-        `profile=${row.profile}`,
-        `payload=${row.payloadBytes}B`,
-        `format=${row.format}`,
-        `size=${row.encodedBytes}B`,
-        `enc_us=${row.encodeUsPerOp}`,
-        `dec_us=${row.decodeUsPerOp}`,
-        `enc_ops_s=${row.encodeOpsPerSecond}`,
-        `dec_ops_s=${row.decodeOpsPerSecond}`,
-      ].join(' | '),
-    )
-  }
-
-  await mkdir('bench-results', { recursive: true })
-  const outputPath = `bench-results/wire-codecs-${profileName}-${Date.now()}.json`
-  await writeFile(
-    outputPath,
-    `${JSON.stringify({
-      generatedAt: new Date().toISOString(),
-      profile: profileName,
-      iterations: profile.iterations,
-      payloadSizes: PAYLOAD_SIZES,
-      results,
-    }, null, 2)}\n`,
-    'utf8',
-  )
-  console.log(`\nSaved benchmark results to ${outputPath}`)
-}
-
-run().catch((error: unknown) => {
-  const message = error instanceof Error ? error.stack ?? error.message : String(error)
-  console.error(message)
-  process.exitCode = 1
-})

package/scripts/build-binary-conformance.ts

@@ -1,36 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises'
-import { signEnvelopeEd25519, signEnvelopeHmac } from '../src/protocol'
-import { encodeEnvelopeBinary } from '../src/protocolBinary'
-import { AIP_V01_CONFORMANCE_VECTORS, AIP_V01_ED25519_CONFORMANCE_VECTORS } from '../src/conformanceVectors'
-
-function toHex(bytes: Uint8Array): string {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')
-}
-
-async function run(): Promise<void> {
-  const hmac = await Promise.all(
-    AIP_V01_CONFORMANCE_VECTORS.map(async (vector) => {
-      const signed = await signEnvelopeHmac(vector.envelope, vector.secret, vector.keyId)
-      return { id: vector.id, alg: 'HS256', binaryHex: toHex(encodeEnvelopeBinary(signed)) }
-    }),
-  )
-  const ed25519 = await Promise.all(
-    AIP_V01_ED25519_CONFORMANCE_VECTORS.map(async (vector) => {
-      const signed = await signEnvelopeEd25519(vector.envelope, vector.privateKey, vector.keyId)
-      return { id: vector.id, alg: 'ED25519', binaryHex: toHex(encodeEnvelopeBinary(signed)) }
-    }),
-  )
-
-  await mkdir('conformance', { recursive: true })
-  await writeFile(
-    'conformance/7h3_v0_1_binary.json',
-    `${JSON.stringify({ generatedAt: new Date().toISOString(), vectors: [...hmac, ...ed25519] }, null, 2)}\n`,
-    'utf8',
-  )
-  console.log('Wrote conformance/7h3_v0_1_binary.json')
-}
-
-run().catch((error: unknown) => {
-  console.error(error instanceof Error ? error.stack ?? error.message : String(error))
-  process.exitCode = 1
-})

package/scripts/build-release-dashboard.ts

@@ -1,175 +0,0 @@
-import { access, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises'
-import process from 'node:process'
-
-interface E2ERow {
-  mode: string
-  payloadBytes: number
-  concurrency: number
-  opsPerSecond: number
-  p99Ms: number
-}
-
-interface OpenLoopRow {
-  mode: string
-  payloadBytes: number
-  concurrency: number
-  opsPerSecond: number
-  p99Ms: number
-  dropPct: number
-}
-
-interface SignatureRow {
-  algorithm: 'HS256' | 'ED25519'
-  signUsPerOp: number
-  verifyUsPerOp: number
-}
-
-interface WireRow {
-  payloadBytes: number
-  format: 'compact-json' | 'binary'
-  encodedBytes: number
-  encodeUsPerOp: number
-  decodeUsPerOp: number
-}
-
-async function readJson<T>(filePath: string): Promise<T> {
-  const raw = await readFile(filePath, 'utf8')
-  return JSON.parse(raw) as T
-}
-
-async function readJsonIfExists<T>(filePath: string): Promise<T | null> {
-  try {
-    await access(filePath)
-    return await readJson<T>(filePath)
-  } catch {
-    return null
-  }
-}
-
-async function newestFileMatching(dir: string, prefix: string): Promise<string | null> {
-  let entries: string[]
-  try {
-    entries = await readdir(dir)
-  } catch {
-    return null
-  }
-
-  const matches = entries.filter((name) => name.startsWith(prefix) && name.endsWith('.json'))
-  if (matches.length === 0) return null
-
-  let newest: { path: string; mtimeMs: number } | null = null
-  for (const name of matches) {
-    const path = `${dir}/${name}`
-    const info = await stat(path)
-    if (!newest || info.mtimeMs > newest.mtimeMs) {
-      newest = { path, mtimeMs: info.mtimeMs }
-    }
-  }
-  return newest?.path ?? null
-}
-
-function range(values: number[]): { min: number; max: number } {
-  if (values.length === 0) return { min: 0, max: 0 }
-  return {
-    min: Number(Math.min(...values).toFixed(3)),
-    max: Number(Math.max(...values).toFixed(3)),
-  }
-}
-
-async function main(): Promise<void> {
-  const warnings: string[] = []
-
-  const e2e = await readJsonIfExists<{ results: E2ERow[] }>('dist/bench/protocol-e2e.quick.latest.json')
-  const openloop = await readJsonIfExists<{ results: OpenLoopRow[] }>('dist/bench/protocol-openloop.quick.latest.json')
-  if (!e2e) warnings.push('Missing dist/bench/protocol-e2e.quick.latest.json (run npm run bench:e2e:quick)')
-  if (!openloop) warnings.push('Missing dist/bench/protocol-openloop.quick.latest.json (run npm run bench:openloop:adaptive:quick)')
-
-  const signaturePath = await newestFileMatching('bench-results', 'signature-profiles-quick-')
-  const wirePath = await newestFileMatching('bench-results', 'wire-codecs-quick-')
-
-  const signature = signaturePath ? await readJson<{ results: SignatureRow[] }>(signaturePath) : { results: [] }
-  const wire = wirePath ? await readJson<{ results: WireRow[] }>(wirePath) : { results: [] }
-
-  const e2eRows = e2e?.results ?? []
-  const openloopRows = openloop?.results ?? []
-
-  const e2eHttp1000 = e2eRows.find((row) => row.mode === 'http' && row.payloadBytes === 256 && row.concurrency === 1000) ?? null
-  const e2eWs100 = e2eRows.find((row) => row.mode === 'ws' && row.payloadBytes === 256 && row.concurrency === 100) ?? null
-  const e2eInproc100 = e2eRows.find((row) => row.mode === 'inproc' && row.payloadBytes === 256 && row.concurrency === 100) ?? null
-
-  const openloopHttp1000 = openloopRows.find((row) => row.mode === 'http' && row.payloadBytes === 256 && row.concurrency === 1000) ?? null
-
-  const hs = signature.results.filter((row) => row.algorithm === 'HS256')
-  const ed = signature.results.filter((row) => row.algorithm === 'ED25519')
-  const hsSign = range(hs.map((row) => row.signUsPerOp))
-  const hsVerify = range(hs.map((row) => row.verifyUsPerOp))
-  const edSign = range(ed.map((row) => row.signUsPerOp))
-  const edVerify = range(ed.map((row) => row.verifyUsPerOp))
-
-  const wire256Compact =
-    wire.results.find((row) => row.payloadBytes === 256 && row.format === 'compact-json') ?? null
-  const wire256Binary = wire.results.find((row) => row.payloadBytes === 256 && row.format === 'binary') ?? null
-
-  const dashboard = {
-    generatedAt: new Date().toISOString(),
-    warnings,
-    highlights: {
-      e2eHttp1000,
-      e2eWs100,
-      e2eInproc100,
-      openloopHttp1000,
-      signatures: {
-        hs256: { signUsPerOp: hsSign, verifyUsPerOp: hsVerify },
-        ed25519: { signUsPerOp: edSign, verifyUsPerOp: edVerify },
-      },
-      wire256: {
-        compact: wire256Compact,
-        binary: wire256Binary,
-      },
-    },
-  }
-
-  const markdownLines = [
-    '# Release Dashboard (Quick Bench)',
-    '',
-    `Generated: ${dashboard.generatedAt}`,
-    ...(warnings.length > 0
-      ? ['', '## Warnings', '', ...warnings.map((warning) => `- ${warning}`)]
-      : []),
-    '',
-    '## Transport highlights',
-    '',
-    `- E2E HTTP 256B c=1000: ops/s=${e2eHttp1000?.opsPerSecond ?? 0}, p99=${e2eHttp1000?.p99Ms ?? 0}ms`,
-    `- E2E WS 256B c=100: ops/s=${e2eWs100?.opsPerSecond ?? 0}, p99=${e2eWs100?.p99Ms ?? 0}ms`,
-    `- E2E InProc 256B c=100: ops/s=${e2eInproc100?.opsPerSecond ?? 0}, p99=${e2eInproc100?.p99Ms ?? 0}ms`,
-    `- OpenLoop HTTP 256B c=1000: ops/s=${openloopHttp1000?.opsPerSecond ?? 0}, p99=${openloopHttp1000?.p99Ms ?? 0}ms, drop=${openloopHttp1000?.dropPct ?? 0}%`,
-    '',
-    '## Signature ranges (us/op)',
-    '',
-    `- HS256 sign=${hsSign.min}-${hsSign.max}, verify=${hsVerify.min}-${hsVerify.max}`,
-    `- ED25519 sign=${edSign.min}-${edSign.max}, verify=${edVerify.min}-${edVerify.max}`,
-    '',
-    '## Wire format (256B)',
-    '',
-    `- compact-json size=${wire256Compact?.encodedBytes ?? 0}B, enc=${wire256Compact?.encodeUsPerOp ?? 0}us, dec=${wire256Compact?.decodeUsPerOp ?? 0}us`,
-    `- binary size=${wire256Binary?.encodedBytes ?? 0}B, enc=${wire256Binary?.encodeUsPerOp ?? 0}us, dec=${wire256Binary?.decodeUsPerOp ?? 0}us`,
-    '',
-  ]
-
-  await mkdir('dist/release-dashboard', { recursive: true })
-  await writeFile('dist/release-dashboard/latest.json', `${JSON.stringify(dashboard, null, 2)}\n`, 'utf8')
-  await writeFile('dist/release-dashboard/latest.md', `${markdownLines.join('\n')}\n`, 'utf8')
-
-  console.log('Wrote dist/release-dashboard/latest.json')
-  console.log('Wrote dist/release-dashboard/latest.md')
-  if (warnings.length > 0) {
-    console.log('Dashboard generated with warnings:')
-    for (const warning of warnings) console.log(`- ${warning}`)
-  }
-}
-
-main().catch((error: unknown) => {
-  const message = error instanceof Error ? error.stack ?? error.message : String(error)
-  console.error(message)
-  process.exitCode = 1
-})

package/scripts/canary-rollout.ts

@@ -1,38 +0,0 @@
-interface CanaryStage {
-  percent: number
-  durationMinutes: number
-  required: {
-    maxDropPct: number
-    maxP99Ms: number
-  }
-}
-
-const DEFAULT_PLAN: CanaryStage[] = [
-  { percent: 5, durationMinutes: 15, required: { maxDropPct: 0.1, maxP99Ms: 20 } },
-  { percent: 25, durationMinutes: 30, required: { maxDropPct: 0.1, maxP99Ms: 20 } },
-  { percent: 50, durationMinutes: 30, required: { maxDropPct: 0.1, maxP99Ms: 20 } },
-  { percent: 100, durationMinutes: 60, required: { maxDropPct: 0.1, maxP99Ms: 20 } },
-]
-
-function renderStage(stage: CanaryStage): string {
-  return [
-    `- Stage ${stage.percent}% for ${stage.durationMinutes}m`,
-    `  - maxDropPct <= ${stage.required.maxDropPct}`,
-    `  - maxP99Ms <= ${stage.required.maxP99Ms}`,
-  ].join('\n')
-}
-
-async function main(): Promise<void> {
-  console.log('Canary rollout plan')
-  console.log('===================')
-  for (const stage of DEFAULT_PLAN) {
-    console.log(renderStage(stage))
-  }
-  console.log('\nRollback trigger: if any stage breaches limits for sustained window, rollback immediately.')
-}
-
-main().catch((error: unknown) => {
-  const message = error instanceof Error ? error.stack ?? error.message : String(error)
-  console.error(message)
-  process.exitCode = 1
-})