@thorprovider/storefront 0.3.1

package/bin/storefront.js

@@ -0,0 +1,531 @@
+#!/usr/bin/env node
+// @thorprovider/storefront — CLI
+// Deterministic storefront scaffolder + installable OpenCode command suite.
+//
+// Actions:
+//   create    Scaffold a complete, runnable storefront AND install the command suite
+//   update    Refresh an existing install (prunes removed files, migrates the record)
+//   doctor    Report the recorded version and whether the installed skills match this package
+//
+// On a TTY, `create` prompts for missing inputs (name, site name, backend URL, preset —
+// Maia is preselected). Without a TTY, every required input must be a flag; the command
+// fails fast and writes nothing rather than guessing. Brand color is never prompted.
+//
+// The package's generated copies are verified against their source before anything is
+// copied into a target project. On divergence the command stops and writes nothing.
+
+import { cp, mkdir, readdir, readFile, writeFile, rm } from 'node:fs/promises'
+import { existsSync, readFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { spawnSync } from 'node:child_process'
+import { dirname, join, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { cancel, intro, isCancel, outro, select, text } from '@clack/prompts'
+import { checkAssets } from '../scripts/sync-assets.mjs'
+import { renderScaffold, toKebab } from '../scripts/render-templates.mjs'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const PKG_ROOT = resolve(__dirname, '..')
+
+const VERSION_RECORD_FILE = 'storefront.json'
+const LEGACY_RECORD_FILE = '.create-storefront.json'
+const COPY_DIRS = ['commands', 'skills']
+// Files that shipped in earlier versions and are no longer part of the suite.
+// `update` prunes them so an upgraded project does not keep running the
+// eliminated /sf-init scaffold wizard.
+const PRUNED_PATHS = ['commands/sf-init.md', 'skills/sf-scaffold']
+
+const PRESETS = ['maia', 'nova', 'vega', 'luma', 'lyra', 'mira']
+const PRESET_LABELS = {
+  maia: 'Rounded and spacious. Warm and approachable — fits a store.',
+  nova: 'Compact and balanced. The neutral default.',
+  vega: 'The classic shadcn look. Polished, modern.',
+  luma: 'Very rounded and airy. Soft and premium.',
+  lyra: 'Square corners and minimal. Geometric and strict.',
+  mira: 'Very dense. For lots of information on screen.',
+}
+const DEFAULT_BACKEND_URL = 'http://localhost:9000'
+
+const HELP = `@thorprovider/storefront — scaffold Thor Commerce storefronts
+
+Usage:
+  storefront create <dir> [options]   Scaffold a storefront and install the suite
+  storefront <update|doctor> <dir>    Manage an existing install
+
+create options:
+  --name <name>        storefront name = lib/<name>/ (required without a terminal)
+  --site-name <name>   human site name                 (default: <name>)
+  --backend-url <url>  Medusa backend URL              (default: http://localhost:9000)
+  --preset <preset>    maia | nova | vega | luma | lyra | mira (required without a terminal)
+  --brand <color>      brand color over preset tokens  (not prompted by the wizard)
+  -f, --force          overwrite files that already exist
+  -h, --help           show this help
+
+In a terminal, create prompts for missing inputs (Maia is preselected).
+Without a terminal, every required input must be a flag — the command fails fast.
+`
+
+function parseArgs(argv) {
+  const out = {
+    action: null,
+    dir: null,
+    name: null,
+    siteName: null,
+    backendUrl: null,
+    preset: null,
+    brand: null,
+    force: false,
+    help: false,
+  }
+  const positionals = []
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '--name') {
+      out.name = argv[++i]
+    } else if (arg === '--site-name') {
+      out.siteName = argv[++i]
+    } else if (arg === '--backend-url') {
+      out.backendUrl = argv[++i]
+    } else if (arg === '--preset') {
+      out.preset = argv[++i]
+    } else if (arg === '--brand') {
+      out.brand = argv[++i]
+    } else if (arg === '--force' || arg === '-f') {
+      out.force = true
+    } else if (arg === '--help' || arg === '-h') {
+      out.help = true
+    } else if (arg.startsWith('-')) {
+      console.error(`Unknown option: ${arg}`)
+      process.exitCode = 1
+      return null
+    } else {
+      positionals.push(arg)
+    }
+  }
+  out.action = positionals[0] ?? null
+  if (positionals[1]) out.dir = resolve(positionals[1])
+  else if (!out.dir) out.dir = process.cwd()
+  return out
+}
+
+async function copyDir(from, to, force) {
+  const entries = await readdir(from, { withFileTypes: true })
+  let copied = 0
+  for (const entry of entries) {
+    const src = join(from, entry.name)
+    const dest = join(to, entry.name)
+    if (entry.isDirectory()) {
+      await mkdir(dest, { recursive: true })
+      copied += await copyDir(src, dest, force)
+    } else {
+      if (existsSync(dest) && !force) continue
+      await mkdir(to, { recursive: true })
+      await cp(src, dest)
+      copied++
+    }
+  }
+  return copied
+}
+
+async function prunePath(opencodeDir, relPath) {
+  await rm(join(opencodeDir, relPath), { recursive: true, force: true })
+}
+
+function sha256(text) {
+  return createHash('sha256').update(text).digest('hex')
+}
+
+async function hashDir(dir) {
+  const files = []
+  async function walk(d) {
+    for (const entry of await readdir(d, { withFileTypes: true })) {
+      const full = join(d, entry.name)
+      if (entry.isDirectory()) await walk(full)
+      else files.push(full)
+    }
+  }
+  if (existsSync(dir)) await walk(dir)
+  files.sort()
+  const lines = []
+  for (const f of files) {
+    lines.push(`${relative(dir, f)}:${sha256(await readFile(f, 'utf8'))}`)
+  }
+  return sha256(lines.join('\n'))
+}
+
+function pkgVersion() {
+  const pkg = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8'))
+  return pkg.version
+}
+
+async function readRecord(opencodeDir) {
+  for (const name of [VERSION_RECORD_FILE, LEGACY_RECORD_FILE]) {
+    const path = join(opencodeDir, name)
+    if (existsSync(path)) {
+      try {
+        return JSON.parse(readFileSync(path, 'utf8'))
+      } catch {
+        return null
+      }
+    }
+  }
+  return null
+}
+
+async function writeRecord(projectDir, version) {
+  const opencodeDir = join(projectDir, '.opencode')
+  await mkdir(opencodeDir, { recursive: true })
+  await writeFile(
+    join(opencodeDir, VERSION_RECORD_FILE),
+    JSON.stringify({ version, installedAt: new Date().toISOString() }, null, 2) + '\n',
+    'utf8',
+  )
+}
+
+async function verifyConsistency() {
+  const diverged = await checkAssets()
+  if (diverged.length > 0) {
+    console.error('Generated assets are out of sync with recipes/:')
+    for (const file of diverged) console.error(`  ${file}`)
+    console.error('Run `yarn workspace @thorprovider/storefront sync-assets` to regenerate.')
+    return false
+  }
+  return true
+}
+
+async function installSuite(opencodeDir, force) {
+  let total = 0
+  for (const dir of COPY_DIRS) {
+    const from = join(PKG_ROOT, dir)
+    const to = join(opencodeDir, dir)
+    await mkdir(to, { recursive: true })
+    total += await copyDir(from, to, force)
+  }
+  return total
+}
+
+function run(cmd, cmdArgs, cwd) {
+  const res = spawnSync(cmd, cmdArgs, { cwd, stdio: 'inherit', shell: false })
+  return res.status ?? 1
+}
+
+const BRAND_TOKEN_KEYS = {
+  light: ['--primary', '--primary-foreground', '--nav', '--ring'],
+  dark: ['--primary', '--primary-foreground', '--nav', '--ring'],
+}
+
+const COLOR_HUES = {
+  red: 27,
+  orange: 55,
+  amber: 75,
+  yellow: 95,
+  lime: 130,
+  green: 155,
+  teal: 185,
+  cyan: 210,
+  blue: 232,
+  indigo: 264,
+  violet: 290,
+  purple: 310,
+  pink: 350,
+  slate: 240,
+  gray: 240,
+  neutral: 0,
+  stone: 60,
+}
+
+function applyBrand(globalsCss, brand) {
+  if (!brand) return globalsCss
+  const hue = COLOR_HUES[brand]
+  if (hue === undefined) {
+    console.error(`Unknown brand color: ${brand}`)
+    process.exitCode = 1
+    return globalsCss
+  }
+  // Swap the hue channel (third component) of each brand token's oklch value in
+  // both modes. Lightness/chroma stay from the preset so the contrast pair rule
+  // is preserved; only the hue carries the brand color.
+  let css = globalsCss
+  for (const key of [...BRAND_TOKEN_KEYS.light, ...BRAND_TOKEN_KEYS.dark]) {
+    css = css.replace(new RegExp(`(${key}: oklch\\([^)]*?\\s)([^\\s)]+)(\\))`, 'g'), `$1${hue}$3`)
+  }
+  return css
+}
+
+async function promptScaffoldInputs(args) {
+  const inputs = {
+    name: toKebab(args.name ?? '') || null,
+    siteName: args.siteName ?? null,
+    backendUrl: args.backendUrl ?? null,
+    preset: args.preset ?? null,
+    brand: args.brand ?? null,
+  }
+
+  const tty = Boolean(process.stdout.isTTY)
+  if (tty) {
+    intro('storefront create')
+
+    if (!inputs.name) {
+      const value = await text({
+        message: 'Storefront name (kebab-case — lib/<name>/):',
+        placeholder: 'my-shop',
+        validate: (v) => (toKebab(v ?? '').length ? undefined : 'Enter a kebab-case name'),
+      })
+      if (isCancel(value)) {
+        cancel('Operation cancelled.')
+        process.exit(0)
+      }
+      inputs.name = toKebab(value)
+    }
+
+    if (!inputs.siteName) {
+      const value = await text({
+        message: 'Site name:',
+        initialValue: inputs.name,
+      })
+      if (isCancel(value)) {
+        cancel('Operation cancelled.')
+        process.exit(0)
+      }
+      inputs.siteName = value
+    }
+
+    if (!inputs.backendUrl) {
+      const value = await text({
+        message: 'Medusa backend URL:',
+        initialValue: DEFAULT_BACKEND_URL,
+      })
+      if (isCancel(value)) {
+        cancel('Operation cancelled.')
+        process.exit(0)
+      }
+      inputs.backendUrl = value
+    }
+
+    if (!inputs.preset) {
+      const value = await select({
+        message: 'Visual preset:',
+        initialValue: 'maia',
+        options: PRESETS.map((preset) => ({
+          value: preset,
+          label: `${preset} — ${PRESET_LABELS[preset]}`,
+        })),
+      })
+      if (isCancel(value)) {
+        cancel('Operation cancelled.')
+        process.exit(0)
+      }
+      inputs.preset = value
+    }
+
+    outro('Scaffolding…')
+  }
+
+  const missing = []
+  if (!inputs.name) missing.push('storefront name (--name <name>)')
+  if (!inputs.preset) missing.push('--preset (one of: ' + PRESETS.join(', ') + ')')
+  else if (!PRESETS.includes(inputs.preset)) missing.push(`--preset must be one of: ${PRESETS.join(', ')}`)
+
+  if (missing.length > 0) return { missing }
+  return {
+    inputs: {
+      name: inputs.name,
+      siteName: inputs.siteName ?? inputs.name,
+      backendUrl: inputs.backendUrl ?? DEFAULT_BACKEND_URL,
+      preset: inputs.preset,
+      brand: inputs.brand,
+    },
+  }
+}
+
+async function create(args) {
+  const target = args.dir
+  const { inputs, missing } = await promptScaffoldInputs(args)
+  if (missing && missing.length > 0) {
+    console.error('Missing or invalid input (run in a terminal to use the wizard, or pass flags):')
+    for (const item of missing) console.error(`  - ${item}`)
+    return 1
+  }
+
+  const { name, siteName, backendUrl, preset, brand } = inputs
+
+  console.log('storefront create — deterministic scaffold')
+  console.log(`  name:        ${name}`)
+  console.log(`  site name:   ${siteName}`)
+  console.log(`  backend:     ${backendUrl}`)
+  console.log(`  preset:      ${preset}`)
+  if (brand) console.log(`  brand:       ${brand}`)
+  console.log(`  target:      ${target}`)
+
+  // 1. Preconditions
+  if (!existsSync(target)) {
+    console.log(`Creating target directory: ${target}`)
+    await mkdir(target, { recursive: true })
+  }
+  const libDir = join(target, 'lib', name)
+  if (existsSync(libDir)) {
+    console.error(`lib/${name}/ already exists — refusing to overwrite.`)
+    console.error('Use /sf-add-view to extend an existing storefront.')
+    return 1
+  }
+  if (!(await verifyConsistency())) return 1
+
+  // 2. Next.js base
+  const hasPackageJson = existsSync(join(target, 'package.json'))
+  if (!hasPackageJson) {
+    const stash = join(target, '.opencode.__stash__')
+    const opencodeDir = join(target, '.opencode')
+    const hadOpenCode = existsSync(opencodeDir)
+    if (hadOpenCode) {
+      await mkdir(stash, { recursive: true })
+      await cp(opencodeDir, stash, { recursive: true })
+      await rm(opencodeDir, { recursive: true, force: true })
+    }
+    const status = run('yarn', ['create', 'next-app', '.', '--ts', '--tailwind', '--app', '--import-alias', '@/*', '--no-turbopack'], target)
+    if (hadOpenCode) {
+      await cp(stash, opencodeDir, { recursive: true })
+      await rm(stash, { recursive: true, force: true })
+    }
+    if (status !== 0) {
+      console.error('create-next-app failed.')
+      return status
+    }
+  }
+
+  // 3. shadcn base
+  const shadcnStatus = run(
+    'yarn',
+    ['dlx', 'shadcn@latest', 'init', '--template', 'next', '--base', 'base', '--preset', preset, '--no-monorepo', '--no-rtl', '--yes'],
+    target,
+  )
+  if (shadcnStatus !== 0) {
+    console.error('shadcn init failed.')
+    return shadcnStatus
+  }
+
+  // 4. Yarn node-modules linker
+  await writeFile(join(target, '.yarnrc.yml'), 'nodeLinker: node-modules\n', 'utf8')
+  await rm(join(target, '.pnp.cjs'), { force: true })
+
+  // 5. Dependencies
+  const STOREFRONT_DEPS = [
+    '@thorprovider/blocks',
+    '@thorprovider/adapters',
+    '@thorprovider/runtime',
+    '@json-render/core',
+    '@json-render/react',
+    '@json-render/next',
+    'motion',
+    'zod',
+  ]
+  const addStatus = run('yarn', ['add', ...STOREFRONT_DEPS], target)
+  if (addStatus !== 0) {
+    console.error('yarn add failed.')
+    return addStatus
+  }
+
+  // 6. Template copy + placeholder substitution
+  await renderScaffold({ targetDir: target, name, siteName })
+
+  // 7. .env.local + theme
+  const envLocal = `MEDUSA_BACKEND_URL=${backendUrl}\nMEDUSA_REGION_ID=\nMEDUSA_PUBLISHABLE_KEY=\n`
+  await writeFile(join(target, '.env.local'), envLocal, 'utf8')
+
+  const globalsPath = join(target, 'app', 'globals.css')
+  if (existsSync(globalsPath)) {
+    const css = readFileSync(globalsPath, 'utf8')
+    await writeFile(globalsPath, applyBrand(css, brand), 'utf8')
+  }
+
+  // 8. Suite install + version record
+  const opencodeDir = join(target, '.opencode')
+  const total = await installSuite(opencodeDir, args.force)
+  await writeRecord(target, pkgVersion())
+  console.log(`installed ${total} file(s) and recorded the version`)
+
+  console.log('')
+  console.log('Done. Next steps:')
+  console.log(`  cd ${relative(process.cwd(), target) || '.'}`)
+  console.log('  yarn dev')
+  console.log('Then use /sf-add-view, /sf-view, /sf-theme to extend the store.')
+  return 0
+}
+
+async function update(args) {
+  const target = args.dir
+  if (!existsSync(target)) {
+    console.error(`Target directory does not exist: ${target}`)
+    return 1
+  }
+  if (!(await verifyConsistency())) return 1
+
+  const opencodeDir = join(target, '.opencode')
+  if (!existsSync(opencodeDir)) {
+    console.error(`No .opencode/ found in ${target}`)
+    console.error('Run `storefront create <dir>` to scaffold and install the suite.')
+    return 1
+  }
+
+  const total = await installSuite(opencodeDir, args.force)
+  for (const rel of PRUNED_PATHS) await prunePath(opencodeDir, rel)
+  await writeRecord(target, pkgVersion())
+  await rm(join(opencodeDir, LEGACY_RECORD_FILE), { force: true })
+
+  console.log(`Refreshed install in ${target}:`)
+  console.log(`  installed ${total} file(s)`)
+  console.log('  pruned removed files (sf-init, sf-scaffold)')
+  console.log('  migrated version record to storefront.json')
+  console.log('Done. Available in OpenCode:')
+  console.log('  /sf-add-view  /sf-view  /sf-theme')
+  if (args.force) console.log('(used --force: existing files were overwritten)')
+  return 0
+}
+
+async function doctor(args) {
+  const target = args.dir
+  console.log(`@thorprovider/storefront doctor — ${target}`)
+  if (!existsSync(target)) {
+    console.error(`Target directory does not exist: ${target}`)
+    return 1
+  }
+
+  const opencodeDir = join(target, '.opencode')
+  const record = await readRecord(opencodeDir)
+  if (!record) {
+    console.log('No version record found in .opencode/.')
+    console.log('Run `storefront update` to install and record the suite.')
+    return 0
+  }
+
+  const version = pkgVersion()
+  console.log(`  recorded version: ${record.version} (installed ${record.installedAt})`)
+  console.log(`  package version:  ${version}`)
+
+  const installedHash = await hashDir(opencodeDir)
+  const sourceHash = await hashDir(PKG_ROOT)
+  const match = installedHash === sourceHash
+  console.log(`  installed suite matches package: ${match ? 'yes' : 'no'}`)
+  if (!match) {
+    console.log('  status: update available — run "storefront update"')
+  }
+  return 0
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2))
+  if (!args) return 1
+  if (args.help || !args.action) {
+    console.log(HELP)
+    return 0
+  }
+  if (args.action === 'create') return create(args)
+  if (args.action === 'update') return update(args)
+  if (args.action === 'doctor') return doctor(args)
+  console.error(`Unknown action: ${args.action}`)
+  console.log(HELP)
+  return 1
+}
+
+main().then((code) => {
+  process.exitCode = code
+})

