@owlmeans/viable-common 0.0.25 → 0.0.27

package/src/blueprint/types.ts

@@ -16,6 +16,12 @@ import type { TopologyDescriptor } from '../topology/types.js'
  * Deliberately NOT called a preset: `presets/` in the agent library already means the LLM
  * model/provider configurations, and the two are asked at different moments about different
  * things.
+ *
+ * Five layers are REQUIRED and say what the project is built WITH; the sixth, `experience`, is
+ * OPTIONAL and says what its product should do for the people using it. Optional because a
+ * blueprint registered before the layer existed — or a patch serialized into a run row — must keep
+ * resolving: every reader asks through a helper that answers the default for an absent layer
+ * ({@link landingGatePreferenceOf}).
  */
 export interface Blueprint {
   id: string
@@ -25,6 +31,7 @@ export interface Blueprint {
   template: TemplateLayer
   createApp: CreateAppLayer
   packages: PackagesLayer
+  experience?: ExperienceLayer
 }
 
 /**
@@ -32,7 +39,8 @@ export interface Blueprint {
  *
  * The ordering is the point: `technology` overrides everything, because a change of language
  * invalidates every template, prompt and package below it. Nothing today has more than one
- * technology — the ladder exists so that adding one is a data change.
+ * technology — the ladder exists so that adding one is a data change. `experience` is last and
+ * optional: it shares no key with the five build layers, so its place decides nothing today.
  */
 export enum BlueprintLayer {
   Technology = 'technology',
@@ -40,6 +48,7 @@ export enum BlueprintLayer {
   Template = 'template',
   CreateApp = 'create-app',
   Packages = 'packages',
+  Experience = 'experience',
 }
 
 export const BLUEPRINT_LAYER_ORDER: BlueprintLayer[] = [
@@ -48,8 +57,55 @@ export const BLUEPRINT_LAYER_ORDER: BlueprintLayer[] = [
   BlueprintLayer.Template,
   BlueprintLayer.CreateApp,
   BlueprintLayer.Packages,
+  BlueprintLayer.Experience,
 ]
 
+/**
+ * How strongly a product of this kind wants a LANDING GATE — the working entry into the key
+ * end-user workflow drawn on the guest home, where a guest starts before signing in.
+ *
+ * A PRIOR handed to the model that decides, never the decision itself: `Encourage` still lets it
+ * answer "no gate" for a product with no end-user step a guest could begin, and `Discourage` still
+ * lets it choose one when the specification plainly describes such a step.
+ */
+export enum LandingGatePreference {
+  /** Most products of this kind have a first-value step a guest can begin — look for it. */
+  Encourage = 'encourage',
+  /** Neutral: decide from the specification alone. */
+  Allow = 'allow',
+  /** Products of this kind rarely have one — choose a gate only when the specification asks. */
+  Discourage = 'discourage',
+}
+
+/**
+ * What the product should do for the people using it, independent of the stack it is built on.
+ *
+ * A layer of its own rather than a field of `packages`, because it changes no dependency, no
+ * capability and no prompt a coder reads — it is asked by the analysis stage about the PRODUCT.
+ */
+export interface ExperienceLayer {
+  landingGate: LandingGatePreference
+}
+
+const LANDING_GATE_PREFERENCES = new Set<string>(Object.values(LandingGatePreference))
+
+/**
+ * The landing-gate preference of a resolved blueprint.
+ *
+ * Total: an absent layer, an absent key and a value this deploy does not know (a patch serialized
+ * by a newer one) all answer `Allow` — the neutral prior, which leaves the decision to the
+ * specification rather than tilting it either way on a value nobody set.
+ */
+export const landingGatePreferenceOf = (
+  blueprint?: Pick<Blueprint, 'experience'> | null
+): LandingGatePreference => {
+  const value = blueprint?.experience?.landingGate
+
+  return value != null && LANDING_GATE_PREFERENCES.has(value)
+    ? value
+    : LandingGatePreference.Allow
+}
+
 /** Language and toolchain. Overrides everything below it. */
 export interface TechnologyLayer {
   id: string

package/src/branding.ts

@@ -14,6 +14,7 @@ export const BRANDING_ENV_KEYS = [
   'BRANDING_PRIVACY_URL',
   'BRANDING_CREDIT',
   'BRANDING_PRODUCT',
+  'BRANDING_GOOGLE_TAG',
 ] as const
 
 /**
@@ -23,6 +24,10 @@ export const BRANDING_ENV_KEYS = [
  * hides the platform credit, so a metadata set that never carried the key keeps it. That is the
  * safe direction — the opposite failure hands out a paid feature and nobody reports getting more
  * than they paid for.
+ *
+ * `BRANDING_GOOGLE_TAG` is always EMITTED, empty when no tag is set, although its metadata key is
+ * omitted from a push while unset: the environment is read by the application's own build, which
+ * treats `''` as "load no tag", while the metadata key is read by a publisher that may predate it.
  */
 export const brandingEnv = (meta: Partial<SlotMetadata>): Record<string, string> => ({
   BRANDING_COPYRIGHT: meta.brandingCopyright ?? '',
@@ -31,4 +36,5 @@ export const brandingEnv = (meta: Partial<SlotMetadata>): Record<string, string>
   BRANDING_PRIVACY_URL: meta.brandingPrivacyUrl ?? '',
   BRANDING_CREDIT: meta.brandingCredit === '' ? '' : '1',
   BRANDING_PRODUCT: meta.projectName ?? '',
+  BRANDING_GOOGLE_TAG: meta.brandingGoogleTag ?? '',
 })

package/src/connect/consts.ts

@@ -301,6 +301,19 @@ export const CONNECT_CONFIGURE_TIMEOUT_MS = 60_000
  */
 export const CONNECT_CAP_LOCAL_LLM_KEY = 'connect--local-llm'
 
+/**
+ * The ceilings of a project's branding strings on the connector wire.
+ *
+ * Each equals its twin in the platform's own branding contract (`BRANDING_COPYRIGHT_MAX`,
+ * `BRANDING_ORGANIZATION_MAX`, `BRANDING_URL_MAX`) and must stay equal: a connector refused below the
+ * web form's limit, or accepted above it and refused further in, is one value with two answers.
+ * The Google tag's is its own — the longest id any Google product issues is well under it.
+ */
+export const CONNECT_BRANDING_COPYRIGHT_MAX = 200
+export const CONNECT_BRANDING_ORGANIZATION_MAX = 120
+export const CONNECT_BRANDING_URL_MAX = 2048
+export const CONNECT_BRANDING_GOOGLE_TAG_MAX = 32
+
 /** The access-token prefix the platform issues. Every connector token starts with it. */
 export const CONNECT_TOKEN_PREFIX = 'vib_'
 
@@ -393,6 +406,15 @@ export const connect = Object.freeze({
     llm: 'viable:manager-api:connect:project:llm',
     /** The per-project converter inference mode. Separate from `llm`: it is not a paid capability. */
     converterLlm: 'viable:manager-api:connect:project:converter-llm',
+    /**
+     * The project's own branding — copyright, organization, the two legal links, the Google tag.
+     * The platform credit is deliberately NOT here: hiding it is a paid capability with its own
+     * gated route, and a connector setting the rest must never be able to touch it.
+     */
+    branding: Object.freeze({
+      get: 'viable:manager-api:connect:project:branding:get',
+      save: 'viable:manager-api:connect:project:branding:save',
+    }),
   }),
   story: Object.freeze({
     status: 'viable:manager-api:connect:story:status',

package/src/connect/entrypoints.ts

@@ -7,14 +7,15 @@ import {
   ConnectAttachBodySchema, ConnectConfirmBodySchema, ConnectConvertCreateBodySchema,
   ConnectConvertProceedBodySchema, ConnectCreateBodySchema, ConnectInquiryParamsSchema,
   ConnectModifyBodySchema, ConnectOpParamsSchema, ConnectOpResultSchema,
-  ConnectPipelineParamsSchema, ConnectPipelineResumeBodySchema, ConnectProjectIdSchema,
-  ConnectProjectLlmBodySchema, ConnectSessionOpenSchema, ConnectSessionParamsSchema,
-  ConnectPullQuerySchema, ConnectStoryParamsSchema, InquiryAnswerSchema,
+  ConnectPipelineParamsSchema, ConnectPipelineResumeBodySchema, ConnectProjectBrandingSaveSchema,
+  ConnectProjectIdSchema, ConnectProjectLlmBodySchema, ConnectSessionOpenSchema,
+  ConnectSessionParamsSchema, ConnectPullQuerySchema, ConnectStoryParamsSchema, InquiryAnswerSchema,
 } from './schemas.js'
 import type {
   ConnectAttachBody, ConnectConfirmBody, ConnectConvertCreateBody, ConnectConvertProceedBody,
   ConnectCreateBody, ConnectInquiryAnswerBody, ConnectModifyBody,
-  ConnectPipelineParams, ConnectPipelineResumeBody, ConnectProjectLlmBody, ConnectSessionOpen,
+  ConnectPipelineParams, ConnectPipelineResumeBody, ConnectProjectBranding,
+  ConnectProjectBrandingSave, ConnectProjectLlmBody, ConnectSessionOpen,
   ConnectPipelineState, ConnectProjectStatus, ConnectPullQuery, ConnectSessionParams,
   ConnectStoryStatus, ConversionStatusView, ConvertCheck,
 } from './types.js'
@@ -188,6 +189,27 @@ export const connectProtocols = (opts: ConnectEntrypointOptions) => {
         body: typed<ConverterProjectLlmBody>(ConverterProjectLlmBodySchema),
       }, typed()),
     ),
+    // Under `base` like every sibling — the guard and the ownership gate — and never under the
+    // paid gate: saving branding is free, and the paid credit switch is not reachable from here.
+    branding: {
+      get: protocol(
+        route(connect.project.branding.get, '/project/:id/branding', {
+          parent: base, method: RouteMethod.GET,
+        }),
+        contract.request({
+          params: typed<{ id: string }>(ConnectProjectIdSchema),
+        }, typed<ConnectProjectBranding>()),
+      ),
+      save: protocol(
+        route(connect.project.branding.save, '/project/:id/branding', {
+          parent: base, method: RouteMethod.POST,
+        }),
+        contract.request({
+          params: typed<{ id: string }>(ConnectProjectIdSchema),
+          body: typed<ConnectProjectBrandingSave>(ConnectProjectBrandingSaveSchema),
+        }, typed<ConnectProjectBranding>()),
+      ),
+    },
     },
 
     story: {

package/src/connect/references.ts

@@ -8,9 +8,10 @@ import type {
   ConnectAttachBody, ConnectCapabilitiesView, ConnectConfirmBody, ConnectCreateBody,
   ConnectConvertCreateBody, ConnectConvertProceedBody, ConnectInquiryAnswerBody,
   ConnectModifyBody, ConnectOpSubmission, ConnectPipelineParams, ConnectPipelineResumeBody,
-  ConnectPipelineState, ConnectProjectLlmBody, ConnectProjectSettings, ConnectProjectStatus,
-  ConnectProjectSummary, ConnectPullQuery, ConnectSessionOpen, ConnectSessionParams,
-  ConnectSessionView, ConnectStoryStatus, ConversionStatusView, ConvertCheck,
+  ConnectPipelineState, ConnectProjectBranding, ConnectProjectBrandingSave, ConnectProjectLlmBody,
+  ConnectProjectSettings, ConnectProjectStatus, ConnectProjectSummary, ConnectPullQuery,
+  ConnectSessionOpen, ConnectSessionParams, ConnectSessionView, ConnectStoryStatus,
+  ConversionStatusView, ConvertCheck,
 } from './types.js'
 
 type ConnectReference<Request extends RequestShape, Response> =
@@ -44,6 +45,12 @@ export interface ConnectReferences {
     converterLlm: ConnectReference<{
       params: { id: string }, body: ConverterProjectLlmBody
     }, ConnectProjectSettings>
+    branding: {
+      get: ConnectReference<{ params: { id: string } }, ConnectProjectBranding>
+      save: ConnectReference<{
+        params: { id: string }, body: ConnectProjectBrandingSave
+      }, ConnectProjectBranding>
+    }
   }
   story: {
     status: ConnectReference<{ params: { id: string, storyId: string } }, ConnectStoryStatus>
@@ -110,6 +117,12 @@ export const connectRef: ConnectReferences = {
     converterLlm: entrypointRef<{
       params: { id: string }, body: ConverterProjectLlmBody
     }, ConnectProjectSettings>(connect.project.converterLlm),
+    branding: {
+      get: entrypointRef<{ params: { id: string } }, ConnectProjectBranding>(connect.project.branding.get),
+      save: entrypointRef<{
+        params: { id: string }, body: ConnectProjectBrandingSave
+      }, ConnectProjectBranding>(connect.project.branding.save),
+    },
   },
   story: {
     status: entrypointRef<{

package/src/connect/schemas.ts

@@ -1,15 +1,17 @@
 import type { JSONSchemaType } from 'ajv'
 import { ConversionDecision, OriginKind } from '../convert/consts.js'
 import {
-  CONNECT_INQUIRY_MAX_TEXT, ConnectHarness, ConnectLlm, ConnectOpErrorKind, ConnectSessionStatus,
-  ConnectTarget, ConnectTransport, ModelTaskResultKind, ModelTier
+  CONNECT_BRANDING_COPYRIGHT_MAX, CONNECT_BRANDING_GOOGLE_TAG_MAX,
+  CONNECT_BRANDING_ORGANIZATION_MAX, CONNECT_BRANDING_URL_MAX, CONNECT_INQUIRY_MAX_TEXT,
+  ConnectHarness, ConnectLlm, ConnectOpErrorKind, ConnectSessionStatus, ConnectTarget,
+  ConnectTransport, ModelTaskResultKind, ModelTier
 } from './consts.js'
 import type { ConnectOpResult, InquiryAnswerPayload } from './ops.js'
 import type {
   ConnectAttachBody, ConnectConfirmBody, ConnectConvertCreateBody, ConnectConvertProceedBody,
   ConnectCreateBody, ConnectLlmBody, ConnectModifyBody, ConnectPipelineParams,
-  ConnectPipelineResumeBody, ConnectProjectLlmBody, ConnectSession, ConnectSessionOpen,
-  ConnectPullQuery, ConnectSessionParams
+  ConnectPipelineResumeBody, ConnectProjectBrandingSave, ConnectProjectLlmBody, ConnectSession,
+  ConnectSessionOpen, ConnectPullQuery, ConnectSessionParams
 } from './types.js'
 
 /**
@@ -313,6 +315,33 @@ export const ConnectProjectLlmBodySchema = {
   additionalProperties: false,
 } as unknown as JSONSchemaType<ConnectProjectLlmBody>
 
+/**
+ * The branding patch a connector saves.
+ *
+ * STRUCTURAL only — lengths and types. What makes a value acceptable (a non-empty copyright and
+ * organization, a legal link that is `https://` or a same-origin path, a real Google tag id) is the
+ * platform's rule, applied by the handler to the MERGED record with the same checks the web form
+ * uses; a pattern repeated here would be a second copy of those rules free to drift from the first.
+ * No `pattern`, and no `enum` on the tag: a connector and the platform deploy apart, and a tag kind
+ * Google adds later must be refused by the rule that knows about it, not by a stale wire schema.
+ */
+export const ConnectProjectBrandingSaveSchema = {
+  type: 'object',
+  properties: {
+    copyright: {
+      type: 'string', minLength: 1, maxLength: CONNECT_BRANDING_COPYRIGHT_MAX, nullable: true,
+    },
+    organizationName: {
+      type: 'string', minLength: 1, maxLength: CONNECT_BRANDING_ORGANIZATION_MAX, nullable: true,
+    },
+    termsUrl: { type: 'string', maxLength: CONNECT_BRANDING_URL_MAX, nullable: true },
+    privacyUrl: { type: 'string', maxLength: CONNECT_BRANDING_URL_MAX, nullable: true },
+    googleTag: { type: 'string', maxLength: CONNECT_BRANDING_GOOGLE_TAG_MAX, nullable: true },
+  },
+  required: [],
+  additionalProperties: false,
+} as unknown as JSONSchemaType<ConnectProjectBrandingSave>
+
 export const ModelTaskResultSchema = {
   type: 'object',
   properties: {

package/src/connect/types.ts

@@ -223,6 +223,34 @@ export interface ConnectProjectLlmBody {
   llmMode: ConnectLlm | null
 }
 
+/**
+ * A project's branding as a connector reads it — what the generated application says about who
+ * made it, and the Google tag it loads.
+ *
+ * Every field is a string, `''` when unset, in the platform's own branding vocabulary. The
+ * platform credit is absent on purpose: hiding it is a paid capability behind its own gated route,
+ * and neither reading nor saving this record may reach it.
+ */
+export interface ConnectProjectBranding {
+  /** The copyright line in the application's footer. Never empty once saved. */
+  copyright: string
+  /** The organization's display name. Never empty once saved. */
+  organizationName: string
+  /** `''`, an `https://` URL, or a same-origin path such as `/terms` (the generated page). */
+  termsUrl: string
+  /** `''`, an `https://` URL, or a same-origin path such as `/privacy` (the generated page). */
+  privacyUrl: string
+  /** `''`, or a Google tag id: `GTM-…`, `G-…`, `GT-…`, `AW-…`, `DC-…`. */
+  googleTag: string
+}
+
+/**
+ * A PATCH of a project's branding: every field optional, and an absent field keeps its current
+ * value. The platform merges it over what is stored, validates the result as a whole with the
+ * rules the web form uses, and answers the merged record.
+ */
+export interface ConnectProjectBrandingSave extends Partial<ConnectProjectBranding> {}
+
 /** What the platform tells a connector about itself. */
 export interface ConnectCapabilitiesView {
   /** Tier → the platform role names that will be asked for at that tier. */

package/src/consts.ts

@@ -17,6 +17,9 @@ export const metadataConfigs = [
   'brandingPrivacyUrl',
   'brandingCredit',
   'brandingHideCreditIntent',
+  // Optional in `SlotConstMetadata`: omitted from a push while unset (an older publisher refuses
+  // an undeclared key), so an empty stored row must never be delivered as `''`.
+  'brandingGoogleTag',
 ] satisfies (keyof NonSecretScalarSlotMetadata)[]
 
 export const metadataLists = [

package/src/metadata/types.ts

@@ -116,6 +116,12 @@ export interface StoryMeta extends Record<string, unknown> {
    * that moves section when it is implemented leaves its own dashboard behind.
    */
   section?: string
+  /**
+   * This is the landing gate's story — a guest starts it on the landing page and continues here
+   * after signing in. Copied from the card's `fields.landing`; written only when `true`, so every
+   * other story's file keeps the shape it always had.
+   */
+  landing?: boolean
   entity: string
   entities: string[]
   screens: StoryScreenRef[]
@@ -153,6 +159,8 @@ export interface StoryWriteInput {
   narrative: string
   status: string
   primary: boolean
+  /** The card's landing flag — see {@link StoryMeta.landing}. Absent reads as `false`. */
+  landing?: boolean
   /** Carried through a develop run so the rewrite does not drop the scaffold's assignment. */
   section?: string
   /** Likewise the reserved screen name. */

package/src/planning/helpers.ts

@@ -115,19 +115,22 @@ export const projectBriefOf = (project: Workcard, specs: readonly Specification[
  * What the metadata store writes to `docs/stories/<code>.md`, from the card and a run's content.
  *
  * The CODE is the target's only story identifier — a card id never reaches a target file — so a
- * story card without one is refused rather than filed under its id.
+ * story card without one is refused rather than filed under its id. The landing flag is carried
+ * only when it is set, so every other story's frontmatter keeps the shape it always had.
  */
 export const storyWriteInputOf = (card: Workcard, content: StoryWriteContent): StoryWriteInput => {
   if (card.code == null || card.code === '') {
     throw new ProjectStoryMissconfigured('no-code')
   }
   const { status, ...rest } = content
+  const fields = storyFieldsOf(card)
 
   return {
     ...rest,
     code: card.code,
     narrative: card.title,
     status: status ?? card.status,
-    primary: storyFieldsOf(card).primary,
+    primary: fields.primary,
+    ...(fields.landing === true ? { landing: true } : {}),
   }
 }

package/src/planning/index.ts

@@ -3,4 +3,5 @@ export * from './errors.js'
 export * from './schemas.js'
 export * from './flows.js'
 export * from './helpers.js'
+export * from './landing.js'
 export type * from './types.js'

package/src/planning/landing.ts

@@ -0,0 +1,43 @@
+import { TITLE_MAX } from '@owlmeans/planning'
+
+/**
+ * The sentence a landing story's narrative carries — what a person reading the board sees.
+ *
+ * The AUTHORITY is the card's `fields.landing` flag, never this text: the design and development
+ * stages key on the flag, and a person may reword the narrative at any time. The sentence exists so
+ * the board says in plain words why this story is different, and so the analyst and the designer,
+ * who read the narrative, write a screen that continues what the guest started.
+ *
+ * A constant, byte for byte, because {@link hasLandingSentence} is how a resumed decision step
+ * knows it already appended it.
+ */
+export const LANDING_STORY_SENTENCE = 'A visitor can start this on the landing page without an account;'
+  + ' after signing in they continue here with their choices carried over.'
+
+const normalized = (text: string): string => text.replace(/\s+/g, ' ')
+
+/** Whether a narrative already carries the landing sentence, whatever whitespace surrounds it. */
+export const hasLandingSentence = (title: string): boolean =>
+  normalized(title).includes(LANDING_STORY_SENTENCE)
+
+/**
+ * The narrative with the landing sentence appended once.
+ *
+ * Idempotent — a narrative that already carries the sentence comes back unchanged, so a decision
+ * step that is resumed after it wrote the card never appends a second copy. It never produces a
+ * title longer than a card accepts (`TITLE_MAX`): a narrative with no room left is returned as it
+ * is rather than cut, because a person's words are worth more than the note, and the flag on the
+ * card still carries the fact.
+ */
+export const withLandingSentence = (title: string): string => {
+  if (hasLandingSentence(title)) {
+    return title
+  }
+  const base = title.trimEnd()
+  if (base === '') {
+    return LANDING_STORY_SENTENCE
+  }
+  const joined = `${base} ${LANDING_STORY_SENTENCE}`
+
+  return joined.length > TITLE_MAX ? title : joined
+}

package/src/planning/schemas.ts

@@ -28,6 +28,18 @@ export const ViableProjectFieldsSchema = {
     origin: { ...ProjectOriginSchema, nullable: true },
     connectLlmMode: { type: 'string', enum: [...Object.values(ConnectLlm), null], nullable: true },
     converterLlmMode: { type: 'string', enum: [...Object.values(ConnectLlm), null], nullable: true },
+    // `story: null` is a DECIDED "no gate" and must stay spellable; an absent `landing` is "never
+    // decided". `at` carries no `format`: the planning registry compiles without ajv-formats.
+    landing: {
+      type: 'object',
+      nullable: true,
+      properties: {
+        story: { type: 'string', minLength: 1, maxLength: CODE_MAX, nullable: true },
+        at: { type: 'string', minLength: 1, maxLength: 32 },
+      },
+      required: ['at'],
+      additionalProperties: false,
+    },
   },
   required: [],
   additionalProperties: false,
@@ -48,6 +60,7 @@ export const ViableStoryFieldsSchema = {
     actor: { type: 'string', enum: [...Object.values(StoryActor), null], nullable: true },
     warning: { type: 'string', maxLength: 1024, nullable: true },
     kind: { type: 'string', enum: [...Object.values(StoryKind), null], nullable: true },
+    landing: { type: 'boolean', nullable: true },
   },
   required: ['area', 'primary'],
   additionalProperties: false,

package/src/planning/types.ts

@@ -32,6 +32,23 @@ export type ViableProjectFields = {
   connectLlmMode?: ConnectLlm
   /** Who performs a conversion's model calls on this project; absent inherits. */
   converterLlmMode?: ConnectLlm
+  /**
+   * The landing-gate decision: which story a guest can start on the landing page.
+   *
+   * Three states, and the third is why this is an object rather than a code: ABSENT means the
+   * decision was never made (an initialization that has not reached it, or a project older than
+   * the gate), `story: null` means it WAS made and the answer is "no gate", and a code names the
+   * story. A failed decision is never recorded — writing `null` for it would read as a decided
+   * "none" and no later run would ask again. `at` is when it was decided, an ISO timestamp.
+   */
+  landing?: ViableLandingDecision
+}
+
+/** The recorded landing-gate decision — see {@link ViableProjectFields.landing}. */
+export interface ViableLandingDecision {
+  /** The story card's CODE, or `null` for a decided "no gate". */
+  story: string | null
+  at: string
 }
 
 /**
@@ -51,6 +68,15 @@ export type ViableStoryFields = {
   warning?: string
   /** Which half of the analysis the story came from. */
   kind?: StoryKind
+  /**
+   * The story a guest starts on the landing page — the landing gate's story. At most one per
+   * project, and the project card's `fields.landing.story` names the same code.
+   *
+   * Its development gains a step that replaces the gate's sketch on the guest home with the real
+   * component, and its full-scale screen reads the choices the guest carried over. Absent and
+   * `false` read the same.
+   */
+  landing?: boolean
 }
 
 export interface ViableProjectCard extends Project {
@@ -67,9 +93,9 @@ export type ViableSpecification = Specification
 /**
  * What a develop run hands the metadata store beside the card.
  *
- * The code, the narrative and the primary flag are the CARD's and are never passed separately — a
- * second copy is a second answer. `status` defaults to the card's own.
+ * The code, the narrative, the primary flag and the landing flag are the CARD's and are never
+ * passed separately — a second copy is a second answer. `status` defaults to the card's own.
  */
 export type StoryWriteContent =
-  & Omit<StoryWriteInput, 'code' | 'narrative' | 'primary' | 'status'>
+  & Omit<StoryWriteInput, 'code' | 'narrative' | 'primary' | 'landing' | 'status'>
   & { status?: string }

package/src/scaffold/consts.ts

@@ -1,3 +1,5 @@
+import type { BentoFragmentKind } from './types.js'
+
 /**
  * The shapes a drawn widget can take.
  *
@@ -24,3 +26,11 @@ export const AREA_HOME_WIDGET_CAP = 3
 
 /** Sections per area beyond which a top menu stops being navigable. */
 export const AREA_SECTION_CAP = 6
+
+/**
+ * The shapes a landing page's bento fragment can take.
+ *
+ * A closed set for the same reason as {@link WidgetKind}: each value is one stamped primitive, so a
+ * value nothing can draw is a tile with an empty bottom.
+ */
+export const BENTO_FRAGMENT_KINDS: BentoFragmentKind[] = ['list', 'note', 'people', 'steps']