Skip to content

Self-hosted personal gallery application with online photo management and albums, supporting Live/Motion Photos, EXIF parsing, geolocation recognition, and an explore map.

32.5 KB
Raw Blame
import { splitSqlQuery } from './helpers/sql.ts'
import assert from 'node:assert/strict'
import test from 'node:test'
import { readFile, readdir } from 'node:fs/promises'
import { createRequire } from 'node:module'
import {
  createD1Provisioning,
  createD1Directory,
  createD1SiteCatalog,
} from '../packages/platform/src/index.ts'
import {
  createDomainManager,
  DomainError,
  renameDefaultDomain,
  DOMAIN_HEALTH_TTL,
} from '../packages/platform/src/domains.ts'
import type { DomainProvider } from '../packages/platform/src/domains.ts'
import {
  normalizeDomain,
  validSiteSlug,
  domainClaimTarget,
} from '../packages/contracts/src/domains.ts'
import {
  checkDomainCname,
  createDomainProvider,
} from '../apps/shared/platform/domain-provider.ts'
const require = createRequire(import.meta.url),
  { Miniflare, convertV4MiniflareOptions } = createRequire(
    require.resolve('wrangler/package.json'),
  )('miniflare')

test('Domain input accepts IDN hostnames but rejects URLs, IPs and reserved platform addresses', () => {
  assert.equal(normalizeDomain(' Photos.Example.COM. '), 'photos.example.com')
  assert.equal(normalizeDomain('相册.example.com'), 'xn--26q252g.example.com')
  for (const v of [
    'https://example.com',
    'example.com:443',
    '[email protected]',
    '*.example.com',
    'example.com/path',
    '127.0.0.1',
    '2130706433',
    'bad..example',
    'x\\evil.com',
    'example.com?x',
    'a'.repeat(64) + '.com',
  ])
    assert.throws(() => normalizeDomain(v), v)
  for (const v of [
    'app',
    'docs',
    'cname',
    'site',
    'api',
    'staging',
    'mail',
    'noreply',
    'smtp',
    'dev',
    'www',
  ])
    assert.equal(validSiteSlug(v), false, v)
  assert.equal(validSiteSlug('timo'), true)
})