package/commands/sf-add-view.md

@@ -0,0 +1,26 @@
+---
+description: "Add a single view to an existing Thor Commerce storefront (product, category, checkout, user-panel)"
+---
+
+Add one view to an existing Thor Commerce storefront, generated from a recipe.
+
+**Input**: view name, optionally followed by a description of what the view should contain or emphasize.
+Examples:
+- `/sf-add-view product`
+- `/sf-add-view category specialize in power stations, use a dense grid`
+- `/sf-add-view checkout keep it single-page`
+
+**Provided arguments**: $ARGUMENTS
+
+Use the `sf-view-gen` skill.
+
+The skill generates from the assets inside its own directory (`assets/recipes/`, `assets/templates/views/`); when a choice is not resolved there, it asks you.
+
+**Reads (target project):** existence of `package.json`, `lib/<name>/`, `.opencode/`, and the view name + description.
+**Writes (target project):** the view module and one barrel entry, all reported.
+
+**Constraints (do not violate without explicit user authorization):**
+- Allowed view names: `home`, `product`, `category`, `checkout`, `user-panel`
+- Block variants and optional sections MUST come from the skill's own `assets/recipes/` (`recipes.json`, `archetypes.json`, `sections.json`)
+- UI components come ONLY from `@thorprovider/blocks`
+- Data access goes ONLY through `@thorprovider/adapters` / `@thorprovider/runtime/commerce`

