@owlmeans/viable-common 0.0.43 → 0.0.45

package/src/areas/tenancy.ts

@@ -1,69 +1,34 @@
 import type { Blueprint } from '../blueprint/types.js'
-import { ProjectArea } from './consts.js'
+import { ProjectArea, NO_TENANCY } from './consts.js'
+import type { ProjectTenancy } from './types.js'
+import type { TenancyHelper } from './tenancy/types.js'
 
-/**
- * Whether a generated application splits its audiences into tenant ORGANIZATIONS.
- *
- * Two flags rather than one, because the two audiences split independently: one back office can
- * serve end users who each belong to their own company (`users` only), every reseller can run its
- * own staff over one shared public (`operators` only), and a B2B tool usually does both. An
- * organization is an IAM-managed tenant — never a table the target keeps for itself.
- *
- * Both false is today's application: one organization, the project owner's, that every person acts in.
- */
-export interface ProjectTenancy {
-  /** The staff of the back office are split into tenant organizations. */
-  operators: boolean
-  /** The end users of the front office are distributed across tenant organizations. */
-  users: boolean
-}
+export const createTenancyHelper = (): TenancyHelper => {
+  const tenancyOf = (blueprint?: Pick<Blueprint, 'experience'> | null): ProjectTenancy => {
+    const tenancy = blueprint?.experience?.tenancy
+    const operators = tenancy?.operators === true
+    const users = tenancy?.users === true
 
-/**
- * A tenancy decision as the project card records it (`fields.tenancy`).
- *
- * The flags plus where they came from. `quotes` are the requester's OWN sentences, verbatim — the
- * evidence a later reader (a person reviewing the board, a run asked to reconsider) checks the
- * decision against, which a paraphrase would quietly replace with the model's reading of it.
- * `by` says whether a model inferred it or the owner set it; `at` is when, an ISO timestamp.
- */
-export interface ViableTenancyDecision extends ProjectTenancy {
-  quotes?: { operators?: string; users?: string }
-  by: 'model' | 'owner'
-  at: string
-}
+    return operators || users ? Object.freeze({ operators, users }) : NO_TENANCY
+  }
 
-/** The longest requester sentence a tenancy decision quotes — a card refuses a longer one. */
-export const TENANCY_QUOTE_MAX = 1024
+  const tenantedArea = (area: ProjectArea, tenancy: ProjectTenancy): boolean => {
+    switch (area) {
+      case ProjectArea.User: return tenancy.users === true
+      case ProjectArea.Operator: return tenancy.operators === true
+      default: return false
+    }
+  }
 
-/** A single-organization application — what every project is until a decision says otherwise. */
-export const NO_TENANCY: ProjectTenancy = Object.freeze({ operators: false, users: false })
+  return { tenancyOf, tenantedArea }
+}
 
-/**
- * The tenancy of a resolved blueprint.
- *
- * Total, like `landingGatePreferenceOf`: an absent layer, an absent key and a value this deploy
- * cannot read all answer {@link NO_TENANCY}. Only a literal `true` turns a flag on, because a flag
- * read as on by mistake splits a product's people into organizations nobody asked for, while one
- * read as off leaves the application exactly as it was before tenancy existed.
- */
-export const tenancyOf = (blueprint?: Pick<Blueprint, 'experience'> | null): ProjectTenancy => {
-  const tenancy = blueprint?.experience?.tenancy
-  const operators = tenancy?.operators === true
-  const users = tenancy?.users === true
+export const tenancyHelper = createTenancyHelper()
 
-  return operators || users ? Object.freeze({ operators, users }) : NO_TENANCY
-}
+/** @deprecated compat:factory-refactor — use `tenancyHelper.tenancyOf(…)` */
+export const tenancyOf = (blueprint?: Pick<Blueprint, 'experience'> | null): ProjectTenancy =>
+  tenancyHelper.tenancyOf(blueprint)
 
