create-tanqory-theme 0.0.0-stage → 0.2.2

package/templates/nova/tests/cases/styles/Radius.cases.tsx

@@ -0,0 +1,10 @@
+import type { Meta, StoryObj } from '../../support/case'
+import * as pages from '../../support/foundation-pages'
+
+const meta = {
+  title: 'Nova/01 Styles/Radius',
+  parameters: { layout: 'fullscreen', },
+} satisfies Meta
+export default meta
+
+export const Overview: StoryObj = pages.Radius

package/templates/nova/tests/cases/styles/SharedThemeSettings.cases.tsx

@@ -0,0 +1,19 @@
+import type { Meta, StoryObj } from '../../support/case'
+import * as pages from '../../support/foundation-pages'
+import { SharedSettingsPage } from '../../support/ia-pages'
+
+/**
+ * Every shared setting in one place: the global theme settings (fonts, colours,
+ * radius, section spacing scale…) and the section-level settings every section
+ * shares (section width, content width, spacing, background, alignment…).
+ */
+const meta = {
+  title: 'Nova/01 Styles/Shared Theme Settings',
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta
+export default meta
+
+export const Playground: StoryObj = { ...(pages.ThemeSettings as StoryObj), name: 'Theme settings' }
+export const SectionSettings: StoryObj = { name: 'Section settings', render: () => <SharedSettingsPage /> }

package/templates/nova/tests/cases/styles/Spacing.cases.tsx

@@ -0,0 +1,10 @@
+import type { Meta, StoryObj } from '../../support/case'
+import * as pages from '../../support/foundation-pages'
+
+const meta = {
+  title: 'Nova/01 Styles/Spacing',
+  parameters: { layout: 'fullscreen', },
+} satisfies Meta
+export default meta
+
+export const Overview: StoryObj = pages.Spacing

package/templates/nova/tests/cases/styles/Typography.cases.tsx

@@ -0,0 +1,10 @@
+import type { Meta, StoryObj } from '../../support/case'
+import * as pages from '../../support/foundation-pages'
+
+const meta = {
+  title: 'Nova/01 Styles/Typography',
+  parameters: { layout: 'fullscreen', },
+} satisfies Meta
+export default meta
+
+export const Overview: StoryObj = pages.Typography

package/templates/nova/tests/cases.test.tsx

@@ -0,0 +1,38 @@
+/**
+ * Every case, rendered and PLAYED in jsdom, then checked with axe for serious
+ * and critical violations.
+ *
+ * Cases tagged `browser-only` need real layout (measured overflow, computed
+ * sizes, visibility via CSS) and are skipped here.
+ */
+import { describe, expect, it } from 'vitest'
+import axe from 'axe-core'
+import { casesOf, runCase, type CaseModule } from './support/case'
+import { withNova } from './support/with-nova'
+
+const modules = import.meta.glob('./cases/**/*.cases.tsx', { eager: true }) as Record<string, CaseModule>
+
+// jsdom has no layout or CSS: rules that need either are skipped.
+// jsdom never loads media, so axe must not wait for <video> (preload: false).
+// iframes: false — jsdom cannot host axe inside a frame; the account slot's frame is the platform's page, not the theme's.
+const AXE_JSDOM = { preload: false, iframes: false, rules: { 'color-contrast': { enabled: false }, region: { enabled: false }, 'target-size': { enabled: false } } }
+
+it('finds the cases', () => {
+  expect(Object.keys(modules).length).toBeGreaterThan(50)
+})
+
+for (const [file, mod] of Object.entries(modules)) {
+  describe(file.replace('./cases/', ''), () => {
+    for (const [name, story] of casesOf(mod)) {
+      const tags = [...(mod.default.tags ?? []), ...(story.tags ?? [])]
+      const run = tags.includes('browser-only') ? it.skip : it
+      run(story.name ?? name, async () => {
+        document.body.innerHTML = ''
+        await runCase(mod, story, withNova)
+        const results = await axe.run(document.body, AXE_JSDOM)
+        const serious = results.violations.filter((v) => v.impact === 'serious' || v.impact === 'critical')
+        expect(serious.map((v) => `${v.id}: ${v.nodes.map((n) => n.target.join(' ')).slice(0, 3).join(' | ')}`)).toEqual([])
+      })
+    }
+  })
+}

package/templates/nova/tests/components/PromoPopup.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+import { mayShowPopup, type PopupScheduleInput } from '../../src/components/overlays/PromoPopup'
+
+const base: PopupScheduleInput = { enabled: true, consentAnswered: true, pageType: 'index', shownThisSession: false, lastDismissed: null, frequency: '7d', now: Date.UTC(2026, 8, 29) }
+const DAY = 86_400_000
+
+describe('promotion popup behaviour (Nova 13 · 9)', () => {
+  it('is off unless enabled', () => expect(mayShowPopup({ ...base, enabled: false })).toBe(false))
+  it('never before consent is answered', () => expect(mayShowPopup({ ...base, consentAnswered: false })).toBe(false))
+  it('never twice in a session', () => expect(mayShowPopup({ ...base, shownThisSession: true })).toBe(false))
+  it('never on cart or checkout', () => {
+    expect(mayShowPopup({ ...base, pageType: 'cart' })).toBe(false)
+    expect(mayShowPopup({ ...base, pageType: 'checkout' })).toBe(false)
+  })
+  it('respects the frequency window after a dismissal', () => {
+    expect(mayShowPopup({ ...base, lastDismissed: base.now - 3 * DAY })).toBe(false)
+    expect(mayShowPopup({ ...base, lastDismissed: base.now - 8 * DAY })).toBe(true)
+    expect(mayShowPopup({ ...base, frequency: '30d', lastDismissed: base.now - 8 * DAY })).toBe(false)
+  })
+  it('"next visit" ignores the stored dismissal (session only)', () => expect(mayShowPopup({ ...base, frequency: 'session', lastDismissed: base.now - DAY })).toBe(true))
+})

package/templates/nova/tests/components/RichText.test.tsx

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { RichText, isolateParagraphs } from '../../src/components/content/RichText'
+import { LongForm } from '../../src/components/content/LongForm'
+import { BadgeBlock } from '../../src/components/commerce/blocks/Badge'
+
+// Merchant text keeps its own direction via <bdi>; the paragraph keeps the page's.
+describe('merchant rich text isolates each paragraph', () => {
+  it('wraps the text of each text block, keeping its attributes', () => {
+    expect(isolateParagraphs('<p class="a">Halden &amp; Co.</p><h3>Care</h3>')).toBe('<p class="a"><bdi>Halden &amp; Co.</bdi></p><h3><bdi>Care</bdi></h3>')
+  })
+  it('leaves a block that contains another block to its child', () => {
+    expect(isolateParagraphs('<li>One<ul><li>Two</li></ul></li>')).not.toContain('<li><bdi>One<ul>')
+  })
+  it('long-form pages (articles, policies, size guides) isolate the same way', () => {
+    const html = renderToStaticMarkup(<LongForm html="<ol><li>Measure the insert.</li></ol><table><tr><td>90–100 cm</td></tr></table>" />)
+    expect(html).toContain('<li><bdi>Measure the insert.</bdi></li>')
+    expect(html).toContain('<td><bdi>90–100 cm</bdi></td>')
+  })
+  it('plain text and as="p" render inside one <bdi>', () => {
+    expect(renderToStaticMarkup(<RichText html="Made in Chiang Mai." />)).toBe('<div class="nv-prose"><p><bdi>Made in Chiang Mai.</bdi></p></div>')
+    expect(renderToStaticMarkup(<RichText as="p" html="<em>Hand</em>-glazed." />)).toBe('<p class="nv-prose"><bdi><em>Hand</em>-glazed.</bdi></p>')
+  })
+})
+
+// A page-wide unicode-bidi rule flipped the theme's own strings and bare numbers
+// to LTR on Arabic pages ("English غير متاحة…", a tab count "١٢"). Scope stays in the markup.
+it('no stylesheet sets unicode-bidi page-wide', () => {
+  expect(readFileSync(join(__dirname, '../../src/styles/base.css'), 'utf8')).not.toMatch(/unicode-bidi\s*:\s*plaintext/)
+})
+
+// <bdi> isolates ONE run of merchant text. Wrapped around JSX it turns separate
+// grid rows into one inline run: the badge block's label and detail rendered as
+// "Free shippingOver $120" on every page. Every <bdi> in src must hold a string.
+it('every <bdi> in the theme wraps text, never elements', () => {
+  const ts = require('typescript') as typeof import('typescript')
+  const root = join(__dirname, '../..')
+  const cfg = ts.getParsedCommandLineOfConfigFile(join(root, 'tsconfig.json'), {}, { ...ts.sys, onUnRecoverableConfigFileDiagnostic: () => {} })!
+  const program = ts.createProgram(cfg.fileNames.filter((f) => f.includes('/src/')), cfg.options)
+  const checker = program.getTypeChecker()
+  const bad: string[] = []
+  for (const sf of program.getSourceFiles()) {
+    if (!sf.fileName.startsWith(join(root, 'src'))) continue
+    const visit = (n: import('typescript').Node): void => {
+      if (ts.isJsxElement(n) && n.openingElement.tagName.getText(sf) === 'bdi')
+        for (const c of n.children) {
+          if (ts.isJsxElement(c) || ts.isJsxSelfClosingElement(c) || ts.isJsxFragment(c)) bad.push(`${sf.fileName.slice(root.length + 1)}: element inside <bdi>`)
+          if (!ts.isJsxExpression(c) || !c.expression) continue
+          const t = checker.getTypeAtLocation(c.expression)
+          const text = (t.isUnion() ? t.types : [t]).every((p) => p.flags & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.BooleanLiteral))
+          if (!text) bad.push(`${sf.fileName.slice(root.length + 1)}: {${c.expression.getText(sf)}} is ${checker.typeToString(t)}`)
+        }
+      ts.forEachChild(n, visit)
+    }
+    visit(sf)
+  }
+  expect(bad).toEqual([])
+}, 60_000)
+
+it('the badge block keeps label and detail as separate rows', () => {
+  const html = renderToStaticMarkup(<BadgeBlock icon="truck" label="Free shipping" detail="2–4 days" link="" />)
+  expect(html).toContain('<span class="nv-pdp-badge__label"><bdi>Free shipping</bdi></span><span class="nv-pdp-badge__detail"><bdi>2–4 days</bdi></span>')
+})