test('Real D1 custom domains fence claims, CNAME ownership transitions, provider retries, primary and removal', async () => {
  const mf = new Miniflare(
    convertV4MiniflareOptions({
      modules: true,
      script: 'export default {fetch(){return new Response("test")}}',
      compatibilityDate: '2026-10-22',
      d1Databases: ['DB'],
    }),
  )
  try {
    const db = await mf.getD1Database('DB')
    for (const file of (await readdir('packages/platform/migrations'))
      .filter((f) => f.endsWith('.sql'))
      .sort()) {
      const sql = await readFile('packages/platform/migrations/' + file, 'utf8')
      for (const q of splitSqlQuery(sql.replace(/^--.*$/gm, ''))
        .map((s) => s.trim())
        .filter(Boolean))
        await db.prepare(q).run()
    }
    let time = Date.now(),
      sequence = 0
    await db
      .prepare(
        'INSERT INTO platform_users(id,email,name,email_verified,created_at,updated_at) VALUES(1,?,?,1,?,?),(2,?,?,1,?,?)',
      )
      .bind(
        '[email protected]',
        'One',
        time,
        time,
        '[email protected]',
        'Two',
        time,
        time,
      )
      .run()
    await db
      .prepare(
        `UPDATE platform_plans SET policy_json=json_set(policy_json,'$.limits.sites',10,'$.limits.customDomains',4,'$.limits.byos',1) WHERE id='free'`,
      )
      .run()
    const sites = createD1Provisioning(db)
    const one = await sites.create(1, {
      name: 'One',
      slug: 'timo',
      requestId: '00000000-0000-4000-8000-000000000001',
    })
    const two = await sites.create(2, {
      name: 'Two',
      slug: 'other',
      requestId: '00000000-0000-4000-8000-000000000002',
    })
    await db.prepare('UPDATE platform_sites SET published=1').run()
    const hosts = new Map<
        string,
        { id: string; status: string; ssl: string }
      >(),
      routes = new Map<string, { id: string; owned: boolean }>(),
      dns = new Map<string, string>()
    let creates = 0,
      routeCreates = 0,
      loseCreate = false,
      failDelete = false
    const nextId = () => (++sequence).toString(16).padStart(32, '0')
    const provider: DomainProvider = {
      count: async () => hosts.size,
      find: async (h) => hosts.get(h) ?? null,
      get: async (id) => [...hosts.values()].find((x) => x.id === id) ?? null,
      async create(h) {
        creates++
        const value = { id: nextId(), status: 'active', ssl: 'active' }
        hosts.set(h, value)
        if (loseCreate) {
          loseCreate = false
          throw new DomainError(503, 'domain_provider_unavailable')
        }
        return value
      },
      retry: async () => {},
      async remove(id) {
        if (failDelete) {
          failDelete = false
          throw new DomainError(503, 'domain_provider_unavailable')
        }
        for (const [h, v] of hosts) if (v.id === id) hosts.delete(h)
      },
      findRoute: async (h) => routes.get(h) ?? null,
      async createRoute(h) {
        routeCreates++
        const id = nextId()
        routes.set(h, { id, owned: true })
        return id
      },
      async removeRoute(id, h) {
        if (routes.get(h)?.id === id) routes.delete(h)
      },
    }
    const config = {
      enabled: true,
      routingReady: true,
      baseDomain: 'chronoframe.art',
      cnameTarget: 'cname.chronoframe.art',
      limit: 20,
    }
    const manager = createDomainManager(db, config, {
        provider,
        dns: async (h, target) => (dns.get(h) === target ? 'ready' : 'missing'),
        id: nextId,
        now: () => time,
      }),
      directory = createD1Directory(db, () => time)
    assert.equal(
      (await directory.getPublishedSiteByHost('timo.chronoframe.art'))?.id,
      one.siteId,
    )
    for (const name of [
      'app.chronoframe.art',
      'timo.chronoframe.art',
      'cname.chronoframe.art',
      'foo.workers.dev',
    ])
      await assert.rejects(
        () => manager.request(1, one.siteId, name),
        DomainError,
      )
    await assert.rejects(
      () => manager.request(2, one.siteId, 'outside.example.com'),
      { statusCode: 404 },
    )
    let domain = await manager.request(1, one.siteId, ' Photos.Example.com ')
    dns.set(domain.hostname, 'cname.chronoframe.art')
    await manager.reconcile()
    assert.equal(
      creates,
      0,
      'a claimant cannot activate when the real owner later points at the shared ingress',
    )
    time += 60000
    assert.equal(domain.cnameTarget, domainClaimTarget(domain.generation))
    await assert.rejects(
      () => manager.request(2, two.siteId, domain.hostname),
      { code: 'domain_conflict' },
    )
    dns.set(domain.hostname, domain.cnameTarget)
    await db
      .prepare(
        'UPDATE platform_domain_provider_lock SET lease_token=?,lease_until=? WHERE id=1',
      )
      .bind('other-allocation', time + 60000)
      .run()
    await manager.reconcile()
    domain = (await manager.list(1, one.siteId))[0]!
    assert.equal(domain.error, 'domain_wait')
    assert.equal(
      creates,
      0,
      'a concurrent allocation cannot bypass the provider resource cap',
    )
    time += 60001
    await manager.reconcile()
    domain = (await manager.list(1, one.siteId))[0]!
    assert.equal(domain.status, 'active')
    assert.equal(creates, 1)
    assert.equal(routeCreates, 1)
    assert.equal(
      (await directory.getPublishedSiteByHost(domain.hostname))?.id,
      one.siteId,
    )
    await manager.mutate(
      1,
      one.siteId,
      domain.hostname,
      domain.generation,
      domain.revision,
      'primary',
    )
    domain = (await manager.list(1, one.siteId))[0]!
    assert.equal(domain.primary, true)
    // Downgrades block traffic before the next provider reconciliation.
    const claimGeneration = domain.generation,
      claimTarget = domain.cnameTarget
    await db
      .prepare(
        "UPDATE platform_plans SET policy_json=json_set(policy_json,'$.limits.customDomains',0) WHERE id='free'",
      )
      .run()
    assert.equal(await directory.getPublishedSiteByHost(domain.hostname), null)
    let held = (await manager.list(1, one.siteId))[0]!
    assert.equal(held.holdReason, 'plan')
    assert.equal(held.status, 'paused')
    assert.equal(held.cleanupPending, true)
    failDelete = true
    time += 1800001
    await manager.reconcile(domain.hostname)
    assert.equal(
      hosts.size,
      1,
      'failed cleanup retains the upstream reference for retry',
    )
    assert.equal(await directory.getPublishedSiteByHost(domain.hostname), null)
    time += 1800001
    await manager.reconcile(domain.hostname)
    held = (await manager.list(1, one.siteId))[0]!
    assert.equal(held.cleanupPending, false)
    assert.equal(hosts.size, 0)
    assert.equal(routes.size, 0)
    assert.equal(held.generation, claimGeneration)
    const heldRevision = held.revision
    const suspendedAudits = (await db
      .prepare(
        "SELECT COUNT(*) AS n FROM platform_domain_audit WHERE hostname=? AND action='suspended'",
      )
      .bind(domain.hostname)
      .first())!.n
    time += 1800001
    await manager.reconcile(domain.hostname)
    assert.equal(
      (await manager.list(1, one.siteId))[0]!.revision,
      heldRevision,
      'unchanged holds only heartbeat, without revision churn',
    )
    assert.equal(
      (await db
        .prepare(
          "SELECT COUNT(*) AS n FROM platform_domain_audit WHERE hostname=? AND action='suspended'",
        )
        .bind(domain.hostname)
        .first())!.n,
      suspendedAudits,
      'unchanged holds do not duplicate audit entries',
    )
    await db
      .prepare(
        "UPDATE platform_plans SET policy_json=json_set(policy_json,'$.limits.customDomains',4) WHERE id='free'",
      )
      .run()
    await db.prepare('UPDATE platform_custom_domains SET next_check_at=0').run()
    await manager.reconcile(domain.hostname)
    domain = (await manager.list(1, one.siteId))[0]!
    assert.equal(domain.status, 'active')
    assert.equal(domain.primary, true)
    assert.equal(domain.cnameTarget, claimTarget)
    // Owner and site moderation block all public routes immediately.
    await db
      .prepare(
        "INSERT INTO platform_account_controls(user_id,suspended,public_reason) VALUES(1,1,'Account under review')",
      )
      .run()
    assert.equal(
      await directory.getPublishedSiteByHost('timo.chronoframe.art'),
      null,
    )
    assert.equal(await directory.getPublishedSiteByHost(domain.hostname), null)
    await db.prepare('UPDATE platform_account_controls SET suspended=0').run()
    await db
      .prepare(
        "UPDATE platform_sites SET suspended=1,suspension_reason='Site under review' WHERE id=?",
      )
      .bind(one.siteId)
      .run()
    const catalog = await createD1SiteCatalog(db).list(1)
    assert.equal(catalog[0]?.suspended, true)
    assert.equal(catalog[0]?.suspensionReason, 'Site under review')
    await db
      .prepare('UPDATE platform_sites SET suspended=0 WHERE id=?')
      .bind(one.siteId)
      .run()
    await manager.mutate(
      1,
      one.siteId,
      domain.hostname,
      domain.generation,
      domain.revision,
      'pause',
    )
    assert.equal(await directory.getPublishedSiteByHost(domain.hostname), null)
    assert.equal(
      (await directory.getPublishedSiteByHost('timo.chronoframe.art'))?.id,
      one.siteId,
    )
    await assert.rejects(
      () =>
        manager.mutate(
          1,
          one.siteId,
          domain.hostname,
          domain.generation,
          domain.revision,
          'resume',
        ),
      { code: 'domain_changed' },
    )
    domain = (await manager.list(1, one.siteId))[0]!
    await manager.mutate(
      1,
      one.siteId,
      domain.hostname,
      domain.generation,
      domain.revision,
      'resume',
    )
    await manager.reconcile()
    domain = (await manager.list(1, one.siteId))[0]!
    assert.equal(domain.status, 'active')
    failDelete = true
    await manager.mutate(
      1,
      one.siteId,
      domain.hostname,
      domain.generation,
      domain.revision,
      'delete',
    )
    await manager.reconcile()
    domain = (await manager.list(1, one.siteId))[0]!
    assert.equal(domain.status, 'deleting')
    assert.equal(await directory.getPublishedSiteByHost(domain.hostname), null)
    time += 1800000
    await manager.reconcile()
    assert.equal((await manager.list(1, one.siteId)).length, 0)
    assert.equal(hosts.size, 0)
    dns.set('photos.example.com', domain.cnameTarget)
    let rebound = await manager.request(2, two.siteId, 'photos.example.com')
    assert.equal(rebound.dnsStatus, 'missing')
    assert.notEqual(rebound.cnameTarget, domain.cnameTarget)
    await manager.reconcile()
    assert.equal(
      creates,
      2,
      'a prior generation CNAME must not establish account ownership',
    )
    dns.set(rebound.hostname, 'cname.chronoframe.art')
    time += 60000
    await manager.reconcile()
    assert.equal(
      creates,
      2,
      'a shared CNAME does not authorize the new generation',
    )
    dns.set(rebound.hostname, rebound.cnameTarget)
    time += 60000
    await manager.reconcile()
    rebound = (await manager.list(2, two.siteId))[0]!
    assert.equal(rebound.status, 'active')
    assert.equal(
      (await directory.getPublishedSiteByHost(rebound.hostname))?.id,
      two.siteId,
    )
    assert.notEqual(rebound.generation, domain.generation)
    await assert.rejects(
      () =>
        manager.mutate(
          1,
          one.siteId,
          domain.hostname,
          domain.generation,
          domain.revision,
          'delete',
        ),
      { code: 'domain_not_found' },
    )
    loseCreate = true
    let lost = await manager.request(1, one.siteId, 'lost.example.com')
    dns.set(lost.hostname, lost.cnameTarget)
    await manager.reconcile()
    assert.equal(
      (await manager.list(1, one.siteId))[0]?.error,
      'domain_provider_unavailable',
    )
    const created = creates
    time += 1800000
    await manager.reconcile()
    lost = (await manager.list(1, one.siteId))[0]!
    assert.equal(lost.status, 'active')
    assert.equal(
      creates,
      created,
      'lost create response reconciles instead of duplicating the certificate',
    )
    time += DOMAIN_HEALTH_TTL + 1
    assert.equal(
      await directory.getPublishedSiteByHost(lost.hostname),
      null,
      'stale provider/DNS evidence stops serving',
    )
    await manager.reconcile()
    assert.equal(
      (await directory.getPublishedSiteByHost(lost.hostname))?.id,
      one.siteId,
    )
    let release!: () => void, started!: () => void
    const gate = new Promise<void>((resolve) => {
        release = resolve
      }),
      entered = new Promise<void>((resolve) => {
        started = resolve
      })
    const originalCreate = provider.create
    provider.create = async (hostname) => {
      const result = await originalCreate(hostname)
      if (hostname === 'leased.example.com') {
        started()
        await gate
      }
      return result
    }
    let leased = await manager.request(1, one.siteId, 'leased.example.com')
    dns.set(leased.hostname, leased.cnameTarget)
    const pending = manager.reconcile(leased.hostname)
    await entered
    leased = (await manager.list(1, one.siteId)).find(
      (d) => d.hostname === leased.hostname,
    )!
    await manager.mutate(
      1,
      one.siteId,
      leased.hostname,
      leased.generation,
      leased.revision,
      'delete',
    )
    await manager.reconcile(leased.hostname)
    assert.ok(
      hosts.has(leased.hostname),
      'cleanup cannot race the in-flight provider request',
    )
    release()
    await pending
    assert.equal(
      (await manager.list(1, one.siteId)).find(
        (d) => d.hostname === leased.hostname,
      )?.status,
      'deleting',
    )
    time += 300001
    await manager.reconcile(leased.hostname)
    assert.equal(hosts.has(leased.hostname), false)
    provider.create = originalCreate
    let releasePolicy!: () => void, enteredPolicy!: () => void
    const policyGate = new Promise<void>((r) => (releasePolicy = r)),
      policyStarted = new Promise<void>((r) => (enteredPolicy = r))
    provider.create = async (host) => {
      const result = await originalCreate(host)
      if (host === 'policy-race.example.com') {
        enteredPolicy()
        await policyGate
      }
      return result
    }
    const racing = await manager.request(
      1,
      one.siteId,
      'policy-race.example.com',
    )
    dns.set(racing.hostname, racing.cnameTarget)
    const work = manager.reconcile(racing.hostname)
    await policyStarted
    await db.batch([
      db.prepare(
        "UPDATE platform_plans SET policy_json=json_set(policy_json,'$.limits.customDomains',0) WHERE id='free'",
      ),
      db.prepare(
        'UPDATE platform_policy_epoch SET revision=revision+1 WHERE id=1',
      ),
    ])
    releasePolicy()
    await work
    assert.equal(await directory.getPublishedSiteByHost(racing.hostname), null)
    assert.equal(
      routes.has(racing.hostname),
      false,
      'old policy cannot finish publishing a route',
    )
    time += 300001
    await manager.reconcile(racing.hostname)
    assert.equal(
      hosts.has(racing.hostname),
      false,
      'uncertain provider create is recovered and reclaimed',
    )
    await db
      .prepare(
        "UPDATE platform_plans SET policy_json=json_set(policy_json,'$.limits.customDomains',4) WHERE id='free'",
      )
      .run()
    // A queued permanent removal is not finalized until upstream deletion succeeds.
    await db
      .prepare(
        "UPDATE platform_custom_domains SET state='deleting',purge_requested=1,next_check_at=0 WHERE hostname=?",
      )
      .bind(lost.hostname)
      .run()
    failDelete = true
    await manager.reconcile(lost.hostname)
    assert.ok(
      await db
        .prepare(
          'SELECT hostname FROM platform_custom_domains WHERE hostname=?',
        )
        .bind(lost.hostname)
        .first(),
    )
    time += 1800001
    await db
      .prepare(
        "CREATE TRIGGER fail_purge BEFORE DELETE ON platform_custom_domains BEGIN SELECT RAISE(ABORT,'forced purge failure'); END",
      )
      .run()
    await manager.reconcile(lost.hostname)
    assert.equal(
      (
        await db
          .prepare('SELECT state FROM platform_custom_domains WHERE hostname=?')
          .bind(lost.hostname)
          .first()
      )?.state,
      'deleted',
      'confirmed upstream removal survives a failed final database purge',
    )
    await db.prepare('DROP TRIGGER fail_purge').run()
    await manager.reconcile(lost.hostname)
    assert.equal(hosts.has(lost.hostname), false)
    assert.equal(
      await db
        .prepare(
          'SELECT hostname FROM platform_custom_domains WHERE hostname=?',
        )
        .bind(lost.hostname)
        .first(),
      null,
    )
    provider.create = originalCreate

    await renameDefaultDomain(
      db,
      1,
      one.siteId,
      { slug: 'timo-new', revision: one.revision },
      'chronoframe.art',
      time,
    )
    assert.equal(
      (await directory.getPublishedSiteByHost('timo-new.chronoframe.art'))?.id,
      one.siteId,
    )
    assert.equal(
      (await directory.getPublishedSiteByHost('timo.chronoframe.art'))?.id,
      one.siteId,
    )
    await assert.rejects(
      () =>
        sites.create(2, {
          name: 'Taken',
          slug: 'timo',
          requestId: '00000000-0000-4000-8000-000000000003',
        }),
      { statusCode: 409 },
    )
    time += 7 * 86400000 + 1
    assert.equal(
      await directory.getPublishedSiteByHost('timo.chronoframe.art'),
      null,
    )
    assert.equal(
      (await directory.getPublishedSiteByHost('timo-new.chronoframe.art'))?.id,
      one.siteId,
    )
  } finally {
    await mf.dispose()
  }
})