-/**
- * Whether an AREA's people act inside a tenant organization.
- *
- * Guest has no organization to act in, and admin is the project owner, who stands above every
- * tenant rather than inside one — so both are never tenanted, whatever the flags say.
- */
-export const tenantedArea = (area: ProjectArea, tenancy: ProjectTenancy): boolean => {
-  switch (area) {
-    case ProjectArea.User: return tenancy.users === true
-    case ProjectArea.Operator: return tenancy.operators === true
-    default: return false
-  }
-}
+/** @deprecated compat:factory-refactor — use `tenancyHelper.tenantedArea(…)` */
+export const tenantedArea = (area: ProjectArea, tenancy: ProjectTenancy): boolean =>
+  tenancyHelper.tenantedArea(area, tenancy)

package/src/areas/types.ts

@@ -27,3 +27,34 @@ export interface NavEntry {
   alias: string
   label: string
 }
+
+/**
+ * Whether a generated application splits its audiences into tenant ORGANIZATIONS.
+ *
+ * Two flags rather than one, because the two audiences split independently: one back office can
+ * serve end users who each belong to their own company (`users` only), every reseller can run its
+ * own staff over one shared public (`operators` only), and a B2B tool usually does both. An
+ * organization is an IAM-managed tenant — never a table the target keeps for itself.
+ *
+ * Both false is today's application: one organization, the project owner's, that every person acts in.
+ */
+export interface ProjectTenancy {
+  /** The staff of the back office are split into tenant organizations. */
+  operators: boolean
+  /** The end users of the front office are distributed across tenant organizations. */
+  users: boolean
+}
+
+/**
+ * A tenancy decision as the project card records it (`fields.tenancy`).
+ *
+ * The flags plus where they came from. `quotes` are the requester's OWN sentences, verbatim — the
+ * evidence a later reader (a person reviewing the board, a run asked to reconsider) checks the
+ * decision against, which a paraphrase would quietly replace with the model's reading of it.
+ * `by` says whether a model inferred it or the owner set it; `at` is when, an ISO timestamp.
+ */
+export interface ViableTenancyDecision extends ProjectTenancy {
+  quotes?: { operators?: string; users?: string }
+  by: 'model' | 'owner'
+  at: string
+}

package/src/ba/connecting/types.ts

@@ -0,0 +1,45 @@
+import type { StoryDraft } from '../../areas/types.js'
+import type { ConnectingStoryDraft, MergedStoryDraft } from '../types.js'
+
+/** The connecting stories of a flow: how many it may carry, and where each one lands. */
+export interface ConnectingStoryHelper {
+  /**
+   * How many connecting stories one flow may carry.
+   *
+   * An N-step chain has N-1 joints, and a connecting story exists to bridge one of them — so the
+   * flow sizes its own supporting cast, and a three-step product can never end up with eight list
+   * screens. It is a CEILING, not a target: the prompt is told to write as few as its rules actually
+   * derived, and most flows land well below this.
+   *
+   * The real reason for a hard number: every story here becomes a full develop run the project's
+   * owner pays for.
+   */
+  connectingStoryCap: (flowCount: number) => number
+  /**
+   * Interleave the connecting stories into the flow they were derived from.
+   *
+   * `after` is an ANCHOR, not a position: it names the flow story whose result the connecting story
+   * displays, so the connecting story lands immediately behind it — which is also immediately in
+   * front of the step it leads into. The result is ONE ordered list, and it is the order records are
+   * created in.
+   *
+   * This is the only place the anchor is interpreted. Both halves of the feature — the prompt that
+   * produces it and the pipeline that persists the result — read it through here, or the two drift
+   * and nothing fails loudly enough to notice. The CLAMPED anchor is carried out on each connective
+   * entry as `after`, which is what the story card's `follows` relationship is written from.
+   *
+   * Four properties are deliberate:
+   *
+   * - **The flow subsequence is never disturbed.** Strip the connecting stories back out and you have
+   *   `flow`, in `flow` order: story N still implements numbered step N. Everything that finds the
+   *   primary story depends on that.
+   * - **Nothing precedes the first flow story.** An anchor below 1 is clamped up rather than opening a
+   *   position in front of the flow — nothing can be listed before the step that produced it, and
+   *   story 1 stays the enabling action.
+   * - **A placement is advice; the story is work already paid for.** An anchor past the end means
+   *   "at the end", and one that is not a number at all means the front of the flow. Neither is a
+   *   reason to lose a story.
+   * - **Ties keep the model's order**, which is the only ranking anything has.
+   */
+  mergeConnectingStories: (flow: StoryDraft[], connecting: ConnectingStoryDraft[]) => MergedStoryDraft[]
+}

