@owlmeans/viable-common 0.0.43 → 0.0.44

package/src/integrity/utils.ts

@@ -0,0 +1,320 @@
+import { HARNESS_PROTECTED, ROOT_PROTECTED } from './consts.local.js'
+import { TARGET_BUNDLED_PACKAGES, TARGET_CURRENT_LAYOUT, TARGET_LEGACY_BUNDLED_PACKAGES, TARGET_LEGACY_PACKAGES, TARGET_LEGACY_PACKAGES_DIR, TARGET_PACKAGES_DIR, TargetLayout, TargetLegacyPackage, TargetPackage } from './consts.js'
+import type { TargetLayoutManifest } from './types.js'
+
+const fileIn = (dir: string, pkg: string, path: string): string => `${dir}/${pkg}/${path}`
+
+const protectedOf = (
+  dir: string, packages: readonly string[], bundled: readonly string[]
+): readonly string[] => [
+  ...ROOT_PROTECTED,
+  ...HARNESS_PROTECTED,
+  ...packages.flatMap(pkg => [fileIn(dir, pkg, 'package.json'), fileIn(dir, pkg, 'tsconfig.json')]),
+  ...bundled.flatMap(pkg =>
+    [fileIn(dir, pkg, 'rollup.config.js'), fileIn(dir, pkg, 'rollup.build.mjs')]),
+]
+
+const v2 = (pkg: TargetPackage, path: string): string =>
+  fileIn(TARGET_PACKAGES_DIR, pkg, path)
+
+const v1 = (pkg: TargetLegacyPackage, path: string): string =>
+  fileIn(TARGET_LEGACY_PACKAGES_DIR, pkg, path)
+
+/**
+ * The current layout: five workspace packages under `sources/`.
+ *
+ * `common` and `backend` are libraries the other three import, so they emit declarations with
+ * `tsc -b` rather than a bundle; `api`, `web` and `worker` each bundle themselves.
+ */
+const V2_MANIFEST: TargetLayoutManifest = {
+  layout: TargetLayout.V2,
+  dir: TARGET_PACKAGES_DIR,
+  packages: Object.values(TargetPackage),
+  // The same file the publisher's own filesystem detection probes for (`sources/api`), so the
+  // two answers about one volume cannot disagree.
+  probe: v2(TargetPackage.Api, 'package.json'),
+  files: [
+    'package.json',
+    'bunfig.toml',
+    v2(TargetPackage.Common, 'package.json'),
+    v2(TargetPackage.Common, 'tsconfig.json'),
+    v2(TargetPackage.Common, 'src/index.ts'),
+    v2(TargetPackage.Common, 'src/entrypoints.ts'),
+    v2(TargetPackage.Backend, 'package.json'),
+    v2(TargetPackage.Backend, 'tsconfig.json'),
+    v2(TargetPackage.Backend, 'src/index.ts'),
+    v2(TargetPackage.Backend, 'src/context.ts'),
+    v2(TargetPackage.Backend, 'src/config.ts'),
+    v2(TargetPackage.Api, 'package.json'),
+    v2(TargetPackage.Api, 'tsconfig.json'),
+    v2(TargetPackage.Api, 'rollup.config.js'),
+    v2(TargetPackage.Api, 'rollup.build.mjs'),
+    v2(TargetPackage.Api, 'src/index.ts'),
+    v2(TargetPackage.Api, 'src/owlmeans.ts'),
+    v2(TargetPackage.Api, 'src/config.ts'),
+    v2(TargetPackage.Api, 'src/entrypoints.ts'),
+    v2(TargetPackage.Web, 'package.json'),
+    v2(TargetPackage.Web, 'tsconfig.json'),
+    v2(TargetPackage.Web, 'rollup.config.js'),
+    v2(TargetPackage.Web, 'rollup.build.mjs'),
+    v2(TargetPackage.Web, 'src/index.tsx'),
+    v2(TargetPackage.Web, 'src/owlmeans.ts'),
+    v2(TargetPackage.Web, 'src/config.ts'),
+    v2(TargetPackage.Web, 'src/entrypoints.ts'),
+    v2(TargetPackage.Worker, 'package.json'),
+    v2(TargetPackage.Worker, 'tsconfig.json'),
+    v2(TargetPackage.Worker, 'rollup.config.js'),
+    v2(TargetPackage.Worker, 'rollup.build.mjs'),
+    v2(TargetPackage.Worker, 'src/index.ts'),
+    v2(TargetPackage.Worker, 'src/owlmeans.ts'),
+    v2(TargetPackage.Worker, 'src/config.ts'),
+    v2(TargetPackage.Worker, 'src/entrypoints.ts'),
+  ],
+  protectedFiles: protectedOf(
+    TARGET_PACKAGES_DIR, Object.values(TargetPackage), TARGET_BUNDLED_PACKAGES),
+  buildScripts: {
+    [TargetPackage.Common]: 'tsc -b',
+    [TargetPackage.Backend]: 'tsc -b',
+    [TargetPackage.Api]: 'bun ./rollup.build.mjs',
+    [TargetPackage.Web]: 'bun ./rollup.build.mjs',
+    [TargetPackage.Worker]: 'bun ./rollup.build.mjs',
+  },
+  requiredDeps: {
+    [TargetPackage.Common]: ['@owlmeans/context', '@owlmeans/entrypoint'],
+    [TargetPackage.Backend]: ['@owlmeans/context', '@owlmeans/postgres-resource'],
+    [TargetPackage.Api]: ['@owlmeans/server-app'],
+    [TargetPackage.Web]: ['@owlmeans/web-client'],
+    [TargetPackage.Worker]: ['@owlmeans/queue', '@owlmeans/redis-queue'],
+  },
+  // `api` and `worker` both reach the database through `backend`, which is the whole reason
+  // `backend` is a library: two runtimes, one context factory, one set of resources. A `worker`
+  // that stopped depending on `backend` is processing jobs against something else.
+  workspaceDeps: {
+    [TargetPackage.Common]: [],
+    [TargetPackage.Backend]: [TargetPackage.Common],
+    [TargetPackage.Api]: [TargetPackage.Common, TargetPackage.Backend],
+    [TargetPackage.Web]: [TargetPackage.Common],
+    [TargetPackage.Worker]: [TargetPackage.Backend],
+  },
+  workspaceGlob: `${TARGET_PACKAGES_DIR}/*`,
+  workspaceEntries: Object.values(TargetPackage).map(pkg => `${TARGET_PACKAGES_DIR}/${pkg}`),
+  markers: {
+    [v2(TargetPackage.Common, 'src/index.ts')]: ['./entrypoints.js'],
+    [v2(TargetPackage.Backend, 'src/index.ts')]: ['./context.js'],
+    [v2(TargetPackage.Backend, 'src/context.ts')]: ['@owlmeans/context', 'makeContext'],
+    [v2(TargetPackage.Api, 'src/index.ts')]: ['./owlmeans.js', 'initOwlMeans'],
+    [v2(TargetPackage.Api, 'src/owlmeans.ts')]: ['@owlmeans/server-app', 'makeContext'],
+    [v2(TargetPackage.Web, 'src/index.tsx')]: ['@owlmeans/web-client', 'renderApp', './owlmeans'],
+    [v2(TargetPackage.Web, 'src/owlmeans.ts')]: ['makeContext', 'owlCtx'],
+    // The worker binds nothing but its health port; what makes it a worker is that it listens.
+    [v2(TargetPackage.Worker, 'src/index.ts')]: ['./owlmeans.js', 'initOwlMeans'],
+    [v2(TargetPackage.Worker, 'src/owlmeans.ts')]: ['@owlmeans/queue', 'makeContext'],
+    // The build configuration itself: what it reads and what it emits. These are the paths the
+    // publisher spawns and serves, so a config that redirects either one is a different program.
+    // Matched loosely enough to survive the `path.resolve(srcDir, …)` the template writes them
+    // with, and strictly enough that an input or an output somewhere else fails.
+    [v2(TargetPackage.Api, 'rollup.config.js')]: ['input:', 'index.ts', 'dist', 'index.js'],
+    [v2(TargetPackage.Web, 'rollup.config.js')]: ['input:', 'index.tsx', 'dist', 'bundle.js'],
+    [v2(TargetPackage.Worker, 'rollup.config.js')]: ['input:', 'index.ts', 'dist', 'index.js'],
+  },
+}
+
+/**
+ * The legacy layout: three workspace packages under `packages/`.
+ *
+ * Frozen — nothing generates one any more, and every rule here is stated against the trees that
+ * exist rather than against a template this repository still ships (it does not). `backend` is
+ * the HTTP server AND the data layer, which is why it carries both `@owlmeans/server-app` and
+ * `@owlmeans/postgres-resource`; `common` is the only library.
+ */
+const V1_MANIFEST: TargetLayoutManifest = {
+  layout: TargetLayout.V1,
+  dir: TARGET_LEGACY_PACKAGES_DIR,
+  packages: TARGET_LEGACY_PACKAGES,
+  // `packages/backend` again — the publisher's own marker for this layout.
+  probe: v1(TargetLegacyPackage.Backend, 'package.json'),
+  files: [
+    'package.json',
+    'bunfig.toml',
+    v1(TargetLegacyPackage.Common, 'package.json'),
+    v1(TargetLegacyPackage.Common, 'tsconfig.json'),
+    v1(TargetLegacyPackage.Common, 'src/index.ts'),
+    v1(TargetLegacyPackage.Common, 'src/entrypoints.ts'),
+    v1(TargetLegacyPackage.Backend, 'package.json'),
+    v1(TargetLegacyPackage.Backend, 'tsconfig.json'),
+    v1(TargetLegacyPackage.Backend, 'rollup.config.js'),
+    v1(TargetLegacyPackage.Backend, 'rollup.build.mjs'),
+    v1(TargetLegacyPackage.Backend, 'src/index.ts'),
+    v1(TargetLegacyPackage.Backend, 'src/owlmeans.ts'),
+    v1(TargetLegacyPackage.Backend, 'src/config.ts'),
+    v1(TargetLegacyPackage.Backend, 'src/entrypoints.ts'),
+    v1(TargetLegacyPackage.Frontend, 'package.json'),
+    v1(TargetLegacyPackage.Frontend, 'tsconfig.json'),
+    v1(TargetLegacyPackage.Frontend, 'rollup.config.js'),
+    v1(TargetLegacyPackage.Frontend, 'rollup.build.mjs'),
+    v1(TargetLegacyPackage.Frontend, 'src/index.tsx'),
+    v1(TargetLegacyPackage.Frontend, 'src/owlmeans.ts'),
+    v1(TargetLegacyPackage.Frontend, 'src/config.ts'),
+    v1(TargetLegacyPackage.Frontend, 'src/entrypoints.ts'),
+  ],
+  protectedFiles: protectedOf(
+    TARGET_LEGACY_PACKAGES_DIR, TARGET_LEGACY_PACKAGES, TARGET_LEGACY_BUNDLED_PACKAGES),
+  buildScripts: {
+    [TargetLegacyPackage.Common]: 'tsc -b',
+    [TargetLegacyPackage.Backend]: 'bun ./rollup.build.mjs',
+    [TargetLegacyPackage.Frontend]: 'bun ./rollup.build.mjs',
+  },
+  requiredDeps: {
+    [TargetLegacyPackage.Common]: ['@owlmeans/context', '@owlmeans/entrypoint'],
+    [TargetLegacyPackage.Backend]: ['@owlmeans/server-app', '@owlmeans/postgres-resource'],
+    [TargetLegacyPackage.Frontend]: ['@owlmeans/web-client'],
+  },
+  workspaceDeps: {
+    [TargetLegacyPackage.Common]: [],
+    [TargetLegacyPackage.Backend]: [TargetLegacyPackage.Common],
+    [TargetLegacyPackage.Frontend]: [TargetLegacyPackage.Common],
+  },
+  workspaceGlob: `${TARGET_LEGACY_PACKAGES_DIR}/*`,
+  workspaceEntries: TARGET_LEGACY_PACKAGES.map(pkg => `${TARGET_LEGACY_PACKAGES_DIR}/${pkg}`),
+  markers: {
+    [v1(TargetLegacyPackage.Common, 'src/index.ts')]: ['./entrypoints.js'],
+    [v1(TargetLegacyPackage.Backend, 'src/index.ts')]: ['./owlmeans.js', 'initOwlMeans'],
+    [v1(TargetLegacyPackage.Backend, 'src/owlmeans.ts')]: ['@owlmeans/server-app', 'makeContext'],
+    [v1(TargetLegacyPackage.Frontend, 'src/index.tsx')]:
+      ['@owlmeans/web-client', 'renderApp', './owlmeans'],
+    [v1(TargetLegacyPackage.Frontend, 'src/owlmeans.ts')]: ['makeContext', 'owlCtx'],
+    [v1(TargetLegacyPackage.Backend, 'rollup.config.js')]:
+      ['input:', 'index.ts', 'dist', 'index.js'],
+    [v1(TargetLegacyPackage.Frontend, 'rollup.config.js')]:
+      ['input:', 'index.tsx', 'dist', 'bundle.js'],
+  },
+}
+
+/**
+ * Every layout the platform is willing to run, keyed by its own name.
+ *
+ * Declared current-first, and the order is load-bearing: detection walks it and takes the first
+ * probe it finds, so a half-migrated tree carrying both is verified against the layout the
+ * platform generates today rather than against the frozen one.
+ */
+export const TARGET_LAYOUTS: Readonly<Record<TargetLayout, TargetLayoutManifest>> = {
+  [TargetLayout.V2]: V2_MANIFEST,
+  [TargetLayout.V1]: V1_MANIFEST,
+}
+
+/** What one layout asserts. */
+export const targetManifest = (layout: TargetLayout): TargetLayoutManifest =>
+  TARGET_LAYOUTS[layout]
+
+/**
+ * Whether a tree of this layout can still be GENERATED INTO.
+ *
+ * A legacy target is served, built and run exactly like any other — that is the whole point of
+ * verifying it against its own manifest. What no longer works on it is code generation: every
+ * path builder, every stamped import specifier and the whole `docs/` metadata tree name the
+ * current layout's packages, so a story implemented into a legacy tree writes files into
+ * directories its workspace does not contain. That fails silently — the build succeeds, the
+ * story completes and the application does not change — which is why the platform refuses
+ * instead, and names re-initialization as the one cure.
+ *
+ * `undefined` reads as current: a publisher that predates layout reporting omits it, and reading
+ * that silence as legacy would refuse development for every slot already in the cluster.
+ */
+export const isLegacyLayout = (layout: TargetLayout | string | undefined | null): boolean =>
+  layout != null && layout !== TARGET_CURRENT_LAYOUT
+
+/**
+ * The files whose presence tells the layouts apart.
+ *
+ * Each layout's probe is a path the other cannot have. They are members of their own layout's
+ * file list too, so a caller that reads {@link TARGET_INTEGRITY_FILES} always has both in hand —
+ * which is the whole reason detection works at all. It did not before: the probe for the legacy
+ * layout was declared but never read, so `detectTargetLayout` could only ever answer `V2`.
+ */
+export const TARGET_LAYOUT_PROBE_FILES: readonly string[] =
+  Object.values(TARGET_LAYOUTS).map(manifest => manifest.probe)
+
+/**
+ * Which layout a tree is in, from its files alone — IO-free, like everything else here.
+ *
+ * A tree that shows neither probe is reported as the current layout: it is not a target at all,
+ * and the integrity report is what has to say so, in the vocabulary of the layout the platform
+ * generates today.
+ */
+export const detectTargetLayout = (files: Record<string, string | null>): TargetLayout => {
+  for (const manifest of Object.values(TARGET_LAYOUTS)) {
+    if (files[manifest.probe] != null) {
+      return manifest.layout
+    }
+  }
+
+  return TARGET_CURRENT_LAYOUT
+}
+
+/**
+ * Files a caller must read and hand to `verifyTargetShape`.
+ *
+ * The UNION over every layout, because a caller reads before it knows which layout it is holding
+ * and the probes are what settle that. The verifier reports only the files its selected layout
+ * actually requires, so the extra reads cost a `stat` each and never a violation.
+ *
+ * The verifier is pure and does no IO of its own — the publisher reads these from the PVC, and
+ * a test reads them from the template tree. A path that does not exist is passed as `null`,
+ * which the verifier reports rather than skipping: absence is a violation for everything here.
+ */
+export const TARGET_INTEGRITY_FILES: readonly string[] = [
+  ...new Set(Object.values(TARGET_LAYOUTS).flatMap(manifest => manifest.files)),
+]
+
+/**
+ * Files no user-facing write may touch, through any path — the union over every layout.
+ *
+ * These are the ones that decide what gets EXECUTED — the build scripts, the package manifests
+ * that name them, the compiler configuration that resolves them, and the install configuration.
+ * The agent harness is here for the same reason: `.claude/settings.json` declares a
+ * `SessionStart` hook and `.agents/scripts/link-skills.sh` is the command it spawns, so a write
+ * to either runs code in the slot the next time an agent session opens, with no build and no
+ * request involved. The agent's own generator already refuses the wiring sources
+ * (`WIRING_SOURCES`), but that guard is LLM-scoped: it never saw a manual editor save and never
+ * saw a git merge.
+ *
+ * The union rather than the current layout's list, because this is a path-shaped refusal with
+ * nothing to gain from being narrow: a v2 path cannot exist in a v1 tree, so covering both costs
+ * nothing and covers the legacy slots that were left writable.
+ */
+export const TARGET_PROTECTED_FILES: readonly string[] = [
+  ...new Set(Object.values(TARGET_LAYOUTS).flatMap(manifest => manifest.protectedFiles)),
+]
+
+/** `<slug>-<package>` — the only way a workspace package is ever named, in either layout. */
+export const targetPackageName = (slug: string, pkg: string): string => `${slug}-${pkg}`
+
+/** Everything one package must declare, once the root manifest has named the slug. */
+export const targetRequiredDeps = (
+  slug: string, pkg: string, layout: TargetLayout = TARGET_CURRENT_LAYOUT
+): string[] => {
+  const manifest = targetManifest(layout)
+
+  return [
+    ...(manifest.requiredDeps[pkg] ?? []),
+    ...(manifest.workspaceDeps[pkg] ?? []).map(dep => targetPackageName(slug, dep)),
+  ]
+}
+
+/**
+ * The current layout's own rules, kept as named constants because consumers outside the verifier
+ * ask about the tree the platform generates today — never about a frozen one.
+ */
+export const TARGET_BUILD_SCRIPTS: Readonly<Record<string, string>> = V2_MANIFEST.buildScripts
+
+export const TARGET_REQUIRED_DEPS: Readonly<Record<string, readonly string[]>> =
+  V2_MANIFEST.requiredDeps
+
+export const TARGET_WORKSPACE_DEPS: Readonly<Record<string, readonly string[]>> =
+  V2_MANIFEST.workspaceDeps
+
+export const TARGET_ENTRY_MARKERS: Readonly<Record<string, readonly string[]>> = V2_MANIFEST.markers
+
+export const TARGET_WORKSPACE_GLOB = V2_MANIFEST.workspaceGlob
+
+export const TARGET_WORKSPACE_ENTRIES: readonly string[] = V2_MANIFEST.workspaceEntries