test('DNS validation uses fixed CNAME-only resolvers and provider credentials never follow redirects', async () => {
  const urls: string[] = []
  const dnsFetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
    urls.push(String(input))
    assert.equal(init?.redirect, 'manual')
    return new Response(
      JSON.stringify({
        Status: 0,
        Answer: [
          {
            name: 'photos.example.com.',
            type: 5,
            data: 'cname.chronoframe.art.',
          },
        ],
      }),
    )
  }) as typeof fetch
  assert.equal(
    await checkDomainCname(
      'photos.example.com',
      'cname.chronoframe.art',
      dnsFetch,
    ),
    'ready',
  )
  assert.equal(urls.length, 2)
  assert.ok(
    urls.every(
      (u) =>
        u.startsWith('https://cloudflare-dns.com/dns-query?') ||
        u.startsWith('https://dns.google/resolve?'),
    ),
  )
  assert.ok(urls.every((u) => u.endsWith('&type=CNAME')))
  const provider = createDomainProvider(
    {
      token: 'fake-provider-secret',
      zoneId: 'a'.repeat(32),
      siteWorker: 'chronoframe-site',
    },
    async (input, init) => {
      assert.ok(
        String(input).startsWith('https://api.cloudflare.com/client/v4/zones/'),
      )
      assert.equal(init?.redirect, 'manual')
      return new Response(
        JSON.stringify({
          success: false,
          errors: [{ message: 'SECRET PROVIDER DETAIL' }],
        }),
        { status: 403 },
      )
    },
  )
  const hostnameId = '0d89c70d-ad9f-4843-b99f-6cc0252067e9'
  const uuidProvider = createDomainProvider(
    {
      token: 'fake-provider-secret',
      zoneId: 'a'.repeat(32),
      siteWorker: 'chronoframe-site',
    },
    async () =>
      new Response(
        JSON.stringify({
          success: true,
          result: {
            id: hostnameId,
            hostname: 'photos.example.com',
            status: 'active',
            ssl: { status: 'active' },
          },
        }),
      ),
  )
  assert.equal((await uuidProvider.create('photos.example.com')).id, hostnameId)
  assert.equal((await uuidProvider.get(hostnameId))?.id, hostnameId)
  await assert.rejects(
    () => provider.create('photos.example.com'),
    (error) =>
      error instanceof DomainError &&
      error.code === 'domain_provider_unavailable' &&
      !String(error).includes('SECRET'),
  )
})