package/src/ba/connecting.ts

@@ -0,0 +1,64 @@
+import type { StoryDraft } from "../areas/types.js"
+import type { ConnectingStoryDraft, MergedStoryDraft } from "./types.js"
+import { StoryKind } from "./consts.js"
+import type { ConnectingStoryHelper } from './connecting/types.js'
+
+export const createConnectingStoryHelper = (): ConnectingStoryHelper => {
+  const connectingStoryCap = (flowCount: number): number => Math.max(flowCount - 1, 0)
+
+  /** Collapse case and whitespace, so "the same story twice" is recognised as such. */
+  const canonical = (story: string): string => story.trim().replace(/\s+/g, ' ').toLowerCase()
+
+  const mergeConnectingStories = (
+    flow: StoryDraft[], connecting: ConnectingStoryDraft[]
+  ): MergedStoryDraft[] => {
+    if (flow.length < 1) {
+      return []
+    }
+
+    const seen = new Set(flow.map(({ story }) => canonical(story)))
+    const placed: Array<{ draft: ConnectingStoryDraft, at: number }> = []
+
+    for (const draft of connecting) {
+      const text = canonical(draft.story)
+      // A connecting story that repeats a flow story is not a second story: it is one develop run
+      // spent twice AND — since the home-screen detector matches its answer back by exact text — a
+      // second record that answer could resolve to.
+      if (text === '' || seen.has(text)) {
+        continue
+      }
+      seen.add(text)
+
+      const after = Number(draft.after)
+      placed.push({
+        draft,
+        at: Number.isFinite(after) ? Math.min(Math.max(Math.trunc(after), 1), flow.length) : 1,
+      })
+    }
+
+    // Over the cap, the LATEST-anchored go: a story late in the flow gates the fewest steps behind
+    // it, while the queue that hands step 1 to step 2 is what makes everything after it reachable.
+    // The sort is stable, so two stories on the same step keep the order they were derived in.
+    const surviving = placed
+      .map((entry, order) => ({ ...entry, order }))
+      .sort((a, b) => a.at - b.at || a.order - b.order)
+      .slice(0, connectingStoryCap(flow.length))
+
+    // Bucket N holds what comes immediately after flow story N (1-based, as the prompt numbers them).
+    const buckets: ConnectingStoryDraft[][] = flow.map(() => [])
+    for (const { draft, at } of surviving) {
+      buckets[at - 1]!.push(draft)
+    }
+
+    return flow.flatMap(({ story, area }, index) => [
+      { story, area, kind: StoryKind.Flow },
+      ...buckets[index]!.map(draft => (
+        { story: draft.story.trim(), area: draft.area, kind: StoryKind.Connective, after: index + 1 }
+      )),
+    ])
+  }
+
+  return { connectingStoryCap, mergeConnectingStories }
+}
+
+export const connectingStoryHelper = createConnectingStoryHelper()

package/src/ba/helpers.ts

@@ -1,94 +1,10 @@
-import type { StoryDraft } from "../areas/types.js"
-import type { ConnectingStoryDraft, MergedStoryDraft } from "./types.js"
-import { StoryKind } from "./consts.js"
+import type { StoryDraft } from '../areas/types.js'
+import { connectingStoryHelper } from './connecting.js'
+import type { ConnectingStoryDraft, MergedStoryDraft } from './types.js'
 