package/commands/sf-theme.md

@@ -0,0 +1,20 @@
+---
+description: "Customize storefront theme: OKLCH colors (light/dark), typography, and identity metadata"
+---
+
+Customize the theme and identity of a Thor Commerce storefront.
+
+**Input**: optional — the wizard asks what to customize (colors, typography, identity, SEO, Open Graph).
+**Provided arguments**: $ARGUMENTS
+
+Use the `sf-theme-gen` skill.
+
+The skill works from its own directory and the vendored `shadcn-theming` skill beside it; when a choice is not resolved there, it asks you.
+
+**Reads (target project):** existence of `package.json`, `lib/<name>/`, `.opencode/`, and the wizard answers.
+**Writes (target project):** `app/globals.css` and `app/layout.tsx`, all reported.
+
+**Constraints (do not violate without explicit user authorization):**
+- Colors are CSS variables in OKLCH with complete background/foreground pairs (light AND dark)
+- Never use raw Tailwind color utilities for themed colors
+- Typography and metadata follow the skill's own assets

package/commands/sf-view.md

@@ -0,0 +1,25 @@
+---
+description: "Modify an existing storefront view's spec while preserving its structure"
+---
+
+Modify an existing view in a Thor Commerce storefront.
+
+**Input**: view name followed by the change to make.
+Examples:
+- `/sf-view home add a statistics band after the hero`
+- `/sf-view category switch to a 4-column grid`
+
+**Provided arguments**: $ARGUMENTS
+
+Use the `sf-view-gen` skill (modification workflow).
+
+The skill works from the assets inside its own directory (`assets/recipes/`, `assets/templates/views/`); when a choice is not resolved there, it asks you.
+
+**Reads (target project):** existence of `package.json`, `lib/<name>/`, `.opencode/`, the existing view module, and the change requested.
+**Writes (target project):** the edited view module, all reported.
+
+**Constraints (do not violate without explicit user authorization):**
+- Allowed view names: `home`, `product`, `category`, `checkout`, `user-panel`
+- Preserve element ids, `type`, untouched `props`, `$state` bindings, and `on` wiring
+- Only add block variants/sections declared in the skill's own `assets/recipes/`
+- UI components come ONLY from `@thorprovider/blocks`

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@thorprovider/storefront",
+  "version": "0.3.1",
+  "description": "Deterministic storefront scaffolder and installable OpenCode command suite for Thor Commerce (Next.js, @thorprovider/blocks, @thorprovider/adapters, Medusa)",
+  "type": "module",
+  "bin": "./bin/storefront.js",
+  "files": [
+    "assets",
+    "bin",
+    "commands",
+    "skills",
+    "recipes",
+    "scripts",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.17.0"
+  },
+  "scripts": {
+    "sync-assets": "node ./scripts/sync-assets.mjs",
+    "check-assets": "node ./scripts/sync-assets.mjs --check",
+    "pretest": "node ./scripts/sync-assets.mjs --check",
+    "test": "vitest run --config vitest.config.ts"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thorprovider/thor-commerce",
+    "directory": "packages/storefront"
+  },
+  "keywords": [
+    "thor-commerce",
+    "opencode",
+    "storefront",
+    "json-render",
+    "scaffolding"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.8.1"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  },
+  "license": "MIT"
+}

package/recipes/archetype.schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "archetype.schema.json",
+  "title": "Storefront archetype manifest",
+  "description": "Maps slots to named intents. Each intent resolves to a block variant that must be allowed by the view recipe for that slot.",
+  "type": "object",
+  "required": ["version", "slots"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": { "type": "string" },
+    "version": { "type": "string" },
+    "description": { "type": "string" },
+    "slots": {
+      "type": "object",
+      "minProperties": 1,
+      "additionalProperties": {
+        "type": "object",
+        "required": ["default", "intents"],
+        "additionalProperties": false,
+        "properties": {
+          "default": { "type": "string" },
+          "intents": {
+            "type": "object",
+            "minProperties": 1,
+            "additionalProperties": {
+              "type": "object",
+              "required": ["variant", "when"],
+              "additionalProperties": false,
+              "properties": {
+                "variant": { "type": "string" },
+                "when": { "type": "string", "minLength": 10 }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}