mppx 0.8.15 → 0.8.18

package/src/internal/HeaderCodec.ts

@@ -1,36 +0,0 @@
-import { Base64 } from 'ox'
-
-import type * as z from '../zod.js'
-
-/**
- * Creates a typed codec for JSON HTTP header values.
- *
- * x402 uses plain base64 JSON header bodies, while the Payment auth scheme uses
- * its own base64url/JCS serializers. Keep this helper internal so transports
- * can opt into the exact wire encoding their protocol expects.
- */
-export function createJson<const schema extends z.ZodMiniType>(schema: schema) {
-  type value = z.output<schema>
-
-  return {
-    encode(value: value): string {
-      return Base64.fromString(JSON.stringify(schema.parse(value)))
-    },
-    decode(value: string): value {
-      try {
-        return schema.parse(JSON.parse(Base64.toString(value))) as value
-      } catch {
-        throw new InvalidJsonHeaderError()
-      }
-    },
-  }
-}
-
-/** Error thrown when a JSON header value is not valid base64-encoded JSON. */
-export class InvalidJsonHeaderError extends Error {
-  override readonly name = 'InvalidJsonHeaderError'
-
-  constructor() {
-    super('Invalid base64 JSON header.')
-  }
-}

package/src/internal/changeset.test.ts