test('Deployment isolates named Previews and leaves customer route ownership with the domain controller', async () => {
  const { configureDomainDeployment, domainDeploymentValues } =
    await import('../scripts/domain-deployment.mjs')
  assert.throws(
    () =>
      domainDeploymentValues('production', {
        PLATFORM_DOMAIN_RESOURCE_LIMIT: '21',
      }),
    /between 1 and 20/,
  )
  const config: Record<string, any> = {
    name: 'chronoframe-cloud',
    routes: [{ pattern: 'old.example.com/*' }],
    triggers: { crons: ['old'] },
  }
  configureDomainDeployment(config, 'cloud', 'production', {
    PLATFORM_DOMAIN_ENABLED: 'true',
    PLATFORM_DEFAULT_DOMAINS_READY: 'true',
    PLATFORM_DOMAIN_ROUTING_READY: 'true',
    PLATFORM_DOMAIN_ZONE_ID: 'a'.repeat(32),
    PLATFORM_DOMAIN_PROVIDER_TOKEN: 'fake-provider-token-'.repeat(2),
  })
  assert.deepEqual(
    configureDomainDeployment({}, 'cloud', 'production', {}).triggers,
    { crons: ['* * * * *'] },
  )
  assert.equal('routes' in config, false)
  assert.deepEqual(config.triggers, { crons: ['* * * * *'] })
  assert.equal(
    config.vars.NUXT_PLATFORM_DOMAIN_CNAME_TARGET,
    'cname.chronoframe.art',
  )
  assert.ok(!JSON.stringify(config).includes('fake-provider-token'))
  const preview = configureDomainDeployment(
    { routes: [], vars: { PRIVATE_PRODUCTION_MARKER: 'not-a-secret' } },
    'site',
    'staging',
    {},
  )
  assert.equal(
    preview.previews.vars.NUXT_PUBLIC_SITE_BASE_DOMAIN,
    'staging.chronoframe.art',
  )
  assert.equal(preview.previews.vars.NUXT_PUBLIC_DEFAULT_DOMAINS_READY, 'false')
  assert.equal(
    preview.previews.vars.NUXT_PLATFORM_DOMAIN_PROVIDER_TOKEN,
    undefined,
  )
  assert.throws(() =>
    domainDeploymentValues('staging', {
      PLATFORM_DOMAIN_ENABLED: 'true',
      PLATFORM_DOMAIN_ZONE_ID: 'a'.repeat(32),
      PLATFORM_DOMAIN_PROVIDER_TOKEN: 'fake-token-'.repeat(3),
    }),
  )
})