-/**
- * How many connecting stories one flow may carry.
- *
- * An N-step chain has N-1 joints, and a connecting story exists to bridge one of them — so the
- * flow sizes its own supporting cast, and a three-step product can never end up with eight list
- * screens. It is a CEILING, not a target: the prompt is told to write as few as its rules actually
- * derived, and most flows land well below this.
- *
- * The real reason for a hard number: every story here becomes a full develop run the project's
- * owner pays for.
- */
-export const connectingStoryCap = (flowCount: number): number => Math.max(flowCount - 1, 0)
+/** @deprecated compat:factory-refactor — use `connectingStoryHelper.connectingStoryCap(…)` */
+export const connectingStoryCap = (flowCount: number): number => connectingStoryHelper.connectingStoryCap(flowCount)
 
-/** Collapse case and whitespace, so "the same story twice" is recognised as such. */
-const canonical = (story: string): string => story.trim().replace(/\s+/g, ' ').toLowerCase()
-
-/**
- * Interleave the connecting stories into the flow they were derived from.
- *
- * `after` is an ANCHOR, not a position: it names the flow story whose result the connecting story
- * displays, so the connecting story lands immediately behind it — which is also immediately in
- * front of the step it leads into. The result is ONE ordered list, and it is the order records are
- * created in.
- *
- * This is the only place the anchor is interpreted. Both halves of the feature — the prompt that
- * produces it and the pipeline that persists the result — read it through here, or the two drift
- * and nothing fails loudly enough to notice. The CLAMPED anchor is carried out on each connective
- * entry as `after`, which is what the story card's `follows` relationship is written from.
- *
- * Four properties are deliberate:
- *
- * - **The flow subsequence is never disturbed.** Strip the connecting stories back out and you have
- *   `flow`, in `flow` order: story N still implements numbered step N. Everything that finds the
- *   primary story depends on that.
- * - **Nothing precedes the first flow story.** An anchor below 1 is clamped up rather than opening a
- *   position in front of the flow — nothing can be listed before the step that produced it, and
- *   story 1 stays the enabling action.
- * - **A placement is advice; the story is work already paid for.** An anchor past the end means
- *   "at the end", and one that is not a number at all means the front of the flow. Neither is a
- *   reason to lose a story.
- * - **Ties keep the model's order**, which is the only ranking anything has.
- */
-export const mergeConnectingStories = (
-  flow: StoryDraft[], connecting: ConnectingStoryDraft[]
-): MergedStoryDraft[] => {
-  if (flow.length < 1) {
-    return []
-  }
-
-  const seen = new Set(flow.map(({ story }) => canonical(story)))
-  const placed: Array<{ draft: ConnectingStoryDraft, at: number }> = []
-
-  for (const draft of connecting) {
-    const text = canonical(draft.story)
-    // A connecting story that repeats a flow story is not a second story: it is one develop run
-    // spent twice AND — since the home-screen detector matches its answer back by exact text — a
-    // second record that answer could resolve to.
-    if (text === '' || seen.has(text)) {
-      continue
-    }
-    seen.add(text)
-
-    const after = Number(draft.after)
-    placed.push({
-      draft,
-      at: Number.isFinite(after) ? Math.min(Math.max(Math.trunc(after), 1), flow.length) : 1,
-    })
-  }
-
-  // Over the cap, the LATEST-anchored go: a story late in the flow gates the fewest steps behind
-  // it, while the queue that hands step 1 to step 2 is what makes everything after it reachable.
-  // The sort is stable, so two stories on the same step keep the order they were derived in.
-  const surviving = placed
-    .map((entry, order) => ({ ...entry, order }))
-    .sort((a, b) => a.at - b.at || a.order - b.order)
-    .slice(0, connectingStoryCap(flow.length))
-
-  // Bucket N holds what comes immediately after flow story N (1-based, as the prompt numbers them).
-  const buckets: ConnectingStoryDraft[][] = flow.map(() => [])
-  for (const { draft, at } of surviving) {
-    buckets[at - 1]!.push(draft)
-  }
-
-  return flow.flatMap(({ story, area }, index) => [
-    { story, area, kind: StoryKind.Flow },
-    ...buckets[index]!.map(draft => (
-      { story: draft.story.trim(), area: draft.area, kind: StoryKind.Connective, after: index + 1 }
-    )),
-  ])
-}
+/** @deprecated compat:factory-refactor — use `connectingStoryHelper.mergeConnectingStories(…)` */
+export const mergeConnectingStories = (flow: StoryDraft[], connecting: ConnectingStoryDraft[]): MergedStoryDraft[] =>
+  connectingStoryHelper.mergeConnectingStories(flow, connecting)