@@ -1,106 +0,0 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-import { describe, expect, test } from 'vp/test'
-
-const changesetDir = path.resolve(import.meta.dirname, '../../.changeset')
-const validPackages = new Set(['mppx'])
-const validBumpTypes = new Set(['major', 'minor', 'patch', 'none'])
-
-function getChangesetFiles() {
-  return fs
-    .readdirSync(changesetDir)
-    .filter((f) => f.endsWith('.md') && f !== 'README.md' && !f.startsWith('.'))
-}
-
-function parseFrontmatter(content: string) {
-  const match = content.match(/^\s*---\n([^]*?)\n\s*---/)
-  if (!match) return undefined
-  return match[1]
-}
-
-function parseReleases(frontmatter: string) {
-  return [...frontmatter.matchAll(/^['"]?([^'":\n]+?)['"]?\s*:\s*(.+)$/gm)].map(
-    ([, name, type]) => ({ name: name!.trim(), type: type!.trim().replace(/['"]/g, '') }),
-  )
-}
-
-describe('changesets', () => {
-  const files = getChangesetFiles()
-
-  test('all changeset files have valid frontmatter fences', () => {
-    for (const file of files) {
-      const content = fs.readFileSync(path.join(changesetDir, file), 'utf-8')
-      expect(content, `${file}: must start with "---"`).toMatch(/^---\n/)
-      const closingIdx = content.indexOf('---', 3)
-      expect(closingIdx, `${file}: missing closing "---" fence`).toBeGreaterThan(3)
-
-      // closing fence must not have trailing non-whitespace (parser chokes)
-      const afterClosing = content.slice(closingIdx + 3).split('\n')[0]!
-      expect(afterClosing.trim(), `${file}: trailing characters after closing "---"`).toBe('')
-    }
-  })
-
-  test('all changesets reference valid packages', () => {
-    for (const file of files) {
-      const content = fs.readFileSync(path.join(changesetDir, file), 'utf-8')
-      const frontmatter = parseFrontmatter(content)
-      if (!frontmatter) continue
-      for (const { name } of parseReleases(frontmatter)) {
-        expect(
-          validPackages.has(name),
-          `${file}: unknown package "${name}" (valid: ${[...validPackages].join(', ')})`,
-        ).toBe(true)
-      }
-    }
-  })
-
-  test('all changesets use valid bump types', () => {
-    for (const file of files) {
-      const content = fs.readFileSync(path.join(changesetDir, file), 'utf-8')
-      const frontmatter = parseFrontmatter(content)
-      if (!frontmatter) continue
-      for (const { name, type } of parseReleases(frontmatter)) {
-        expect(
-          validBumpTypes.has(type),
-          `${file}: invalid bump type "${type}" for "${name}" (valid: major, minor, patch, none)`,
-        ).toBe(true)
-      }
-    }
-  })
-
-  test('no changeset uses major bump (pre-v1 policy)', () => {
-    for (const file of files) {
-      const content = fs.readFileSync(path.join(changesetDir, file), 'utf-8')
-      const frontmatter = parseFrontmatter(content)
-      if (!frontmatter) continue
-      for (const { name, type } of parseReleases(frontmatter)) {
-        expect(type, `${file}: "${name}" uses major bump — pre-v1 policy forbids this`).not.toBe(
-          'major',
-        )
-      }
-    }
-  })
-
-  test('all changesets have a non-empty description', () => {
-    for (const file of files) {
-      const content = fs.readFileSync(path.join(changesetDir, file), 'utf-8')
-      const match = content.match(/^\s*---[^]*?---\s*(.*)$/s)
-      expect(match?.[1]?.trim(), `${file}: changeset has an empty description`).toBeTruthy()
-    }
-  })
-
-  test('no duplicate package entries in frontmatter', () => {
-    for (const file of files) {
-      const content = fs.readFileSync(path.join(changesetDir, file), 'utf-8')
-      const frontmatter = parseFrontmatter(content)
-      if (!frontmatter) continue
-      const releases = parseReleases(frontmatter)
-      const seen = new Set<string>()
-      for (const { name } of releases) {
-        expect(seen.has(name), `${file}: duplicate entry for "${name}"`).toBe(false)
-        seen.add(name)
-      }
-    }
-  })
-})

package/src/internal/constantTimeEqual.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import { constantTimeEqual } from './constantTimeEqual.js'
-
-describe('constantTimeEqual', () => {
-  test('returns true for identical strings', () => {
-    expect(constantTimeEqual('abc', 'abc')).toBe(true)
-  })
-
-  test('returns true for empty strings', () => {
-    expect(constantTimeEqual('', '')).toBe(true)
-  })
-
-  test('returns false for different strings of same length', () => {
-    expect(constantTimeEqual('abc', 'abd')).toBe(false)
-  })
-
-  test('returns false for different lengths', () => {
-    expect(constantTimeEqual('abc', 'abcd')).toBe(false)
-    expect(constantTimeEqual('abcd', 'abc')).toBe(false)
-  })
-
-  test('returns false for empty vs non-empty', () => {
-    expect(constantTimeEqual('', 'a')).toBe(false)
-    expect(constantTimeEqual('a', '')).toBe(false)
-  })
-
-  test('returns false when only first character differs', () => {
-    expect(constantTimeEqual('xbc', 'abc')).toBe(false)
-  })
-
-  test('returns false when only last character differs', () => {
-    expect(constantTimeEqual('abx', 'abc')).toBe(false)
-  })
-
-  test('handles base64url strings (typical HMAC output)', () => {
-    const a = 'dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk'
-    const b = 'dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk'
-    expect(constantTimeEqual(a, b)).toBe(true)
-  })
-
-  test('detects single-bit difference in base64url strings', () => {
-    const a = 'dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk'
-    const b = 'dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXl'
-    expect(constantTimeEqual(a, b)).toBe(false)
-  })
-})

package/src/internal/constantTimeEqual.ts

@@ -1,10 +0,0 @@
-import { Hash, Hex } from 'ox'
-
-/** Constant-time string comparison to prevent timing attacks. */
-export function constantTimeEqual(a: string, b: string): boolean {
-  const hashA = Hash.sha256(Hex.fromString(a))
-  const hashB = Hash.sha256(Hex.fromString(b))
-  let result = 0
-  for (let i = 0; i < hashA.length; i++) result |= hashA.charCodeAt(i) ^ hashB.charCodeAt(i)
-  return result === 0
-}

package/src/internal/env.test.ts

@@ -1,42 +0,0 @@
-import * as Env from './env.js'
-
-afterEach(() => {
-  vi.unstubAllEnvs()
-})
-
-describe('Env.get', () => {
-  test('returns undefined when no env vars are set', () => {
-    expect(Env.get('realm')).toBeUndefined()
-  })
-
-  test('returns undefined when MPP_SECRET_KEY is not set', () => {
-    expect(Env.get('secretKey')).toBeUndefined()
-  })
-
-  test('returns MPP_SECRET_KEY when set', () => {
-    vi.stubEnv('MPP_SECRET_KEY', 'sk_live_abc123')
-    expect(Env.get('secretKey')).toBe('sk_live_abc123')
-  })
-
-  test('MPP_REALM takes precedence over platform vars', () => {
-    vi.stubEnv('MPP_REALM', 'custom-realm')
-    vi.stubEnv('FLY_APP_NAME', 'fly-app')
-    expect(Env.get('realm')).toBe('custom-realm')
-  })
-
-  test('returns FLY_APP_NAME when set', () => {
-    vi.stubEnv('FLY_APP_NAME', 'my-fly-app')
-    expect(Env.get('realm')).toBe('my-fly-app')
-  })
-
-  test('FLY_APP_NAME takes precedence over VERCEL_URL', () => {
-    vi.stubEnv('FLY_APP_NAME', 'fly-app')
-    vi.stubEnv('VERCEL_URL', 'my-app.vercel.app')
-    expect(Env.get('realm')).toBe('fly-app')
-  })
-
-  test('falls through to later vars when earlier ones are unset', () => {
-    vi.stubEnv('VERCEL_URL', 'my-app.vercel.app')
-    expect(Env.get('realm')).toBe('my-app.vercel.app')
-  })
-})

package/src/internal/env.ts

@@ -1,49 +0,0 @@
-/** Map of configuration keys to environment variable names, checked in order. */
-const variables = {
-  realm: [
-    'MPP_REALM',
-    'FLY_APP_NAME',
-    'HEROKU_APP_NAME',
-    'RAILWAY_PUBLIC_DOMAIN',
-    'RENDER_EXTERNAL_HOSTNAME',
-    'VERCEL_URL',
-    'WEBSITE_HOSTNAME',
-  ],
-  secretKey: ['MPP_SECRET_KEY'],
-} as const satisfies Record<string, readonly string[]>
-
-/** Fallback values when no environment variable is set. */
-const defaults = {} as const satisfies Partial<Record<keyof typeof variables, string>>
-
-/**
- * Resolves a configuration value from environment variables.
- *
- * Checks platform-specific env vars in order, falling back to a default if one exists.
- *
- * @example
- * ```ts
- * Env.get('realm')     // e.g. "my-app.vercel.app"
- * Env.get('secretKey') // e.g. value of MPP_SECRET_KEY
- * ```
- */
-export function get(key: keyof typeof variables): string | undefined {
-  for (const name of variables[key]) {
-    const value = read(name)
-    if (value) return value
-  }
-  return (defaults as Record<string, string | undefined>)[key]
-}
-
-/** Reads a single environment variable, probing available runtime APIs. */
-function read(name: string): string | undefined {
-  try {
-    if (typeof process !== 'undefined' && process?.env) return process.env[name] || undefined
-  } catch {}
-
-  try {
-    const deno = (globalThis as any).Deno
-    if (deno?.env?.get) return deno.env.get(name) || undefined
-  } catch {}
-
-  return undefined
-}

package/src/internal/types.test-d.ts

@@ -1,21 +0,0 @@
-import { expectTypeOf, test } from 'vp/test'
-
-import type { ConfiguredDefaults } from './types.js'
-
-test('ConfiguredDefaults retains only known defined values', () => {
-  type Parameters = {
-    configured: string
-    maybeDefined?: number | undefined
-    explicitlyUndefined: boolean | undefined
-    unrelated: bigint
-  }
-  type Defaults = {
-    configured?: string | undefined
-    maybeDefined?: number | undefined
-    explicitlyUndefined?: boolean | undefined
-  }
-
-  expectTypeOf<ConfiguredDefaults<Parameters, Defaults>>().toEqualTypeOf<{
-    configured: string
-  }>()
-})