test('Default-domain migration preserves reserved names and mappings owned by another Site', async () => {
  const mf = new Miniflare(
    convertV4MiniflareOptions({
      modules: true,
      script: 'export default {fetch(){return new Response("test")}}',
      compatibilityDate: '2026-10-22',
      d1Databases: ['DB'],
    }),
  )
  try {
    const db = await mf.getD1Database('DB')
    const apply = async (file: string) => {
      for (const q of splitSqlQuery(
        (
          await readFile('packages/platform/migrations/' + file, 'utf8')
        ).replace(/^--.*$/gm, ''),
      )
        .map((s) => s.trim())
        .filter(Boolean))
        await db.prepare(q).run()
    }
    const files = (await readdir('packages/platform/migrations'))
      .filter((f) => f.endsWith('.sql'))
      .sort()
    for (const file of files.filter((f) => f < '0013_custom_domains.sql'))
      await apply(file)
    await db
      .prepare("INSERT INTO platform_workspaces(id,name) VALUES(1,'Legacy')")
      .run()
    await db
      .prepare(
        "INSERT INTO platform_sites(id,workspace_id,name,published,slug) VALUES(1,1,'Reserved',1,'cname'),(2,1,'Collision',1,'timo'),(3,1,'Other',1,'other')",
      )
      .run()
    await db
      .prepare(
        "INSERT INTO platform_domains(hostname,site_id,verified,active) VALUES('cname.site.chronoframe.art',1,1,1),('timo.site.chronoframe.art',2,1,1),('timo.chronoframe.art',3,1,1)",
      )
      .run()
    await apply('0013_custom_domains.sql')
    assert.equal(
      await db
        .prepare(
          "SELECT hostname FROM platform_domains WHERE hostname='cname.chronoframe.art'",
        )
        .first(),
      null,
    )
    assert.equal(
      (
        await db
          .prepare(
            "SELECT site_id FROM platform_domains WHERE hostname='timo.chronoframe.art'",
          )
          .first()
      ).site_id,
      3,
    )
    assert.equal(
      (
        await db
          .prepare(
            "SELECT kind FROM platform_domains WHERE hostname='timo.site.chronoframe.art'",
          )
          .first()
      ).kind,
      'manual',
    )
    assert.equal(
      (await db.prepare('SELECT slug FROM platform_sites WHERE id=1').first())
        .slug,
      'cname',
    )
    assert.equal(
      (
        await db
          .prepare("SELECT site_id FROM platform_site_slugs WHERE slug='cname'")
          .first()
      ).site_id,
      1,
    )
  } finally {
    await mf.dispose()
  }
})