package/src/ba/index.ts

@@ -1,4 +1,6 @@
 
+export * from './connecting.js'
 export * from './helpers.js'
 export * from './consts.js'
 export type * from './types.js'
+export type * from './connecting/types.js'

package/src/ba/types.ts

@@ -2,7 +2,7 @@ import { SpecCategory } from "./consts"
 import type { ConnectingStoryKind, StoryKind } from "./consts.js"
 import type { ProjectArea } from "../areas/consts.js"
 import type { StoryDraft } from "../areas/types.js"
-import type { StoryActor } from "../design/runtime.js"
+import type { StoryActor } from "../design/consts.js"
 
 export interface EntityList {
   entities: string[]

package/src/blueprint/consts.local.ts

@@ -0,0 +1,3 @@
+import { LandingGatePreference } from './consts.js'
+
+export const LANDING_GATE_PREFERENCES = new Set<string>(Object.values(LandingGatePreference))

package/src/blueprint/consts.ts

@@ -85,3 +85,55 @@ export enum WorkKind {
 
 /** The longest case quote a project card keeps (`fields.caseQuote`) — one sentence, generously. */
 export const CASE_QUOTE_MAX = 1024
+
+/**
+ * The layers, lowest first. A higher layer's value replaces the same key from a lower one.
+ *
+ * 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. `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',
+  Stack = 'stack',
+  Template = 'template',
+  CreateApp = 'create-app',
+  Packages = 'packages',
+  Experience = 'experience',
+}
+
+export const BLUEPRINT_LAYER_ORDER: BlueprintLayer[] = [
+  BlueprintLayer.Technology,
+  BlueprintLayer.Stack,
+  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',
+}
+
+export enum BlueprintPatchKind {
+  /** Deep-merge a JSON document — the manifests, the tsconfigs. */
+  JsonMerge = 'json-merge',
+  /** Rewrite the `<head>` of an HTML document from the project's identity. */
+  HtmlHead = 'html-head',
+  /** Write a document composed from the project's identity. */
+  Compose = 'compose',
+}

package/src/blueprint/index.ts

@@ -1,3 +1,4 @@
 export * from './types.js'
+export * from './utils.js'
 
 export * from './consts.js'

package/src/blueprint/types.ts

@@ -1,8 +1,8 @@
-import type { ProjectTenancy } from '../areas/tenancy.js'
+import type { ProjectTenancy } from '../areas/types.js'
 import type { SubProject } from '../slot/consts.js'
-import type { ViableSkill } from '../skills/consts.js'
-import type { ViablePersona } from '../skills/roles.js'
+import type { ViablePersona, ViableSkill } from '../skills/consts.js'
 import type { TopologyDescriptor } from '../topology/types.js'
+import { BlueprintPatchKind, LandingGatePreference } from './consts.js'
 
 /**
  * A BLUEPRINT is everything that decides what kind of project the pipeline is building — the
@@ -35,49 +35,6 @@ export interface Blueprint {
   experience?: ExperienceLayer
 }
 
-/**
- * The layers, lowest first. A higher layer's value replaces the same key from a lower one.
- *
- * 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. `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',
-  Stack = 'stack',
-  Template = 'template',
-  CreateApp = 'create-app',
-  Packages = 'packages',
-  Experience = 'experience',
-}
-
-export const BLUEPRINT_LAYER_ORDER: BlueprintLayer[] = [
-  BlueprintLayer.Technology,
-  BlueprintLayer.Stack,
-  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.
  *
@@ -96,25 +53,6 @@ export interface ExperienceLayer {
   tenancy?: ProjectTenancy
 }
 
-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
@@ -181,15 +119,6 @@ export interface BlueprintPatchSpec {
   kind: BlueprintPatchKind
 }
 
-export enum BlueprintPatchKind {
-  /** Deep-merge a JSON document — the manifests, the tsconfigs. */
-  JsonMerge = 'json-merge',
-  /** Rewrite the `<head>` of an HTML document from the project's identity. */
-  HtmlHead = 'html-head',
-  /** Write a document composed from the project's identity. */
-  Compose = 'compose',
-}
-
 /** Which scaffolder runs first, and how. */
 export interface CreateAppLayer {
   id: string
@@ -259,6 +188,7 @@ export interface BlueprintCapabilities {
   marketingConsent: boolean
 }
 
+// Kept as a type: a mapped type over the blueprint's keys.
 /** A partial override of a blueprint, deep-merged over the resolved value. */
 export type BlueprintPatch = {
   [K in keyof Blueprint]?: Blueprint[K] extends string ? Blueprint[K] : Partial<Blueprint[K]>

package/src/blueprint/utils.ts

@@ -0,0 +1,20 @@
+import { LANDING_GATE_PREFERENCES } from './consts.local.js'
+import { LandingGatePreference } from './consts.js'
+import type { Blueprint } from './types.js'
+
+/**
+ * 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
+}

package/src/branding.ts

@@ -1,22 +1,5 @@
 import type { SlotMetadata } from './types.js'
 
-/**
- * The build-time environment keys a generated application reads its branding from.
- *
- * Named here, once, because two processes emit them — the publisher for the preview and the agent
- * for a production publish — and a key spelled differently in one of them produces an application
- * that silently falls back to its defaults with nothing anywhere reporting it.
- */
-export const BRANDING_ENV_KEYS = [
-  'BRANDING_COPYRIGHT',
-  'BRANDING_ORGANIZATION',
-  'BRANDING_TERMS_URL',
-  'BRANDING_PRIVACY_URL',
-  'BRANDING_CREDIT',
-  'BRANDING_PRODUCT',
-  'BRANDING_GOOGLE_TAG',
-] as const
-
 /**
  * Slot metadata as build-time environment.
  *

package/src/connect/branding/types.ts

@@ -0,0 +1,29 @@
+
+
+/**
+ * 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> {}

package/src/connect/consts.ts

@@ -169,28 +169,6 @@ export const MODEL_TIER_ROLES: Record<string, ModelTier> = {
   'picker': ModelTier.Cheap,
 }
 
-export const tierOfRole = (role: string): ModelTier =>
-  MODEL_TIER_ROLES[role] ?? ModelTier.Standard
-
-/**
- * Pick the best tier a parent actually offers, never below what was asked for by more than the
- * offer allows.
- *
- * A parent that offers only one model answers every task with it; a parent that offers two gets
- * the nearer of the two. Silence is not an option — a task the connector cannot place is a run
- * that stops.
- */
-export const clampTier = (wanted: ModelTier, offered: ModelTier[]): ModelTier => {
-  if (offered.length < 1 || offered.includes(wanted)) return wanted
-  const ladder = [ModelTier.Strong, ModelTier.Standard, ModelTier.Cheap]
-  const from = ladder.indexOf(wanted)
-  // Prefer a stronger model over a weaker one: the task was sized for `wanted`.
-  for (let i = from; i >= 0; --i) if (offered.includes(ladder[i])) return ladder[i]
-  for (let i = from + 1; i < ladder.length; ++i) if (offered.includes(ladder[i])) return ladder[i]
-
-  return wanted
-}
-
 /** What the model task asks the parent's subagent to produce. */
 export enum ModelTaskMode {
   /** Prose or code. */
@@ -434,3 +412,6 @@ export const connect = Object.freeze({
     resume: 'viable:manager-api:connect:pipeline:resume',
   }),
 })
+
+/** Tier → the model the parent will run it on. Free-form; display only. */
+export const ModelTierValues = Object.values(ModelTier)