package/src/integrity/verify.ts

@@ -1,7 +1,5 @@
-import {
-  detectTargetLayout, IntegrityRule, TARGET_FORBIDDEN_SCRIPTS, TARGET_SLUG_PATTERN,
-  targetManifest, targetPackageName, targetRequiredDeps
-} from './consts.js'
+import { IntegrityRule, TARGET_FORBIDDEN_SCRIPTS, TARGET_SLUG_PATTERN } from './consts.js'
+import { detectTargetLayout, targetManifest, targetPackageName, targetRequiredDeps } from './utils.js'
 import type { IntegrityViolation, TargetFileMap, TargetIntegrityReport } from './types.js'
 
 /**

package/src/intent/consts.local.ts

@@ -0,0 +1,3 @@
+import { INTENT_PAYLOAD_REF } from './consts.js'
+
+export const payloadMap = { [INTENT_PAYLOAD_REF]: 0 }

package/src/intent/entrypoints.ts

@@ -40,4 +40,3 @@ export const makeIntentProtocols = (opts: IntentProtocolOptions = {}) => {
   }
 }
 
-export type IntentProtocols = ReturnType<typeof makeIntentProtocols>

package/src/intent/flow.ts

@@ -1,9 +1,8 @@
 import { DISPATCHER } from '@owlmeans/auth'
 import { HOME } from '@owlmeans/context'
 import type { ShallowFlow } from '@owlmeans/flow'
-import { INTENT_FLOW, INTENT_PAYLOAD_REF, intent, IntentFlowStep } from './consts.js'
-
-const payloadMap = { [INTENT_PAYLOAD_REF]: 0 }
+import { INTENT_FLOW, intent, IntentFlowStep } from './consts.js'
+import { payloadMap } from './consts.local.js'
 
 /**
  * The hand-off flow both sides walk.

package/src/intent/types.ts

@@ -1,4 +1,5 @@
 import type { ResourceRecord } from '@owlmeans/resource'
+import { makeIntentProtocols } from './entrypoints.js'
 
 /** What the public site sends: the prompt and the person's confirmation of its processing. */
 export interface IntentStashBody {
@@ -43,3 +44,5 @@ export interface IntentProtocolOptions {
   /** Path of the landing screen; defaults to `/start`. */
   landing?: string
 }
+
+export type IntentProtocols = ReturnType<typeof makeIntentProtocols>

package/src/metadata/consts.ts

@@ -116,3 +116,40 @@ export const METADATA_SUFFIXES = [SPEC_SUFFIX, UX_SUFFIX, UI_SUFFIX]
 
 /** The trees the pipeline writes into — excluded wholesale when source files are enumerated. */
 export const METADATA_DIRS = [HARNESS_DIR, DOCS_DIR]
+
+export enum MetadataKind {
+  Project = 'project',
+  Story = 'story',
+  Source = 'source',
+  History = 'history',
+}
+
+export enum MetadataListKind {
+  Stories = 'stories',
+  Meta = 'meta',
+  // All metadata: the docs/ and .agents/ trees + co-located *.spec/.ux/.ui.md beside sources
+  All = 'all',
+}
+
+/**
+ * What a registry entry names.
+ *
+ * One entry per artifact the pipeline can generate, so that "where does this live" and "what is
+ * it called" have exactly one answer for the whole life of the project.
+ */
+export enum RegistryKind {
+  /** The single directory segment an entity owns across models/, resources/ and backend models/ */
+  EntityDir = 'entity-dir',
+  ModelType = 'model-type',
+  Resource = 'resource',
+  BackendModel = 'backend-model',
+  ApiHandlers = 'api-handlers',
+  Service = 'service',
+  Layout = 'layout',
+  Screen = 'screen',
+  Component = 'component',
+  ViewModel = 'view-model',
+  State = 'state',
+  /** Alias-only entry for one endpoint — carries no source path of its own */
+  ApiEntrypoint = 'api-entrypoint',
+}

package/src/metadata/types.ts

@@ -1,5 +1,6 @@
 
 import type { SpecCategory } from '../ba/consts.js'
+import { MetadataKind, MetadataListKind, RegistryKind } from './consts.js'
 
 export interface MetadataFile<T extends Record<string, unknown> = Record<string, unknown>> {
   path: string
@@ -12,20 +13,6 @@ export interface MetadataWriteInput<T extends Record<string, unknown> = Record<s
   body: string
 }
 
-export enum MetadataKind {
-  Project = 'project',
-  Story = 'story',
-  Source = 'source',
-  History = 'history',
-}
-
-export enum MetadataListKind {
-  Stories = 'stories',
-  Meta = 'meta',
-  // All metadata: the docs/ and .agents/ trees + co-located *.spec/.ux/.ui.md beside sources
-  All = 'all',
-}
-
 /**
  * Identifies a single metadata document to read:
  * - Project:  kind=Project, no ref/category needed
@@ -181,29 +168,6 @@ export interface StoryWriteInput {
 
 // ─── Name registry (.agents/memory/registry.md) ───────────────────────────────────────
 
-/**
- * What a registry entry names.
- *
- * One entry per artifact the pipeline can generate, so that "where does this live" and "what is
- * it called" have exactly one answer for the whole life of the project.
- */
-export enum RegistryKind {
-  /** The single directory segment an entity owns across models/, resources/ and backend models/ */
-  EntityDir = 'entity-dir',
-  ModelType = 'model-type',
-  Resource = 'resource',
-  BackendModel = 'backend-model',
-  ApiHandlers = 'api-handlers',
-  Service = 'service',
-  Layout = 'layout',
-  Screen = 'screen',
-  Component = 'component',
-  ViewModel = 'view-model',
-  State = 'state',
-  /** Alias-only entry for one endpoint — carries no source path of its own */
-  ApiEntrypoint = 'api-entrypoint',
-}
-
 /**
  * One allocated name.
  *

package/src/planning/consts.ts

@@ -1,5 +1,4 @@
-import { CodeScope, CodeStyle } from '@owlmeans/planning'
-import type { CodePolicy } from '@owlmeans/planning'
+import { CodeScope, CodeStyle, type CodePolicy } from '@owlmeans/planning'
 
 /**
  * The OwlMeans Viable vocabulary over `@owlmeans/planning`.
@@ -180,3 +179,17 @@ export const VIABLE_IMPROVEMENT_CODE: CodePolicy = Object.freeze({
 export const VIABLE_REQUIREMENT_CODE: CodePolicy = Object.freeze({
   ...VIABLE_STORY_CODE, prefix: VIABLE_REQUIREMENT_CODE_PREFIX,
 })
+
+/**
+ * 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.'

package/src/planning/index.ts

@@ -1,7 +1,6 @@
 export * from './consts.js'
 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

@@ -1,18 +1,5 @@
 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.'
+import { LANDING_STORY_SENTENCE } from './consts.js'
 
 const normalized = (text: string): string => text.replace(/\s+/g, ' ')