@owlmeans/viable-common 0.0.43 → 0.0.45

package/tests/presentation.spec.ts

@@ -1,49 +1,47 @@
 import { describe, expect, test } from 'bun:test'
-import {
-  AgentCodeLanguage, AgentMarkdownKind, AgentMessageCategory, AgentMessageRole,
-  AgentStructuredKind, classifyAgentMessage, isAgentMessageHidden,
-} from '../src/agent/presentation.js'
+import { agentPresentationHelper } from '../src/agent/presentation.js'
+import { AgentCodeLanguage, AgentMarkdownKind, AgentMessageCategory, AgentMessageRole, AgentStructuredKind } from '../src/agent/consts.js'
 
 describe('@owlmeans/viable-common — agent message presentation', () => {
   test('classifies source and unified diffs with their display language', () => {
-    expect(classifyAgentMessage({ action: 'code', text: 'export const App = () => <main />' }))
+    expect(agentPresentationHelper.classifyAgentMessage({ action: 'code', text: 'export const App = () => <main />' }))
       .toMatchObject({ category: AgentMessageCategory.Code, language: AgentCodeLanguage.ReactTsx })
-    expect(classifyAgentMessage({ action: 'update-code', text: '--- a/app.css\n+++ b/app.css\n@@ -1 +1 @@\n-.old {}\n+.new {}' }))
+    expect(agentPresentationHelper.classifyAgentMessage({ action: 'update-code', text: '--- a/app.css\n+++ b/app.css\n@@ -1 +1 @@\n-.old {}\n+.new {}' }))
       .toMatchObject({ category: AgentMessageCategory.Diff, language: AgentCodeLanguage.Css })
-    expect(classifyAgentMessage({ text: '{"ready": true}' }))
+    expect(agentPresentationHelper.classifyAgentMessage({ text: '{"ready": true}' }))
       .toMatchObject({ category: AgentMessageCategory.Code, language: AgentCodeLanguage.Json })
   })
 
   test('unwraps schema tool calls into semantic cards instead of a JSON fallback', () => {
-    expect(classifyAgentMessage({
+    expect(agentPresentationHelper.classifyAgentMessage({
       outputType: 'tool_calls',
       action: 'choose-files-for-fix',
       value: [{ name: 'answer', args: { files: ['src/app.tsx'], why: 'screen entrypoint' } }],
     })).toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.ArtifactSelection })
-    expect(classifyAgentMessage({ value: { actor: 'human', worker: false, jobs: [], agents: [], kv: false } }))
+    expect(agentPresentationHelper.classifyAgentMessage({ value: { actor: 'human', worker: false, jobs: [], agents: [], kv: false } }))
       .toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.RuntimeDecision })
     // The model's own runtime-decision call never carries `actor`/`worker` — those are added only
     // once the decision is persisted onto a StoryDesign.
-    expect(classifyAgentMessage({ value: { kv: true, feedback: null, jobs: [], agents: [] } }))
+    expect(agentPresentationHelper.classifyAgentMessage({ value: { kv: true, feedback: null, jobs: [], agents: [] } }))
       .toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.RuntimeDecision })
     // A scaffold plan carries its own `stories` array — checked ahead of StoryPlan's bare check.
-    expect(classifyAgentMessage({
+    expect(agentPresentationHelper.classifyAgentMessage({
       value: { identity: { name: 'App', description: '' }, guestHome: {}, areas: [], stories: [], motifs: '' },
     })).toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.ScaffoldPlan })
-    expect(classifyAgentMessage({ value: { unknown: ['still', 'readable'] } }))
+    expect(agentPresentationHelper.classifyAgentMessage({ value: { unknown: ['still', 'readable'] } }))
       .toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.GenericRecord })
   })
 
   test('routes unconstrained tool-calling loops to ToolCalls even when args shape-match a schema', () => {
     // A single free-flight file read whose args happen to carry `files` — without the action
     // check this reads as an ArtifactSelection card instead of a tool call.
-    expect(classifyAgentMessage({
+    expect(agentPresentationHelper.classifyAgentMessage({
       outputType: 'tool_calls',
       action: 'coding-agent-ask',
       value: [{ name: 'read_sources', args: { files: ['src/app.tsx'] } }],
     })).toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.ToolCalls })
     // Several calls in the same turn are always ToolCalls, regardless of action.
-    expect(classifyAgentMessage({
+    expect(agentPresentationHelper.classifyAgentMessage({
       outputType: 'tool_calls',
       value: [
         { name: 'read_file', args: { path: 'a.ts' } },
@@ -52,34 +50,34 @@ describe('@owlmeans/viable-common — agent message presentation', () => {
     })).toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.ToolCalls })
     // A single call whose args shape-match nothing known stays ToolCalls rather than falling
     // through to a generic JSON dump.
-    expect(classifyAgentMessage({
+    expect(agentPresentationHelper.classifyAgentMessage({
       outputType: 'tool_calls',
       value: [{ name: 'run_bun', args: { args: 'install' } }],
     })).toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.ToolCalls })
   })
 
   test('uses producer metadata for roles and action metadata for documents and decisions', () => {
-    expect(classifyAgentMessage({ agent: 'ba-service', helper: 'ba-helper', action: 'write-specification', text: '# Brief' }))
+    expect(agentPresentationHelper.classifyAgentMessage({ agent: 'ba-service', helper: 'ba-helper', action: 'write-specification', text: '# Brief' }))
       .toMatchObject({ category: AgentMessageCategory.Markdown, document: AgentMarkdownKind.Specification, role: AgentMessageRole.Analytical })
-    expect(classifyAgentMessage({ agent: 'ui-helper', action: 'describe-ui-screen', text: '## Layout' }))
+    expect(agentPresentationHelper.classifyAgentMessage({ agent: 'ui-helper', action: 'describe-ui-screen', text: '## Layout' }))
       .toMatchObject({ role: AgentMessageRole.VisualDesign })
-    expect(classifyAgentMessage({ agent: 'api-helper', action: 'should-update-handler', text: 'true' }))
+    expect(agentPresentationHelper.classifyAgentMessage({ agent: 'api-helper', action: 'should-update-handler', text: 'true' }))
       .toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.Decision, role: AgentMessageRole.Architect })
-    expect(classifyAgentMessage({ agent: 'runtime-architect', action: 'runtime-gate' }))
+    expect(agentPresentationHelper.classifyAgentMessage({ agent: 'runtime-architect', action: 'runtime-gate' }))
       .toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.RuntimeDecision, role: AgentMessageRole.Architect })
-    expect(classifyAgentMessage({ helper: 'navigation-analyst', action: 'detect-story-with-home-screen' }))
+    expect(agentPresentationHelper.classifyAgentMessage({ helper: 'navigation-analyst', action: 'detect-story-with-home-screen' }))
       .toMatchObject({ category: AgentMessageCategory.Structured, structure: AgentStructuredKind.CandidateRanking, role: AgentMessageRole.Analytical })
   })
 
   test('keeps ordinary conversation as plain text', () => {
-    expect(classifyAgentMessage({ agent: 'client', action: 'prompt', text: 'Please add a dashboard.' }))
+    expect(agentPresentationHelper.classifyAgentMessage({ agent: 'client', action: 'prompt', text: 'Please add a dashboard.' }))
       .toEqual({ category: AgentMessageCategory.Plain, role: AgentMessageRole.Technical })
   })
 
   test('hides source-extractor range selections from the user-facing journal', () => {
-    expect(isAgentMessageHidden({ action: 'source-extract', value: [{
+    expect(agentPresentationHelper.isAgentMessageHidden({ action: 'source-extract', value: [{
       name: 'select_ranges', args: { ranges: [{ start: 12, end: 18 }] },
     }] })).toBe(true)
-    expect(isAgentMessageHidden({ action: 'declaration-lookup' })).toBe(false)
+    expect(agentPresentationHelper.isAgentMessageHidden({ action: 'declaration-lookup' })).toBe(false)
   })
 })

package/tests/scaffold.spec.ts

@@ -1,11 +1,16 @@
 import { describe, expect, test } from 'bun:test'
 import Ajv from 'ajv'
-import { validateSpecificationBody } from '@owlmeans/planning'
 import { ProjectArea } from '../src/areas/consts.js'
 import { ViableSpecCategory, VIABLE_PROJECT_SLOTS } from '../src/planning/index.js'
-import { BENTO_FRAGMENT_KINDS, LANDING_GATE_FIELD_KINDS, WidgetKind } from '../src/scaffold/consts.js'
+import {
+  BENTO_FRAGMENT_KINDS, LANDING_ANCHOR_BAND, LANDING_ANCHORS, LANDING_BAND_ORDER, LANDING_GATE_FIELD_KINDS,
+  LANDING_GATE_SLOTS, LANDING_SLOTS, WidgetKind,
+} from '../src/scaffold/consts.js'
+import { landingPlanHelper } from '../src/scaffold/landing.js'
+import * as barrel from '../src/index.js'
 import { ScaffoldPlanAnswerSchema, ScaffoldPlanSchema } from '../src/scaffold/schemas.js'
-import type { ScaffoldPlan } from '../src/scaffold/types.js'
+import type { GuestHomePlan, ScaffoldPlan } from '../src/scaffold/types.js'
+import { validateHelper } from '@owlmeans/planning'
 
 /**
  * The scaffold plan's schema is TWO things at once: the shape a model answers with, and the
@@ -104,12 +109,12 @@ describe('viable-common - the scaffold plan schema', () => {
 
   test('a plan stored before the landing overhaul still validates', () => {
     expect(validate(oldPlan()), JSON.stringify(validate.errors)).toBe(true)
-    expect(() => validateSpecificationBody(slot, JSON.stringify(oldPlan()))).not.toThrow()
+    expect(() => validateHelper.validateSpecificationBody(slot, JSON.stringify(oldPlan()))).not.toThrow()
   })
 
   test('a plan carrying every new field validates', () => {
     expect(validate(newPlan()), JSON.stringify(validate.errors)).toBe(true)
-    expect(() => validateSpecificationBody(slot, JSON.stringify(newPlan()))).not.toThrow()
+    expect(() => validateHelper.validateSpecificationBody(slot, JSON.stringify(newPlan()))).not.toThrow()
   })
 
   test('a provider that spells an unset optional as null is accepted', () => {
@@ -144,7 +149,7 @@ describe('viable-common - the scaffold plan schema', () => {
     stored.guestHome.gate = legacyGate()
 
     expect(validate(stored), JSON.stringify(validate.errors)).toBe(true)
-    expect(() => validateSpecificationBody(slot, JSON.stringify(stored))).not.toThrow()
+    expect(() => validateHelper.validateSpecificationBody(slot, JSON.stringify(stored))).not.toThrow()
   })
 
   test('a field kind nothing can draw is refused', () => {
@@ -189,3 +194,278 @@ describe('viable-common - the scaffold plan the model answers', () => {
     expect(text).not.toContain('maxItems')
   })
 })
+
+const BASIS = 'bakers who want the full method'
+
+/** A plan carrying every key the gated landing page added. */
+const landingPlan = (): ScaffoldPlan => {
+  const plan = newPlan()
+
+  return {
+    ...plan,
+    guestHome: {
+      ...plan.guestHome,
+      testimonials: [
+        { quote: 'I found a rye loaf.', name: 'Mara L.', role: 'Home baker' },
+        { quote: 'The notes saved my bake.', name: 'Jon K.', role: 'Weekend baker' },
+      ],
+      useCases: {
+        cases: [
+          { audience: 'Home bakers', title: 'Bake from the pantry', text: 'Use what is at hand.' },
+          { audience: 'Teachers', title: 'Run a class', text: 'Share one method.' },
+          { audience: 'Clubs', title: 'Swap bakes', text: 'Trade notes.' },
+        ],
+        basis: BASIS,
+      },
+      differentiator: {
+        title: 'The method, not the photo', text: 'Every bake carries its full method.',
+        contrast: [{ usual: 'A photo', ours: 'The full method' }, { usual: 'Guesswork', ours: 'Notes' }],
+        usualLabel: 'Usually', oursLabel: 'With us', basis: BASIS,
+      },
+      approach: {
+        title: 'Honest notes.',
+        principles: [
+          { title: 'Real bakes', text: 'Made at home.' },
+          { title: 'Full methods', text: 'Nothing skipped.' },
+          { title: 'Credit bakers', text: 'Names stay on.' },
+        ],
+        basis: BASIS,
+      },
+      about: { title: 'Who we are', text: 'Bakers sharing bakes.', basis: BASIS },
+      labels: {
+        ...plan.guestHome.labels,
+        useCases: 'Who it is for', useCasesTitle: 'Made for bakers.', differentiator: 'Why us',
+        approach: 'How we work', approachTitle: 'Small batches.', about: 'About',
+      },
+      menu: [{ anchor: 'how', label: 'Steps' }, { anchor: 'why', label: 'Why' }, { anchor: 'about', label: 'Us' }],
+      links: [{ slot: 'hero.browse', story: 'US-ABC12' }, { slot: 'useCase.1', story: 'US-ABC12' }],
+    },
+  }
+}
+
+/** The new optional keys of the guest home and of its labels. */
+const NEW_HOME_KEYS = ['testimonials', 'useCases', 'differentiator', 'approach', 'about', 'menu', 'links'] as const
+const NEW_LABEL_KEYS = ['useCases', 'useCasesTitle', 'differentiator', 'approach', 'approachTitle', 'about'] as const
+
+describe('viable-common - the gated landing page in the scaffold plan schema', () => {
+  const validate = new Ajv({ strict: false, allErrors: true }).compile(ScaffoldPlanSchema)
+  const answer = new Ajv({ strict: false, allErrors: true }).compile(ScaffoldPlanAnswerSchema)
+  const slot = VIABLE_PROJECT_SLOTS.find(entry => entry.category === ViableSpecCategory.Scaffold)!
+
+  test('an old stored plan and a plan with every new key both validate, stored and answered', () => {
+    expect(validate(oldPlan()), JSON.stringify(validate.errors)).toBe(true)
+    expect(validate(landingPlan()), JSON.stringify(validate.errors)).toBe(true)
+    expect(() => validateHelper.validateSpecificationBody(slot, JSON.stringify(landingPlan()))).not.toThrow()
+    expect(answer(landingPlan()), JSON.stringify(answer.errors)).toBe(true)
+  })
+
+  test('every new optional key accepts null', () => {
+    for (const key of NEW_HOME_KEYS) {
+      const plan = landingPlan() as unknown as { guestHome: Record<string, unknown> }
+      plan.guestHome[key] = null
+      expect(validate(plan), `${key}: ${JSON.stringify(validate.errors)}`).toBe(true)
+      expect(answer(plan), `${key}: ${JSON.stringify(answer.errors)}`).toBe(true)
+    }
+    for (const key of NEW_LABEL_KEYS) {
+      const plan = landingPlan() as unknown as { guestHome: { labels: Record<string, unknown> } }
+      plan.guestHome.labels[key] = null
+      expect(validate(plan), `labels.${key}: ${JSON.stringify(validate.errors)}`).toBe(true)
+    }
+    const labels = landingPlan()
+    labels.guestHome.differentiator!.usualLabel = null
+    labels.guestHome.differentiator!.oursLabel = null
+    labels.guestHome.approach!.title = null
+    expect(validate(labels), JSON.stringify(validate.errors)).toBe(true)
+  })
+
+  test('linksDecided is stored (a list, null or absent) and never offered to the model', () => {
+    for (const value of [['US-ABC12', 'US-LATE1'], [], null, undefined]) {
+      const plan = landingPlan() as unknown as { guestHome: Record<string, unknown> }
+      if (value === undefined) delete plan.guestHome.linksDecided
+      else plan.guestHome.linksDecided = value
+      expect(validate(plan), `${JSON.stringify(value)}: ${JSON.stringify(validate.errors)}`).toBe(true)
+      expect(() => validateHelper.validateSpecificationBody(slot, JSON.stringify(plan))).not.toThrow()
+    }
+    const old = oldPlan() as unknown as { guestHome: Record<string, unknown> }
+    old.guestHome.linksDecided = ['US-LATE1']
+    expect(validate(old), JSON.stringify(validate.errors)).toBe(true)
+
+    const wrong = landingPlan() as unknown as { guestHome: Record<string, unknown> }
+    wrong.guestHome.linksDecided = [3]
+    expect(validate(wrong)).toBe(false)
+
+    const answered = ScaffoldPlanAnswerSchema.properties.guestHome as unknown as { properties: Record<string, unknown> }
+    expect(answered.properties.linksDecided).toBeUndefined()
+    expect(answered.properties.links).toBeDefined()
+  })
+
+  test('a plan without testimonials validates', () => {
+    const plan = landingPlan()
+    delete plan.guestHome.testimonials
+    expect(validate(plan), JSON.stringify(validate.errors)).toBe(true)
+    expect(answer(plan), JSON.stringify(answer.errors)).toBe(true)
+  })
+
+  test('refuses a bad anchor, a bad slot and an extra key inside a band', () => {
+    const anchor = landingPlan()
+    anchor.guestHome.menu = [{ anchor: 'pricing' as never, label: 'Pricing' }]
+    expect(validate(anchor)).toBe(false)
+
+    const target = landingPlan()
+    target.guestHome.links = [{ slot: 'hero.logo' as never, story: 'US-ABC12' }]
+    expect(validate(target)).toBe(false)
+
+    for (const band of ['useCases', 'differentiator', 'approach', 'about'] as const) {
+      const plan = landingPlan() as unknown as { guestHome: Record<string, Record<string, unknown>> }
+      plan.guestHome[band].extra = 'x'
+      expect(validate(plan), band).toBe(false)
+    }
+
+    const missing = landingPlan() as unknown as { guestHome: { about: Record<string, unknown> } }
+    delete missing.guestHome.about.basis
+    expect(validate(missing)).toBe(false)
+  })
+
+  test('declares no count as minItems/maxItems, in either schema', () => {
+    for (const schema of [ScaffoldPlanSchema, ScaffoldPlanAnswerSchema]) {
+      const text = JSON.stringify(schema)
+      expect(text).not.toContain('minItems')
+      expect(text).not.toContain('maxItems')
+    }
+    expect(JSON.stringify(ScaffoldPlanAnswerSchema)).toContain('"differentiator"')
+  })
+
+  test('exports the landing vocabulary and helpers through the package barrel', () => {
+    expect(barrel.landingPlanHelper).toBe(landingPlanHelper)
+    expect(barrel.LANDING_GATE_SLOTS).toEqual(['hero.cta', 'hero.secondary', 'closing.primary'])
+    for (const anchor of LANDING_ANCHORS) {
+      expect(LANDING_BAND_ORDER).toContain(LANDING_ANCHOR_BAND[anchor])
+    }
+    for (const gated of LANDING_GATE_SLOTS) {
+      expect(LANDING_SLOTS).toContain(gated)
+    }
+  })
+})
+
+describe('viable-common - landingBandsOf', () => {
+  test('an old stored plan draws the always-on bands; one quote is no testimonials band', () => {
+    expect(landingPlanHelper.landingBandsOf(oldPlan().guestHome)).toEqual(['hero', 'features', 'problem'])
+  })
+
+  test('a full plan draws every band in the house order', () => {
+    expect(landingPlanHelper.landingBandsOf(landingPlan().guestHome)).toEqual(LANDING_BAND_ORDER)
+  })
+
+  test('each optional band follows its own presence rule', () => {
+    const home = landingPlan().guestHome
+    const without = (patch: Partial<GuestHomePlan>) => landingPlanHelper.landingBandsOf({ ...home, ...patch })
+
+    expect(without({ steps: [{ title: '  ', text: 'x' }] })).not.toContain('steps')
+    expect(without({ useCases: { cases: home.useCases!.cases.slice(0, 1), basis: BASIS } })).not.toContain('use-cases')
+    expect(without({ approach: { principles: home.approach!.principles.slice(0, 2), basis: BASIS } })).not.toContain('approach')
+    expect(without({ testimonials: null })).not.toContain('testimonials')
+    expect(without({ about: { title: 'Who', text: ' ', basis: BASIS } })).not.toContain('about')
+    expect(without({ closing: undefined })).not.toContain('closing')
+
+    // The differentiator: enough contrast rows, OR a title and a text.
+    const rowsOnly = { ...home.differentiator!, title: '', text: '' }
+    expect(without({ differentiator: rowsOnly })).toContain('differentiator')
+    const textOnly = { ...home.differentiator!, contrast: [] }
+    expect(without({ differentiator: textOnly })).toContain('differentiator')
+    expect(without({ differentiator: { ...rowsOnly, contrast: rowsOnly.contrast.slice(0, 1) } })).not.toContain('differentiator')
+  })
+})
+
+describe('viable-common - landingMenuOf', () => {
+  test('keeps the planned entries in page order with their own labels', () => {
+    const home = landingPlan().guestHome
+    home.menu = [{ anchor: 'about', label: 'Us' }, { anchor: 'how', label: 'Steps' }, { anchor: 'why', label: ' ' }]
+
+    expect(landingPlanHelper.landingMenuOf(home)).toEqual([
+      { anchor: 'how', label: 'Steps' },
+      { anchor: 'why', label: 'Why us' },
+      { anchor: 'about', label: 'Us' },
+    ])
+  })
+
+  test('drops entries whose band is absent, and duplicates', () => {
+    const home = landingPlan().guestHome
+    home.about = null
+    home.testimonials = null
+    home.menu = [
+      { anchor: 'about', label: 'Us' }, { anchor: 'community', label: 'Reviews' },
+      { anchor: 'features', label: 'Tools' }, { anchor: 'features', label: 'Again' },
+      { anchor: 'approach', label: 'Ways' },
+    ]
+
+    expect(landingPlanHelper.landingMenuOf(home)).toEqual([
+      { anchor: 'features', label: 'Tools' },
+      { anchor: 'approach', label: 'Ways' },
+    ])
+  })
+
+  test('caps at max, never below the minimum', () => {
+    const home = landingPlan().guestHome
+    home.menu = [
+      { anchor: 'how', label: 'Steps' }, { anchor: 'features', label: 'Tools' },
+      { anchor: 'use-cases', label: 'Cases' }, { anchor: 'why', label: 'Why' },
+      { anchor: 'approach', label: 'Ways' }, { anchor: 'about', label: 'Us' },
+    ]
+
+    expect(landingPlanHelper.landingMenuOf(home).map(entry => entry.anchor)).toEqual(['how', 'features', 'use-cases', 'why'])
+    expect(landingPlanHelper.landingMenuOf(home, 3)).toHaveLength(3)
+    expect(landingPlanHelper.landingMenuOf(home, 0).map(entry => entry.anchor)).toEqual(['how', 'features'])
+  })
+
+  test('pads to two with how, features, then the first present optional band', () => {
+    const home = landingPlan().guestHome
+    home.menu = null
+    expect(landingPlanHelper.landingMenuOf(home)).toEqual([
+      { anchor: 'how', label: 'How it works' },
+      { anchor: 'features', label: 'Features' },
+    ])
+
+    home.menu = [{ anchor: 'about', label: 'Us' }]
+    expect(landingPlanHelper.landingMenuOf(home).map(entry => entry.anchor)).toEqual(['how', 'about'])
+
+    const noSteps = landingPlan().guestHome
+    noSteps.steps = []
+    noSteps.menu = []
+    noSteps.labels = { features: 'What you get' }
+    expect(landingPlanHelper.landingMenuOf(noSteps)).toEqual([
+      { anchor: 'features', label: 'What you get' },
+      { anchor: 'use-cases', label: 'Use cases' },
+    ])
+  })
+})
+
+describe('viable-common - homeSlotsOf', () => {
+  test('without a gate: the hero and closing pills exist, plus every labelled link and drawn case', () => {
+    const home = landingPlan().guestHome
+    delete home.gate
+
+    expect(landingPlanHelper.homeSlotsOf(home)).toEqual([
+      'hero.cta', 'hero.secondary', 'hero.browse', 'useCase.1', 'useCase.2', 'useCase.3',
+      'closing.primary', 'closing.secondary', 'closing.link.1', 'closing.link.2',
+    ])
+  })
+
+  test('with a usable gate the gated slots are gone; a gate without fields is no gate', () => {
+    const home = landingPlan().guestHome
+    const slots = landingPlanHelper.homeSlotsOf(home)
+    for (const gated of LANDING_GATE_SLOTS) expect(slots).not.toContain(gated)
+    expect(slots).toContain('hero.browse')
+    expect(slots).toContain('closing.link.1')
+
+    home.gate = { ...home.gate!, fields: [] }
+    expect(landingPlanHelper.homeSlotsOf(home)).toContain('hero.cta')
+  })
+
+  test('an old stored plan has the primary pill alone; too few cases draw no case slots', () => {
+    expect(landingPlanHelper.homeSlotsOf(oldPlan().guestHome)).toEqual(['hero.cta'])
+
+    const home = landingPlan().guestHome
+    home.useCases = { cases: home.useCases!.cases.slice(0, 1), basis: BASIS }
+    expect(landingPlanHelper.homeSlotsOf(home).some(entry => entry.startsWith('useCase.'))).toBe(false)
+  })
+})

package/tests/tenancy.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { NO_TENANCY, ProjectArea, tenancyOf, tenantedArea } from '../src/index.js'
+import { NO_TENANCY, ProjectArea, tenancyHelper } from '../src/index.js'
 import { LandingGatePreference } from '../src/blueprint/index.js'
 
 const experience = (tenancy: unknown) =>
@@ -12,37 +12,37 @@ describe('viable-common - the project tenancy', () => {
   })
 
   test('tenancyOf answers NO_TENANCY for no blueprint, no layer, no key and an unreadable value', () => {
-    expect(tenancyOf()).toBe(NO_TENANCY)
-    expect(tenancyOf(null)).toBe(NO_TENANCY)
-    expect(tenancyOf({})).toBe(NO_TENANCY)
-    expect(tenancyOf({ experience: { landingGate: LandingGatePreference.Allow } })).toBe(NO_TENANCY)
-    expect(tenancyOf(experience(null))).toBe(NO_TENANCY)
-    expect(tenancyOf(experience('both'))).toBe(NO_TENANCY)
-    expect(tenancyOf(experience({ operators: 'yes', users: 1 }))).toBe(NO_TENANCY)
-    expect(tenancyOf(experience({ operators: false, users: false }))).toBe(NO_TENANCY)
-    expect(tenancyOf({ experience: 'flat' as never })).toBe(NO_TENANCY)
+    expect(tenancyHelper.tenancyOf()).toBe(NO_TENANCY)
+    expect(tenancyHelper.tenancyOf(null)).toBe(NO_TENANCY)
+    expect(tenancyHelper.tenancyOf({})).toBe(NO_TENANCY)
+    expect(tenancyHelper.tenancyOf({ experience: { landingGate: LandingGatePreference.Allow } })).toBe(NO_TENANCY)
+    expect(tenancyHelper.tenancyOf(experience(null))).toBe(NO_TENANCY)
+    expect(tenancyHelper.tenancyOf(experience('both'))).toBe(NO_TENANCY)
+    expect(tenancyHelper.tenancyOf(experience({ operators: 'yes', users: 1 }))).toBe(NO_TENANCY)
+    expect(tenancyHelper.tenancyOf(experience({ operators: false, users: false }))).toBe(NO_TENANCY)
+    expect(tenancyHelper.tenancyOf({ experience: 'flat' as never })).toBe(NO_TENANCY)
   })
 
   test('tenancyOf reads a literal true per flag, and an absent flag as off', () => {
-    expect(tenancyOf(experience({ operators: true, users: false }))).toEqual({ operators: true, users: false })
-    expect(tenancyOf(experience({ users: true }))).toEqual({ operators: false, users: true })
-    const both = tenancyOf(experience({ operators: true, users: true }))
+    expect(tenancyHelper.tenancyOf(experience({ operators: true, users: false }))).toEqual({ operators: true, users: false })
+    expect(tenancyHelper.tenancyOf(experience({ users: true }))).toEqual({ operators: false, users: true })
+    const both = tenancyHelper.tenancyOf(experience({ operators: true, users: true }))
     expect(both).toEqual({ operators: true, users: true })
     expect(Object.isFrozen(both)).toBe(true)
   })
 
   test('tenantedArea: user follows users, operator follows operators, guest and admin never', () => {
     const all = { operators: true, users: true }
-    expect(tenantedArea(ProjectArea.User, all)).toBe(true)
-    expect(tenantedArea(ProjectArea.Operator, all)).toBe(true)
-    expect(tenantedArea(ProjectArea.Guest, all)).toBe(false)
-    expect(tenantedArea(ProjectArea.Admin, all)).toBe(false)
+    expect(tenancyHelper.tenantedArea(ProjectArea.User, all)).toBe(true)
+    expect(tenancyHelper.tenantedArea(ProjectArea.Operator, all)).toBe(true)
+    expect(tenancyHelper.tenantedArea(ProjectArea.Guest, all)).toBe(false)
+    expect(tenancyHelper.tenantedArea(ProjectArea.Admin, all)).toBe(false)
 
-    expect(tenantedArea(ProjectArea.User, { operators: true, users: false })).toBe(false)
-    expect(tenantedArea(ProjectArea.Operator, { operators: false, users: true })).toBe(false)
+    expect(tenancyHelper.tenantedArea(ProjectArea.User, { operators: true, users: false })).toBe(false)
+    expect(tenancyHelper.tenantedArea(ProjectArea.Operator, { operators: false, users: true })).toBe(false)
     for (const area of Object.values(ProjectArea)) {
-      expect(tenantedArea(area, NO_TENANCY)).toBe(false)
+      expect(tenancyHelper.tenantedArea(area, NO_TENANCY)).toBe(false)
     }
-    expect(tenantedArea('partner' as ProjectArea, all)).toBe(false)
+    expect(tenancyHelper.tenantedArea('partner' as ProjectArea, all)).toBe(false)
   })
 })

package/build/connect/ops.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ops.d.ts","sourceRoot":"","sources":["../../src/connect/ops.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,OAAO,KAAK,EACV,kBAAkB,EAAE,kBAAkB,EAAE,aAAa,EAAE,aAAa,EAAE,mBAAmB,EACzF,aAAa,EAAE,SAAS,EACzB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAEjD;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,aAAa,CAAA;IACnB,OAAO,EAAE,kBAAkB,GAAG,SAAS,GAAG,gBAAgB,GAAG,cAAc,CAAA;IAC3E,SAAS,EAAE,MAAM,CAAA;IACjB,wFAAwF;IACxF,UAAU,EAAE,MAAM,CAAA;IAClB,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE,OAAO,CAAA;IACX,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,cAAc,CAAA;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,kBAAkB,CAAA;CAC1B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,aAAa,EAAE,CAAA;IACtB,KAAK,EAAE,KAAK,CAAC,MAAM,eAAe,CAAC,CAAA;CACpC;AAED,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAA;IACZ,gFAAgF;IAChF,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,QAAQ,EAAE,eAAe,CAAA;CAC1B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,uFAAuF;IACvF,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,SAAS,CAAA;IACf,2FAA2F;IAC3F,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,aAAa,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,sEAAsE;IACtE,KAAK,CAAC,EAAE,aAAa,EAAE,CAAA;IACvB,8DAA8D;IAC9D,UAAU,CAAC,EAAE,mBAAmB,CAAA;IAChC,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,aAAa,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,4CAA4C;IAC5C,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC/B,qCAAqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC;AAED,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpE,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC9B;AAED,2CAA2C;AAC3C,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,mBAAmB,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC/B,kFAAkF;IAClF,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,oFAAoF;IACpF,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,sEAAsE;AACtE,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,mGAAmG;IACnG,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,kBAAkB,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAA;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,4EAA4E;IAC5E,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,+FAA+F;IAC/F,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC3B,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB"}

package/build/connect/ops.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ops.js.map

package/build/connect/ops.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ops.js","sourceRoot":"","sources":["../../src/connect/ops.ts"],"names":[],"mappings":""}