test('Workspace quotas preserve capacity for other tenants and audit failures roll back domain actions', async () => {
  const mf = new Miniflare(
    convertV4MiniflareOptions({
      modules: true,
      script: 'export default {fetch(){return new Response("test")}}',
      compatibilityDate: '2026-10-22',
      d1Databases: ['DB'],
    }),
  )
  try {
    const db = await mf.getD1Database('DB')
    for (const file of (await readdir('packages/platform/migrations'))
      .filter((f) => f.endsWith('.sql'))
      .sort())
      for (const q of splitSqlQuery(
        (
          await readFile('packages/platform/migrations/' + file, 'utf8')
        ).replace(/^--.*$/gm, ''),
      )
        .map((s) => s.trim())
        .filter(Boolean))
        await db.prepare(q).run()
    let time = Date.now()
    await db
      .prepare(
        'INSERT INTO platform_users(id,email,name,email_verified,created_at,updated_at) VALUES(1,?,?,1,?,?),(2,?,?,1,?,?)',
      )
      .bind(
        '[email protected]',
        'One',
        time,
        time,
        '[email protected]',
        'Two',
        time,
        time,
      )
      .run()
    await db
      .prepare(
        `UPDATE platform_plans SET policy_json=json_set(policy_json,'$.limits.sites',10,'$.limits.customDomains',4,'$.limits.byos',1) WHERE id='free'`,
      )
      .run()
    const sites = createD1Provisioning(db),
      claims = []
    for (let i = 0; i < 5; i++)
      claims.push(
        await sites.create(1, {
          name: 'Quota ' + i,
          slug: 'quota-' + i,
          requestId: crypto.randomUUID(),
        }),
      )
    const other = await sites.create(2, {
      name: 'Other',
      slug: 'fair-other',
      requestId: crypto.randomUUID(),
    })
    const provider = new Proxy(
      {},
      {
        get() {
          return () => {
            throw new Error('Unverified claims must not allocate resources')
          }
        },
      },
    ) as DomainProvider
    const manager = createDomainManager(
      db,
      {
        baseDomain: 'chronoframe.art',
        cnameTarget: 'cname.chronoframe.art',
        enabled: true,
        routingReady: true,
        limit: 20,
      },
      {
        provider,
        dns: async () => 'missing',
        id: () => crypto.randomUUID(),
        now: () => time,
      },
    )
    for (let i = 0; i < 4; i++)
      await manager.request(1, claims[i]!.siteId, 'quota-' + i + '.example.com')
    await assert.rejects(
      () => manager.request(1, claims[4]!.siteId, 'quota-4.example.com'),
      { code: 'domain_limit' },
    )
    // Filled provider reservations do not consume the separate unverified queue.
    for (let i = 0; i < 20; i++)
      await db
        .prepare(
          "INSERT INTO platform_custom_domains(hostname,site_id,generation,state,provider_attempted,created_at,expires_at,next_check_at) VALUES(?,?,?,'paused',1,?,?,?)",
        )
        .bind(
          'existing-' + i + '.example.com',
          claims[0]!.siteId,
          crypto.randomUUID(),
          time,
          time + 86400000,
          time,
        )
        .run()
    await manager.request(2, other.siteId, 'fair.example.com')
    const failAudit =
      "CREATE TRIGGER fail_domain_audit BEFORE INSERT ON platform_domain_audit BEGIN SELECT RAISE(ABORT,'audit unavailable'); END"
    await db.prepare(failAudit).run()
    await assert.rejects(
      () => manager.request(2, other.siteId, 'atomic.example.com'),
      /audit unavailable/,
    )
    assert.equal(
      await db
        .prepare(
          "SELECT hostname FROM platform_custom_domains WHERE hostname='atomic.example.com'",
        )
        .first(),
      null,
    )
    await db.prepare('DROP TRIGGER fail_domain_audit').run()
    const domain = await manager.request(2, other.siteId, 'atomic.example.com')
    await db.prepare(failAudit).run()
    await assert.rejects(
      () =>
        manager.mutate(
          2,
          other.siteId,
          domain.hostname,
          domain.generation,
          domain.revision,
          'pause',
        ),
      /audit unavailable/,
    )
    const unchanged = (await manager.list(2, other.siteId)).find(
      (d) => d.hostname === domain.hostname,
    )!
    assert.equal(unchanged.status, 'pending')
    assert.equal(unchanged.revision, domain.revision)
    await db.prepare('DROP TRIGGER fail_domain_audit').run()
    await manager.mutate(
      2,
      other.siteId,
      domain.hostname,
      domain.generation,
      domain.revision,
      'delete',
    )
    await db.prepare(failAudit).run()
    await manager.reconcile(domain.hostname)
    assert.equal(
      (await manager.list(2, other.siteId)).find(
        (d) => d.hostname === domain.hostname,
      )?.status,
      'deleting',
      'failed removal audit must not commit deleted state',
    )
    await db.prepare('DROP TRIGGER fail_domain_audit').run()
    time += 1800000
    await manager.reconcile(domain.hostname)
    assert.equal(
      (await manager.list(2, other.siteId)).find(
        (d) => d.hostname === domain.hostname,
      ),
      undefined,
    )
    assert.equal(
      (
        await db
          .prepare(
            "SELECT COUNT(*) AS n FROM platform_domain_audit WHERE hostname=? AND action='removed'",
          )
          .bind(domain.hostname)
          .first()
      ).n,
      1,
    )
    for (let i = 0; i < 5; i++)
      await db
        .prepare(
          'INSERT INTO platform_custom_domains(hostname,site_id,generation,state,created_at,expires_at,next_check_at) VALUES(?,?,?,?,?,?,?)',
        )
        .bind(
          'pending-' + i + '.example.com',
          claims[0]!.siteId,
          crypto.randomUUID(),
          i === 0 ? 'expired' : 'pending',
          time,
          time - 1,
          time,
        )
        .run()
    await assert.rejects(
      () => manager.request(2, other.siteId, 'queue-full.example.com'),
      { code: 'domain_limit' },
    )
    await db
      .prepare(
        "UPDATE platform_custom_domains SET state='deleted' WHERE hostname='pending-0.example.com'",
      )
      .run()
    const pausedClaim = await manager.request(
      2,
      other.siteId,
      'queue-full.example.com',
    )
    await manager.mutate(
      2,
      other.siteId,
      pausedClaim.hostname,
      pausedClaim.generation,
      pausedClaim.revision,
      'pause',
    )
    time += 49 * 3600000
    await manager.reconcile(pausedClaim.hostname)
    assert.equal(
      (await manager.list(2, other.siteId)).find(
        (d) => d.hostname === pausedClaim.hostname,
      ),
      undefined,
      'pausing an unverified claim cannot retain queue capacity beyond its expiry',
    )
  } finally {
    await mf.dispose()
  }
})