package/templates/nova/tests/components/formatDate.test.ts

@@ -0,0 +1,10 @@
+import { expect, it } from 'vitest'
+import { formatDate } from '../../src/components/content/ArticleCard'
+
+// The storefront API sends full ISO timestamps; the helper once only took
+// YYYY-MM-DD and printed "2026-09-30T15:52:56.631Z" on every live blog card.
+it('formats the API timestamp as a date, and a plain date the same way', () => {
+  expect(formatDate('2026-09-30T15:52:56.631Z', 'en')).toBe('Sep 30, 2026')
+  expect(formatDate('2026-09-30', 'en')).toBe('Sep 30, 2026')
+  expect(formatDate('not a date', 'en')).toBe('not a date')
+})

package/templates/nova/tests/contract-locks.test.ts

@@ -0,0 +1,23 @@
+import { createHash } from 'node:crypto'
+import { readFileSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+
+/**
+ * .tanqory/contracts is compiler-managed: `tanqory-theme contracts` writes the
+ * locks and records each one's sha256 in LOCK.json. A lock that no longer
+ * matches its hash was edited by hand.
+ */
+const DIR = join(__dirname, '..', '.tanqory', 'contracts')
+const lock = JSON.parse(readFileSync(join(DIR, 'LOCK.json'), 'utf8')) as { files: Record<string, { sha256: string; design: string; family: string }> }
+const sha256 = (text: string) => createHash('sha256').update(text).digest('hex')
+
+describe('contract locks are compiler-managed', () => {
+  it('every lock matches the hash the compiler recorded (no hand edits)', () => {
+    for (const [name, f] of Object.entries(lock.files)) expect(sha256(readFileSync(join(DIR, name), 'utf8')), name).toBe(f.sha256)
+  })
+  it('every lock is listed in LOCK.json, and every listed lock exists', () => {
+    const onDisk = readdirSync(DIR).filter((f) => f.endsWith('.json') && f !== 'LOCK.json').sort()
+    expect(onDisk).toEqual(Object.keys(lock.files).sort())
+  })
+})

package/templates/nova/tests/contracts.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest'
+import { defineSchema, field, type Schema } from '@tanqory/theme-kit'
+import { formatReport, validateContracts, type IssueCode } from '../scripts/compiler/contracts/validate'
+import { VALIDATION_INPUT } from './support/contracts'
+import { dividerSchema } from '../src/sections/Divider/schema'
+import { footerSchema } from '../src/sections/Footer/schema'
+import { groupSchema } from '../src/sections/Group/schema'
+import { headerSchema } from '../src/sections/Header/schema'
+import { announcementBarSchema } from '../src/sections/AnnouncementBar/schema'
+import { breadcrumbsSchema } from '../src/sections/Breadcrumbs/schema'
+import { heroSchema } from '../src/sections/Hero/schema'
+import { marqueeSchema } from '../src/sections/Marquee/schema'
+import { videoHeroSchema } from '../src/sections/VideoHero/schema'
+
+describe('Design → Code contract', () => {
+  it('has no drift for the implemented families', () => {
+    const report = validateContracts(VALIDATION_INPUT)
+    if (report.issues.length) console.error(formatReport(report))
+    expect(report.issues).toEqual([])
+    expect(report.checked.sections).toBe(49)
+    expect(report.checked.presets).toBeGreaterThanOrEqual(117)
+  })
+
+  it('checks global settings (Nova 13 popup) against the contract', () => {
+    const drifted = defineSchema({ kind: 'global', name: 'popup', family: '13' }, { popupEnabled: field.boolean(true) })
+    const report = validateContracts({ ...VALIDATION_INPUT, globals: [drifted] })
+    const codes = report.issues.filter((i) => i.where === 'global:13').map((i) => i.code)
+    expect(codes).toContain('invalid-default') // popupEnabled must default to off
+    expect(codes).toContain('missing-prop') // popupPreset … popupFrequency
+    expect(report.issues.some((i) => i.where.startsWith('preset:popup-'))).toBe(true)
+  })
+})
+
+/**
+ * A green gate is not proof. Each case breaks the code side in one specific
+ * way and asserts the validator names it — so "no drift" above means something.
+ */
+describe('the validator catches every drift class', () => {
+  const run = (sections: readonly Schema[], blocks = VALIDATION_INPUT.blocks) => validateContracts({ ...VALIDATION_INPUT, sections, blocks, accepted: [] })
+  const codes = (sections: readonly Schema[], blocks?: readonly Schema[]) => new Set(run(sections, blocks).issues.map((i) => i.code))
+  const others = VALIDATION_INPUT.sections.filter((s) => s.name !== 'header')
+  const withHeader = (fields: Record<string, unknown>) => [...others, { ...headerSchema, fields } as Schema]
+  const expectCode = (code: IssueCode, sections: readonly Schema[], blocks?: readonly Schema[]) => expect(codes(sections, blocks)).toContain(code)
+
+  it('missing-section', () => expectCode('missing-section', others))
+
+  it('a block renamed after the contract was locked is checked under its old name (legacyNames), and only then', () => {
+    const footerFree = VALIDATION_INPUT.sections.filter((s) => s.name !== 'footer' && s.name !== 'group')
+    const blocks = VALIDATION_INPUT.blocks
+    const nl = blocks.find((b) => b.name === 'newsletter-signup')!
+    expect(nl.legacyNames).toEqual(['newsletter'])
+    // Without the alias the new name has no contract block, and the contract's `newsletter` is not accepted.
+    const bare = { ...nl, legacyNames: undefined } as Schema
+    const issues = run(VALIDATION_INPUT.sections, [...blocks.filter((b) => b !== nl), bare]).issues
+    expect(issues.some((i) => i.code === 'invalid-block' && i.where === 'block:newsletter-signup@footer')).toBe(true)
+    expect(issues.some((i) => i.code === 'invalid-block' && i.where === 'preset:footer-newsletter')).toBe(true)
+    // With it, the renamed block's fields are still compared with the contract rows.
+    const drifted = { ...nl, fields: { ...nl.fields, invented: field.boolean(false) } } as Schema
+    expect(run([...footerFree, footerSchema, groupSchema], [...blocks.filter((b) => b !== nl), drifted]).issues.some((i) => i.code === 'extra-prop' && i.where === 'block:newsletter-signup@footer')).toBe(true)
+  })
+
+  it('missing-prop', () => {
+    const { showCart: _drop, ...rest } = headerSchema.fields
+    expectCode('missing-prop', withHeader(rest))
+  })
+
+  it('extra-prop (no contract row, no extension reason)', () => expectCode('extra-prop', withHeader({ ...headerSchema.fields, invented: field.boolean(false) })))
+
+  it('unknown-option', () => expectCode('unknown-option', withHeader({ ...headerSchema.fields, layout: field.select(['logo-left', 'logo-center', 'logo-right'], 'logo-left') })))
+
+  it('missing-option', () => expectCode('missing-option', withHeader({ ...headerSchema.fields, sticky: field.select(['always', 'none'], 'always') })))
+
+  it('display labels instead of persisted IDs are caught', () => {
+    const labels = field.select(['Always', 'When scrolling up', 'Off'], 'Always')
+    const c = codes(withHeader({ ...headerSchema.fields, sticky: labels }))
+    expect(c).toContain('unknown-option')
+    expect(c).toContain('missing-option')
+  })
+
+  it('invalid-default', () => expectCode('invalid-default', withHeader({ ...headerSchema.fields, menuStyle: field.select(['simple', 'mega'], 'simple') })))
+
+  it('control-mismatch', () => expectCode('control-mismatch', withHeader({ ...headerSchema.fields, logo: field.resource('image') })))
+
+  it('unsupported-legacy: a LEGACY-HIDDEN row exposed as a normal control', () => expectCode('unsupported-legacy', withHeader({ ...headerSchema.fields, bg: field.color('') })))
+
+  it('unsupported-legacy: a legacy option value left unmapped', () => {
+    const bar = { ...announcementBarSchema, fields: { ...announcementBarSchema.fields, background: field.select(['muted', 'inverse', 'brand'], 'muted') } }
+    expectCode('unsupported-legacy', [...VALIDATION_INPUT.sections.filter((s) => s.name !== 'announcement-bar'), bar])
+  })
+
+  it('duplicated-setting: two visible fields for one semantic', () => {
+    expectCode('duplicated-setting', withHeader({ ...headerSchema.fields, bg: field.color('', { semantic: 'background' }) }))
+  })
+
+  it('duplicated-setting: exposing a shared prop the section overrides', () => {
+    const divider = { ...dividerSchema, fields: { ...dividerSchema.fields, sectionWidth: field.select(['standard', 'wide', 'full'], 'wide') } }
+    expectCode('duplicated-setting', [...VALIDATION_INPUT.sections.filter((s) => s.name !== 'divider'), divider])
+  })
+
+  it('shared-applicability: a shared setting that APPLIES is missing', () => {
+    const { background: _b, ...rest } = breadcrumbsSchema.fields
+    const bc = { ...breadcrumbsSchema, fields: rest }
+    expectCode('shared-applicability', [...VALIDATION_INPUT.sections.filter((s) => s.name !== 'breadcrumbs'), bc])
+  })
+
+  it('invalid-preset: a preset value that is no longer an option', () => {
+    // footer-minimal sets layout "centered"; drop that option.
+    const footer = { ...footerSchema, fields: { ...footerSchema.fields, layout: field.select(['columns'], 'columns') } }
+    const r = run([...VALIDATION_INPUT.sections.filter((s) => s.name !== 'footer'), footer])
+    expect(r.issues.some((i) => i.code === 'invalid-preset' && i.where === 'preset:footer-minimal')).toBe(true)
+  })
+
+  it('invalid-block: the section stops accepting a contract block', () => {
+    const group = { ...groupSchema, blocks: groupSchema.blocks!.filter((b) => b !== 'icon') }
+    const r = run([...VALIDATION_INPUT.sections.filter((s) => s.name !== 'group'), group])
+    expect(r.issues.some((i) => i.code === 'invalid-block' && i.key === 'icon')).toBe(true)
+  })
+
+  it('missing-block: an accepted block has no schema', () => {
+    expectCode('missing-block', VALIDATION_INPUT.sections, VALIDATION_INPUT.blocks.filter((b) => b.name !== 'jumbo-text'))
+  })
+
+  it('invalid-range', () => {
+    const icon = VALIDATION_INPUT.blocks.find((b) => b.name === 'icon')!
+    const bad = defineSchema({ ...icon }, { ...icon.fields, size: field.range(32, 16, 64, 4) })
+    expectCode('invalid-range', VALIDATION_INPUT.sections, [...VALIDATION_INPUT.blocks.filter((b) => b.name !== 'icon'), bad])
+  })
+
+  // 12B+ families carry no shared rows of their own: the 12A vocabulary applies.
+  const without = (name: string, s: Schema) => [...VALIDATION_INPUT.sections.filter((x) => x.name !== name), s]
+
+  it('shared-applicability (12B): an APPLIES setting is missing', () => {
+    const { anchorId: _a, ...rest } = heroSchema.fields
+    expectCode('shared-applicability', without('hero', { ...heroSchema, fields: rest } as Schema))
+  })
+
+  it('shared-applicability (12B): an APPLIES setting drops the 12A vocabulary', () => {
+    expectCode('shared-applicability', without('hero', { ...heroSchema, fields: { ...heroSchema.fields, sectionWidth: field.select(['standard', 'wide'], 'wide') } } as Schema))
+  })
+
+  it('shared-applicability (12B): a NOT APPLICABLE setting is exposed', () => {
+    expectCode('shared-applicability', without('marquee', { ...marqueeSchema, fields: { ...marqueeSchema.fields, spacingTop: field.select(['none', 'small', 'medium', 'large', 'xl'], 'none') } } as Schema))
+  })
+
+  it('duplicated-setting (12B): exposing a shared prop the section overrides', () => {
+    // video-hero.contentAlignment is OVERRIDDEN by video-hero.contentPosition.
+    expectCode('duplicated-setting', without('video-hero', { ...videoHeroSchema, fields: { ...videoHeroSchema.fields, contentAlignment: field.select(['left', 'center'], 'left') } } as Schema))
+  })
+
+  it('unsupported-legacy (12B): video-hero.soundButtonUrl exposed as a normal control', () => {
+    expectCode('unsupported-legacy', without('video-hero', { ...videoHeroSchema, fields: { ...videoHeroSchema.fields, soundButtonUrl: field.url('') } } as Schema))
+  })
+})

package/templates/nova/tests/cookie-consent-privacy.test.tsx

@@ -0,0 +1,128 @@
+/**
+ * The cookie banner's privacy policy link (QA run-4): it named /policies/privacy-policy on every
+ * store, a dead end while the merchant had not published that policy. The banner now links it only
+ * when the store has a published privacy policy — known from the page (the policy's own route) or
+ * asked once through the ABI wire (`content.policy`) when the banner shows.
+ */
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, describe, expect, it } from 'vitest'
+import { setThemeBundle } from '@tanqory/theme-kit/runtime'
+import { sectionModules } from '@tanqory/theme-kit/runtime'
+import { registerSections } from '@tanqory/theme-kit/runtime'
+import { SectionTree } from '@tanqory/theme-kit/runtime'
+import { DataProvider } from '@tanqory/theme-kit/runtime'
+import { ThemeProvider } from '@tanqory/theme-kit/runtime'
+import { localeStrings } from '@tanqory/theme-kit/runtime'
+import { bundle } from '../lib/bundle'
+import { AbiShell } from '@tanqory/theme-kit/runtime'
+import { AbiCartProvider } from '@tanqory/theme-kit/runtime'
+import { AbiWireError, type AbiRemote } from '@tanqory/theme-kit/runtime'
+import { createDataApi } from '@tanqory/theme-kit/runtime'
+import type { PageData } from '@tanqory/theme-kit/runtime'
+
+setThemeBundle(bundle)
+registerSections(Object.values(sectionModules()).map((m) => m.default))
+
+const LOCALES = Object.fromEntries(
+  Object.entries(bundle.locales).map(([path, mod]) => [path.match(/\/([^/]+)\.json$/)?.[1] ?? 'en', (mod as { default: Record<string, string> }).default]),
+)
+
+const PRIVACY = { handle: 'privacy-policy', title: 'Privacy policy', url: 'https://demo.example/policies/privacy-policy', body: '<p>How we handle your data.</p>' }
+
+const pageData = (policies: Record<string, unknown> = {}) =>
+  ({
+    route: 'index',
+    shop: { name: 'Demo', description: null, brand: null, policies, primaryDomain: { host: 'demo.example', url: 'https://demo.example', sslEnabled: true } },
+    menus: {}, products: {}, collections: {}, collectionList: null, pages: {}, blogs: {}, articles: {},
+    search: null, listingSeed: null, recommendations: {}, policyHandle: null, accountUrls: null, cart: null,
+    localization: { country: { isoCode: 'TH', name: 'Thailand', currency: { isoCode: 'THB', name: 'Thai Baht', symbol: '฿' } }, language: { isoCode: 'EN', name: 'English' }, availableCountries: [], availableLanguages: [] },
+    signedIn: null, unresolved: [], routeMissing: false,
+  }) as unknown as PageData
+
+/** A host whose consent readout asks for the banner, and whose `content.policy` answers `privacy`. */
+function hostWith(privacy: unknown) {
+  const calls: string[] = []
+  const remote: AbiRemote = {
+    async data(op) {
+      calls.push(op)
+      if (op === 'consent.get') return { known: false, analytics: false, marketing: false, functional: true, bannerRequired: true }
+      if (op === 'content.policy') return privacy
+      throw new AbiWireError(404, 'unknown_op')
+    },
+    async action() {
+      return { ok: true, data: null, dataVersion: '1' }
+    },
+  }
+  return { remote, calls }
+}
+
+let root: Root | null = null
+let host: HTMLElement | null = null
+function unmount(): void {
+  act(() => root?.unmount())
+  host?.remove()
+  root = host = null
+}
+afterEach(unmount)
+
+async function mount(pd: PageData, remote: AbiRemote): Promise<HTMLElement> {
+  unmount()
+  host = document.body.appendChild(document.createElement('div'))
+  root = createRoot(host)
+  act(() =>
+    root!.render(
+      <DataProvider value={createDataApi(pd, remote)}>
+        <ThemeProvider settings={{}} locale={localeStrings('en', LOCALES)}>
+          <AbiCartProvider initial={null} remote={null}>
+            <AbiShell location="/" locale="en" settings={{}} preview={false}>
+              <SectionTree tree={[]} />
+            </AbiShell>
+          </AbiCartProvider>
+        </ThemeProvider>
+      </DataProvider>,
+    ),
+  )
+  await act(() => new Promise((r) => setTimeout(r, 30)))
+  return host
+}
+
+const banner = (el: HTMLElement) => el.querySelector<HTMLElement>('.nv-consent')
+
+describe('cookie banner privacy policy link', () => {
+  it('has no privacy policy link while the store has not published one', async () => {
+    const { remote, calls } = hostWith(null)
+    const el = await mount(pageData(), remote)
+    expect(banner(el)).not.toBeNull()
+    expect(banner(el)!.querySelector('a')).toBeNull()
+    expect(el.querySelector('a[href*="/policies/privacy-policy"]')).toBeNull()
+    expect(calls.filter((c) => c === 'content.policy')).toHaveLength(1)
+  })
+
+  it('links the privacy policy once the platform answers it is published', async () => {
+    const el = await mount(pageData(), hostWith(PRIVACY).remote)
+    expect(banner(el)!.querySelector('a')?.getAttribute('href')).toBe('/policies/privacy-policy')
+  })
+
+  it('links it without asking again when the page already carries the published policy', async () => {
+    const { remote, calls } = hostWith(null)
+    const el = await mount(pageData({ privacy: PRIVACY }), remote)
+    expect(banner(el)!.querySelector('a')?.getAttribute('href')).toBe('/policies/privacy-policy')
+    expect(calls).not.toContain('content.policy')
+  })
+
+  it('has no link when the lookup fails', async () => {
+    const remote: AbiRemote = {
+      async data(op) {
+        if (op === 'consent.get') return { known: false, analytics: false, marketing: false, functional: true, bannerRequired: true }
+        throw new AbiWireError(403, 'capability_denied')
+      },
+      async action() {
+        return { ok: true, data: null, dataVersion: '1' }
+      },
+    }
+    const el = await mount(pageData(), remote)
+    expect(banner(el)).not.toBeNull()
+    expect(banner(el)!.querySelector('a')).toBeNull()
+  })
+})

package/templates/nova/tests/empty-store.test.tsx

@@ -0,0 +1,81 @@
+/**
+ * A brand-new store: no products, no collections, no pages, no policies, and the theme's own
+ * starter content. Every page a shopper can reach from that starter must say something — never a
+ * blank main, never a link to a page the store does not have.
+ */
+import { readFileSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { render } from '@testing-library/react'
+import type { ComponentProps } from 'react'
+import { describe, expect, it } from 'vitest'
+import { NovaProvider } from '../src/styles/NovaProvider'
+import { CollectionList } from '../src/sections/CollectionList/CollectionList'
+import { PolicyPage } from '../src/sections/PolicyPage/PolicyPage'
+import { toLocalization } from '@tanqory/theme-kit/runtime'
+
+interface Node { settings?: Record<string, unknown>; blocks?: Node[] }
+const dir = (d: string) => join(__dirname, '..', d)
+const docs = ['templates', 'groups'].flatMap((d) =>
+  readdirSync(dir(d)).filter((f) => f.endsWith('.json')).map((f) => ({ name: `${d}/${f}`, doc: JSON.parse(readFileSync(join(dir(d), f), 'utf8')) as { sections?: Node[]; groups?: Record<string, unknown> } })),
+)
+const links: string[] = []
+const walk = (nodes: unknown, where: string) => {
+  if (!Array.isArray(nodes)) return
+  for (const n of nodes as Node[]) {
+    for (const [key, v] of Object.entries(n.settings ?? {})) if (/link$|url$/i.test(key) && typeof v === 'string' && v.startsWith('/')) links.push(`${where} ${key}=${v}`)
+    walk(n.blocks, where)
+  }
+}
+for (const { name, doc } of docs) {
+  walk(doc.sections, name)
+  for (const g of Object.values(doc.groups ?? {})) walk((g as { override?: unknown })?.override, name)
+}
+
+/** Routes every store has: only the `all` collection is guaranteed among resources. */
+const ALWAYS = /^\/($|collections(\/all)?$|search$|cart$|account)/
+
+describe('empty store', () => {
+  it("a one-market store shows no locale control, whatever the visitor's own country is", () => {
+    const th = { isoCode: 'TH', name: 'Thailand', currency: { isoCode: 'THB' }, market: null }
+    const us = { isoCode: 'US', name: 'United States', currency: { isoCode: 'USD' }, market: null }
+    const en = { isoCode: 'en', name: 'English' }
+    const one = toLocalization({ country: us, availableCountries: [th], language: en, availableLanguages: [en] } as never)!
+    expect(one.available.map((m) => m.countryCode)).toEqual(['TH'])
+    expect(one.current.countryCode).toBe('TH')
+    const two = toLocalization({ country: us, availableCountries: [th, us], language: en, availableLanguages: [en] } as never)!
+    expect(two.current.countryCode).toBe('US')
+    expect(two.available.map((m) => m.countryCode)).toEqual(['TH', 'US'])
+  })
+
+  it('starter content links only to routes every store has', () => {
+    expect(links.filter((l) => !ALWAYS.test(l.split('=')[1]!))).toEqual([])
+  })
+
+  it('the collections page with no collections says so and offers the catalog', () => {
+    const { container } = render(
+      <NovaProvider>
+        <CollectionList {...({ heading: 'Collections', pageHeading: true, limit: 12, items: [], fallbackCollections: [] } as unknown as ComponentProps<typeof CollectionList>)} />
+      </NovaProvider>,
+    )
+    expect(container.textContent).toContain('There are no collections here yet')
+    expect(container.querySelector('a[href="/collections/all"]')).not.toBeNull()
+  })
+
+  it('a collection list on a page that is not the collections page still renders nothing when empty', () => {
+    const { container } = render(
+      <NovaProvider>
+        <CollectionList {...({ heading: 'Shop by collection', pageHeading: false, limit: 4, items: [], fallbackCollections: [] } as unknown as ComponentProps<typeof CollectionList>)} />
+      </NovaProvider>,
+    )
+    expect(container.textContent).toBe('')
+  })
+
+  it('a live policy route the store has not published shows the message, not a blank page', () => {
+    const { container } = render(
+      <NovaProvider>
+        <PolicyPage {...({ policy: '', content: null } as unknown as ComponentProps<typeof PolicyPage>)} />
+      </NovaProvider>,
+    )
+    expect(container.textContent).toContain("This policy hasn't been published yet.")
+  })
+})