@owlmeans/viable-common 0.0.33 → 0.0.34

package/build/skills/roles.js

@@ -1,4 +1,3 @@
-import { ViableSkill } from './consts.js';
 /**
  * Who the model is being asked to be.
  *
@@ -42,229 +41,4 @@ export var ViablePersona;
     ViablePersona["DeclarationLookup"] = "declaration-lookup";
     ViablePersona["FixAgent"] = "fix-agent";
 })(ViablePersona || (ViablePersona = {}));
-/** Shared by the two helpers that reason about domain models and shared types. */
-const DOMAIN_ARCHITECT = `
-You are a fullstack web developer architect specializing in state management, domain models,
-and typescript.
-`.trim();
-/** The rules every coder and the fixer need, whatever they are writing. */
-const CODING_BASE = [ViableSkill.OutputSourceOnly, ViableSkill.TsStyle, ViableSkill.TsImports];
-/**
- * The frontend stack, in the order a component is built up.
- *
- * `OwlmeansState` is here, not only on the state coder: the view models that READ the stores are
- * written by the view and nav coders and repaired by the fixer, and none of them carried it —
- * the traces show `useStoreList(...)` read as `.list` / `.items` / a plain `T[]` in 18 projects,
- * the second most frequent repair the fixer made.
- */
-const FRONTEND = [
-    ViableSkill.ReactComponents, ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansNav,
-    ViableSkill.OwlMeansServices, ViableSkill.ShadcnUi, ViableSkill.FormFeedback,
-    ViableSkill.OwlmeansState, ViableSkill.StoreAccess, ViableSkill.ViewModelNaming,
-    ViableSkill.LibrariesUi,
-];
-/** The backend stack. */
-const BACKEND = [
-    ViableSkill.ProjectLayout,
-    ViableSkill.ResourceLayer, ViableSkill.ResourceResults, ViableSkill.ResourceMigrations,
-    ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansServer, ViableSkill.OwlmeansContext,
-    ViableSkill.OwlMeansServices, ViableSkill.LibrariesBackend,
-];
-const persona = (role, skills) => ({ role: role.trim(), skills });
-/**
- * The role text and skill set behind every helper.
- *
- * This is the single place a persona is written down. Before it existed the same
- * sentences lived in thirteen helper files and seven near-identical coder factories, and
- * the Express-5, resource-layer and client-state rules were duplicated across three of them.
- */
-export const VIABLE_PERSONAS = {
-    // --- Analysis and design ---
-    [ViablePersona.BusinessAnalyst]: persona(`
-You are a professional business analyst and product manager specializing in figuring out
-user stories from requirements.
-`, [ViableSkill.OutputTextOnly, ViableSkill.MainFlowFocus]),
-    [ViablePersona.ProductArchitect]: persona(`
-You are a product architect. You read what somebody wants built and say which KIND of
-application it is, out of a fixed list. You choose the least capable kind that can deliver
-what was asked for, because every capability above it is machinery a real user pays for.
-You never stretch a description to fit a more interesting answer.
-`, [ViableSkill.OutputTextOnly]),
-    [ViablePersona.ProductNaming]: persona(`
-You are a professional product and brand manager specializing in naming.
-`, [ViableSkill.OutputTextOnly, ViableSkill.MainFlowFocus]),
-    [ViablePersona.UxDesigner]: persona(`
-You are a professional UX designer specializing in user flow and interaction in web
-applications.
-This application serves four audiences — anonymous visitors, signed-in end users, the owner,
-and staff running the business process. Every screen you design belongs to exactly one of them,
-and you are told which one with each task.
-`, [ViableSkill.OutputTextOnly]),
-    [ViablePersona.VisualDesigner]: persona(`
-You are a visual ui designer specializing in writing design guidelines and design systems
-for web applications, and your interfaces are calm, precise and unmistakably the product's own.
-Your house style: a white ground in light mode and a black one in dark mode; colour from ONE
-product accent and never from backgrounds; depth only from hairlines, neutral tiles and a single
-floating shadow; a heavy grotesk display face with tight tracking and generous whitespace carrying
-the brand; motion that is small and belongs to the picture. You never reach for gradients, glass,
-blur or glow, and the older decoration classes a project still defines are painted flat and are
-never your tools. You change any of this only when the customer's specification explicitly asks —
-it names a background colour, a dark-only or coloured theme, a brand palette, or gradients. The
-product's subject matter is not such a request: a bakery is not a warm background, a bank is not a
-blue one. What makes a design this product's is its accent, its type and its illustration — never
-an added effect.
-This application serves four audiences — anonymous visitors, signed-in end users, the owner,
-and staff running the business process. Every screen you style belongs to exactly one of them,
-and you are told which one with each task.
-`, [ViableSkill.OutputTextOnly]),
-    // --- Architects ---
-    [ViablePersona.LayoutArchitect]: persona(`
-You are a frontend developer architect working with typescript and react.
-You are specializing in screen layouts and their components.
-This application's layouts are the four AREA shells it already ships — guest, user, admin and
-operator — so you compose screens to sit inside one of them and you restyle a shell when it
-needs to look different. You never write a new layout and never rebuild its navigation.
-`, [ViableSkill.LayoutDefinition, ViableSkill.ScreenDefinition, ...FRONTEND]),
-    [ViablePersona.ComponentArchitect]: persona(`
-You are a frontend developer architect specializing in typescript react components.
-`, [...FRONTEND]),
-    [ViablePersona.StateArchitect]: persona(`
-You are a frontend developer architect specializing in state management and typescript.
-`, [ViableSkill.OwlmeansState, ViableSkill.StoreAccess, ViableSkill.ViewModelNaming,
-        ViableSkill.LibrariesUiState]),
-    [ViablePersona.NavigationArchitect]: persona(`
-You are a frontend developer architect working with typescript and react.
-You are specializing in UI navigation and transitioning.
-This application has four fixed AREAS — guest, user (front office), admin and operator (back
-office) — and two menu levels inside each: SECTIONS are the top menu, and the screens of the
-active section are the side menu. You place a screen by choosing its area and its section, never
-by editing a menu component and never by changing an address.
-`, [ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansNav, ViableSkill.ScreenDefinition,
-        ViableSkill.LibrariesUi]),
-    [ViablePersona.DomainTypesArchitect]: persona(DOMAIN_ARCHITECT, [ViableSkill.LibrariesCommon]),
-    // Not DOMAIN_ARCHITECT. This helper decides the application's entire authorization model — the
-    // least access each surface can be given, and one name per capability — and borrowing the
-    // state-management architect's sentence was describing a different job to the model.
-    [ViablePersona.AccessArchitect]: persona(`
-You are a web application security architect specializing in authorization.
-You decide the least access an endpoint or a screen can be given and still do its job, and you
-name permissions so that one capability has exactly one name across the whole application.
-`, [ViableSkill.OwlMeansEntrypoints, ViableSkill.PermissionModel, ViableSkill.LibrariesCommon]),
-    [ViablePersona.ApiArchitect]: persona(`
-You are an expert backend architect specializing in designing RESTful APIs using
-TypeScript and the OwlMeans entrypoint framework.
-`, [ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansServer, ViableSkill.ResourceLayer,
-        ViableSkill.ResourceResults, ViableSkill.OwlmeansContext, ViableSkill.LibrariesBackend]),
-    [ViablePersona.DatalayerArchitect]: persona(`
-You are a backend developer architect specializing in TypeScript, PostgreSQL and Node.js,
-working with the OwlMeans resource layer over Postgres (@owlmeans/postgres-resource), which
-owns the schema.
-`, [ViableSkill.ResourceLayer, ViableSkill.ResourceResults, ViableSkill.ResourceMigrations,
-        ViableSkill.OwlmeansContext, ViableSkill.LibrariesBackend]),
-    [ViablePersona.BackendDomainArchitect]: persona(`
-You are a backend developer architect specializing in business logic development.
-If necessary you describe which integrations to use.
-You prefer to use LLM chats models to solve sophisticated problems.
-You are always specific when consider some integrations.
-You always start from the business logic flow description that needs to be implemented
-and focus on it.
-`, [ViableSkill.ProjectLayout, ViableSkill.OwlmeansContext, ViableSkill.ResourceResults,
-        ViableSkill.LibrariesBackend]),
-    // --- Coders ---
-    // `PermissionModel` because this is the persona that WRITES the gate lines — `applyApiAccess`
-    // and `applyScreenAccess` both run on it. Knowing where the `@` may and may not appear has to
-    // reach the hand that types it, not only the one that chose the name.
-    [ViablePersona.CommonCoder]: persona(`
-You are an expert fullstack developer specializing in typescript and domain models.
-`, [...CODING_BASE, ViableSkill.OwlMeansEntrypoints, ViableSkill.PermissionModel,
-        ViableSkill.LibrariesCommon]),
-    [ViablePersona.UiStateCoder]: persona(`
-You are an expert frontend developer specializing in typescript and state management.
-`, [...CODING_BASE, ViableSkill.OwlmeansState, ViableSkill.OwlMeansEntrypoints,
-        ViableSkill.StoreAccess, ViableSkill.ViewModelNaming, ViableSkill.LibrariesUiState]),
-    [ViablePersona.UiViewCoder]: persona(`
-You are an expert frontend developer specializing in typescript, html, css, and react
-development of visual components.
-`, [...CODING_BASE, ...FRONTEND]),
-    [ViablePersona.UiNavCoder]: persona(`
-You are an expert frontend developer specializing in typescript, html, css, and react
-development of navigation and transitions.
-`, [...CODING_BASE, ...FRONTEND]),
-    [ViablePersona.DatalayerCoder]: persona(`
-You are an expert fullstack developer specializing in typescript, node.js and the OwlMeans
-resource layer over Postgres (@owlmeans/postgres-resource).
-`, [...CODING_BASE, ...BACKEND]),
-    [ViablePersona.ApiCoder]: persona(`
-You are an expert fullstack developer specializing in typescript, node.js, the OwlMeans
-entrypoint framework and its resource layer over Postgres (@owlmeans/postgres-resource).
-`, [...CODING_BASE, ...BACKEND]),
-    [ViablePersona.BackendModelCoder]: persona(`
-You are an expert backend developer specializing in typescript and node.js.
-You focus on business logic and integrations implementation — you really implement them,
-not just mock them.
-`, [...CODING_BASE, ViableSkill.ProjectLayout, ViableSkill.OwlmeansContext,
-        ViableSkill.ResourceResults, ViableSkill.LibrariesBackend]),
-    [ViablePersona.RuntimeArchitect]: persona(`
-You are a pragmatic backend architect. You decide what a feature needs to RUN, and your
-default answer is "a request handler and a table". You reach for a queue, a separate worker
-process or an LLM agent only when the work cannot honestly be done inside a request, and you
-say plainly which it is when the answer is none of them.
-`, [ViableSkill.QueueDiscipline, ViableSkill.ProjectLayout, ViableSkill.OwlmeansContext]),
-    [ViablePersona.WorkerCoder]: persona(`
-You are an expert backend developer specializing in typescript, queue processing and LLM
-agents. You write processors that are safe to run twice, because a worker can die mid-job.
-`, [...CODING_BASE, ViableSkill.ProjectLayout, ViableSkill.OwlmeansContext,
-        ViableSkill.WorkerJobs, ViableSkill.TargetAgents, ViableSkill.ResourceResults,
-        ViableSkill.LibrariesBackend]),
-    [ViablePersona.FreeFlightCoder]: persona(`
-You are an expert fullstack developer specializing in typescript.
-`, [...CODING_BASE, ...FRONTEND, ...BACKEND, ViableSkill.PermissionModel]),
-    // --- Everything else ---
-    [ViablePersona.Fixer]: persona(`
-You are an expert typescript fullstack developer specializing in bugfixing of web
-applications. You change as little as the reported error requires.
-`, [...CODING_BASE, ...FRONTEND, ...BACKEND, ViableSkill.FixerHeuristics,
-        ViableSkill.PermissionModel]),
-    // `OwlMeansEntrypoints` is what makes this persona able to ROUTE a report: the four contract
-    // files, and which of them a symptom belongs to. Without it a runtime `entrypoint.call is not a
-    // function` reads as a broken component, and the orchestrator sends a coder to rewrite the view
-    // model that is already correct.
-    //
-    // `OwlMeansServices` is here for the same reason one level down: this persona WRITES the
-    // instruction the coder follows, so it is the one that decides a `Service not found` is
-    // repaired by naming a different alias. It has to know which registry that name comes from
-    // before it delegates, or the coder inherits the wrong premise along with the task.
-    [ViablePersona.Orchestrator]: persona(`
-You are a senior fullstack typescript coding agent. You are orchestrating the
-development. Call the respective tools to inspect the project and to delegate the coding.
-`, [ViableSkill.ProjectLayout, ViableSkill.AgentTooling, ViableSkill.OwlmeansContext,
-        ViableSkill.OwlMeansEntrypoints, ViableSkill.OwlMeansServices, ViableSkill.PermissionModel,
-        ViableSkill.LayoutDefinition, ViableSkill.ScreenDefinition, ViableSkill.TsImports]),
-    [ViablePersona.SourceExtractor]: persona(`
-You are a code-context extraction agent. You are NOT writing code. Do not summarise.
-Your only deliverable is the tool call selecting the relevant line ranges. Be frugal —
-every extra line costs the coder context.
-`, []),
-    [ViablePersona.DeclarationLookup]: persona(`
-You are a TypeScript type-declaration lookup agent. You are NOT writing code and NOT
-fixing anything. Your only deliverable is the report_declarations tool call naming, for
-each requested type, the file that declares it. Be frugal — every tool call costs budget,
-and a wrong path is worse than an unresolved name.
-`, []),
-    [ViablePersona.FixAgent]: persona(`
-You are a build-repair agent working on a TypeScript monorepo you can inspect with tools.
-
-You are called only after a scripted fix loop has already failed on this error, so the
-obvious edit has been tried and did not work. Investigate before you edit: read the file
-the error points at, look up the authoritative name in the registry, search for the other
-places a name is spelled. A build error that keeps coming back is almost always a name
-that exists in two spellings or one that was never declared — declare or create the
-missing thing at its registered name; renaming a reference to a new guess is what made
-the loop circle.
-
-Make the smallest edit that addresses the cause, verify with the build, and finish with
-report_fix. Never delete a feature to silence an error, and never stub a handler to make
-the build pass.
-`, []),
-};
 //# sourceMappingURL=roles.js.map

package/build/skills/roles.js.map

@@ -1 +1 @@
-{"version":3,"file":"roles.js","sourceRoot":"","sources":["../../src/skills/roles.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"roles.js","sourceRoot":"","sources":["../../src/skills/roles.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AACH,MAAM,CAAN,IAAY,aAoCX;AApCD,WAAY,aAAa;IACvB,qDAAoC,CAAA;IACpC,iDAAgC,CAAA;IAChC,wFAAwF;IACxF,uDAAsC,CAAA;IACtC,2CAA0B,CAAA;IAC1B,mDAAkC,CAAA;IAElC,qDAAoC,CAAA;IACpC,2DAA0C,CAAA;IAC1C,mDAAkC,CAAA;IAClC,6DAA4C,CAAA;IAC5C,gEAA+C,CAAA;IAC/C,qDAAoC,CAAA;IACpC,+CAA8B,CAAA;IAC9B,2DAA0C,CAAA;IAC1C,oEAAmD,CAAA;IAEnD,6CAA4B,CAAA;IAC5B,gDAA+B,CAAA;IAC/B,8CAA6B,CAAA;IAC7B,4CAA2B,CAAA;IAC3B,mDAAkC,CAAA;IAClC,uCAAsB,CAAA;IACtB,0DAAyC,CAAA;IACzC,qGAAqG;IACrG,uDAAsC,CAAA;IACtC,kFAAkF;IAClF,6CAA4B,CAAA;IAC5B,sDAAqC,CAAA;IAErC,gCAAe,CAAA;IACf,8CAA6B,CAAA;IAC7B,qDAAoC,CAAA;IACpC,yDAAwC,CAAA;IACxC,uCAAsB,CAAA;AACxB,CAAC,EApCW,aAAa,KAAb,aAAa,QAoCxB"}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@owlmeans/viable-common",
-  "version": "0.0.33",
+  "version": "0.0.34",
   "license": "MIT",
-  "description": "Runtime-free contracts of the OwlMeans Viable platform — the analysis, design and metadata shapes of a generated project, its target-shape manifest, the slot command vocabulary, the connector protocol and the conversion vocabulary.",
+  "description": "Runtime-free contracts of the OwlMeans Viable platform — the analysis, design and metadata shapes of a generated project, its target-shape manifest, the slot command vocabulary, the connector protocol and the conversion vocabulary, and the intent-first hand-off from the public site to the platform.",
   "type": "module",
   "scripts": {
     "build": "tsc -b",
@@ -48,6 +48,13 @@
       "default": "./build/integrity/index.js",
       "module": "./build/integrity/index.js",
       "types": "./build/integrity/index.d.ts"
+    },
+    "./intent": {
+      "import": "./build/intent/index.js",
+      "require": "./build/intent/index.js",
+      "default": "./build/intent/index.js",
+      "module": "./build/intent/index.js",
+      "types": "./build/intent/index.d.ts"
     }
   },
   "devDependencies": {
@@ -59,12 +66,15 @@
     "typescript": "^7.0.2"
   },
   "dependencies": {
-    "@owlmeans/agent-common": "^0.1.18-rc.40",
-    "@owlmeans/entrypoint": "^0.1.18-rc.36",
-    "@owlmeans/error": "^0.1.18-rc.35",
+    "@owlmeans/agent-common": "^0.1.18-rc.41",
+    "@owlmeans/auth": "^0.1.18-rc.36",
+    "@owlmeans/context": "^0.1.18-rc.32",
+    "@owlmeans/entrypoint": "^0.1.18-rc.37",
+    "@owlmeans/error": "^0.1.18-rc.36",
+    "@owlmeans/flow": "^0.1.18-rc.39",
     "@owlmeans/llm-common": "^0.1.18-rc.36",
-    "@owlmeans/planning": "^0.1.18-rc.9",
-    "@owlmeans/resource": "^0.1.18-rc.35",
+    "@owlmeans/planning": "^0.1.18-rc.10",
+    "@owlmeans/resource": "^0.1.18-rc.36",
     "@owlmeans/route": "^0.1.18-rc.33"
   },
   "publishConfig": {

package/src/ba/index.ts

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

package/src/blueprint/consts.ts

@@ -9,3 +9,43 @@ export const DEFAULT_BLUEPRINT_ID = 'owlmeans-fullstack-ts'
 
 /** Recorded on a project so a later run knows which blueprint drew it. */
 export const BLUEPRINT_META_KEY = 'blueprint'
+
+/**
+ * WHICH KIND of product is being built on a blueprint.
+ *
+ * A blueprint says what the STACK is — the language, the framework, the topology, the seeds. A
+ * case says what is being built ON it, and that is a different question with different consumers:
+ * the analyst framing the brief, the architect deciding whether a story needs a queue, the coder
+ * choosing which packages it may import.
+ *
+ * Deliberately NOT a second blueprint. Everything a case has to say is already a blueprint field,
+ * so a case is a PATCH and the resolution order stays base → case → per-run overrides. That is
+ * also why adding one is a data change: nothing reads `BlueprintCase` except the case table
+ * (`BLUEPRINT_CASES` in `@owlmeans/viable`) and the prompt that classifies a project into it.
+ */
+export enum BlueprintCase {
+  /** A web application whose every feature fits inside a request. No queue, no worker, no agents. */
+  Web = 'web',
+  /** A web application with work that genuinely belongs off the request path. */
+  Scalable = 'scalable',
+  /** The product's value comes from ordered, deterministic model-driven steps. */
+  AiPipeline = 'ai-pipeline',
+  /** The product's value comes from an agent that decides its own path through tools. */
+  AiAgent = 'ai-agent',
+  /** A browser game: a three.js scene with an ordinary React interface over it. */
+  Game = 'game',
+}
+
+/**
+ * How a game is played, which decides who owns its state.
+ *
+ * Recorded beside the case rather than folded into it, because it changes nothing about the
+ * dependencies and everything about where the logic goes. `OnlineTurn` is the default for
+ * anything multiplayer unless the brief plainly asks for live play — it is the shape that
+ * actually builds, and it needs no socket, no tick loop and no reconciliation.
+ */
+export enum GameKind {
+  Casual = 'casual',
+  OnlineTurn = 'online-turn',
+  OnlineLive = 'online-live',
+}

package/src/blueprint/index.ts

@@ -1,6 +1,3 @@
 export * from './types.js'
 
 export * from './consts.js'
-export * from './case.js'
-export * from './schemas.js'
-export * from './resolve.js'

package/src/blueprint/types.ts

@@ -201,11 +201,11 @@ export interface PackagesLayer {
   /**
    * Skills added to ONE persona, rather than to every prompt of the blueprint.
    *
-   * The additive twin of {@link skillsForBlueprint}, which subtracts. `skills` above is what is
-   * true of the whole stack; this is what is true of one performer — the analyst who has to know
-   * that a game brief is a core loop rather than a numbered flow, the architect who has to know
-   * when a tool loop is warranted. Without it a case could only change what a CODER is told, and
-   * a case changes the product analysis first.
+   * The additive twin of `skillsForBlueprint` (in `@owlmeans/viable`), which subtracts. `skills`
+   * above is what is true of the whole stack; this is what is true of one performer — the analyst
+   * who has to know that a game brief is a core loop rather than a numbered flow, the architect who
+   * has to know when a tool loop is warranted. Without it a case could only change what a CODER is
+   * told, and a case changes the product analysis first.
    */
   personaSkills?: Partial<Record<ViablePersona, ViableSkill[]>>
   /** Extra dependencies a role's manifest carries, beyond what the overlay ships. */

package/src/intent/consts.ts

@@ -0,0 +1,66 @@
+/**
+ * The intent-first hand-off — how a prompt typed on the public site reaches the platform.
+ *
+ * A visitor types the idea for a project on the marketing site before they have an account. The
+ * site cannot write into the platform's browser storage (IndexedDB is per origin) and must not put
+ * the prompt in a URL, so the prompt takes a short detour through the platform's own cache: the
+ * site stashes it behind an unguessable reference, sends the browser to the platform with only that
+ * reference, and the platform picks the prompt up once — after which it lives in the visitor's own
+ * browser until they decide what to do with it.
+ *
+ * Everything here is serializable and runtime-free: the site, the manager API and the manager web
+ * read the same declarations, and none of them may reinvent a name the others parse.
+ */
+
+/** Every address of the hand-off. API routes are guest routes; the landing is a screen. */
+export const intent = Object.freeze({
+  base: 'viable:manager-api:intent:base',
+  stash: 'viable:manager-api:intent:stash',
+  pickup: 'viable:manager-api:intent:pickup',
+  landing: 'viable:manager-web:intent:landing',
+} as const)
+
+/** Where the guest API lives, and the screen the visitor's browser is sent to. */
+export const INTENT_API_PATH = '/public/intent'
+export const INTENT_LANDING_PATH = '/start'
+
+/** The flow the two sides walk. */
+export const INTENT_FLOW = 'viable:intent'
+
+/**
+ * How long the platform keeps a stashed prompt waiting for pickup. Short on purpose: the pickup
+ * happens the moment the browser lands, so anything older was abandoned, and a prompt is personal
+ * data the platform has no business holding once nobody is coming for it.
+ */
+export const INTENT_TTL_SECONDS = 120
+
+/** The longest prompt the platform will create a project from (`PromptSchema` in viable). */
+export const INTENT_PROMPT_MAX = 8192
+
+/**
+ * The reference's shape: `createIdOfLength(24)` — Base58, so no `0`, `O`, `I` or `l`. Anything else
+ * is refused before the cache is asked, which keeps a crafted reference from ever being a key.
+ */
+export const INTENT_REF_LENGTH = 24
+export const INTENT_REF_PATTERN = '^[1-9A-HJ-NP-Za-km-z]{24}$'
+
+/** The flow payload key carrying the reference — short, because a payload is CSV-joined. */
+export const INTENT_PAYLOAD_REF = 'ref'
+
+/** How long the visitor's draft survives in their own browser waiting for a decision. */
+export const INTENT_DRAFT_TTL_MS = 24 * 60 * 60 * 1000
+
+/** How long a suspended landing waits while the visitor signs in or registers. */
+export const INTENT_SUSPEND_TTL_MS = 30 * 60 * 1000
+
+/** Steps of {@link intentFlow}, exported so a screen never spells one as a literal. */
+export enum IntentFlowStep {
+  /** The public site: the prompt is typed and stashed. */
+  Compose = 'compose',
+  /** The platform's landing screen: the stash is picked up. */
+  Land = 'land',
+  /** The platform's own sign-in dispatcher. */
+  SignIn = 'sign-in',
+  /** The platform's home screen, where the draft is offered back. */
+  Review = 'review',
+}

package/src/intent/entrypoints.ts

@@ -0,0 +1,43 @@
+import { contract, openProtocol, protocol, typed } from '@owlmeans/entrypoint'
+import { frontend, route, RouteMethod } from '@owlmeans/route'
+import { INTENT_API_PATH, INTENT_LANDING_PATH, intent } from './consts.js'
+import { IntentPickupBodySchema, IntentStashBodySchema } from './schemas.js'
+import type {
+  IntentPickupBody, IntentPickupResult, IntentProtocolOptions, IntentStashBody, IntentStashResult,
+} from './types.js'
+
+/**
+ * Declare the intent-first hand-off: two GUEST API routes and the landing screen's address.
+ *
+ * No guard and no gate anywhere on the API — the caller is a visitor who has no account yet — and
+ * no `service` on any route: each consumer fills it in (the public site names the platform's
+ * services in its own configuration; the manager binds them to its own).
+ *
+ * TODO(cors): these routes ride the framework's global `origin: '*'` CORS policy (no credentials).
+ * If viable ever restricts allowed origins globally, this entrypoint must keep answering the public
+ * site's origins — owlmeans.com, owlmeans.pl and, in dev/stage, `http://localhost:4321`.
+ *
+ * The landing screen is `sticky`, like the OAuth consent screens: it is an ordinary in-app screen
+ * that a visitor arrives at directly from another origin.
+ */
+export const makeIntentProtocols = (opts: IntentProtocolOptions = {}) => {
+  const base = openProtocol(route(intent.base, opts.path ?? INTENT_API_PATH))
+
+  return {
+    base,
+
+    stash: protocol(
+      route(intent.stash, '/', { parent: base, method: RouteMethod.POST }),
+      contract.request({ body: typed<IntentStashBody>(IntentStashBodySchema) }, typed<IntentStashResult>()),
+    ),
+
+    pickup: protocol(
+      route(intent.pickup, '/pickup', { parent: base, method: RouteMethod.POST }),
+      contract.request({ body: typed<IntentPickupBody>(IntentPickupBodySchema) }, typed<IntentPickupResult>()),
+    ),
+
+    landing: openProtocol(route(intent.landing, opts.landing ?? INTENT_LANDING_PATH, frontend()), { sticky: true }),
+  }
+}
+
+export type IntentProtocols = ReturnType<typeof makeIntentProtocols>

package/src/intent/errors.ts

@@ -0,0 +1,33 @@
+import { ResilientError } from '@owlmeans/error'
+
+export class IntentError extends ResilientError {
+  public static override typeName = `ViableIntent${ResilientError.typeName}`
+
+  constructor(message: string = 'error') {
+    super(IntentError.typeName, `viable-intent:${message}`)
+  }
+}
+
+/** No stashed prompt under that reference — expired, already picked up, or never existed. */
+export class IntentExpired extends IntentError {
+  public static override typeName = `Expired${IntentError.typeName}`
+  /** The reference answers nothing (any more): answered 404. */
+  public static httpStatus = 404
+
+  constructor(message: string = 'error') {
+    super(`expired:${message}`)
+    this.type = IntentExpired.typeName
+  }
+}
+
+/** Too many stashes or pickups from one address, or across everyone. */
+export class IntentThrottled extends IntentError {
+  public static override typeName = `Throttled${IntentError.typeName}`
+  /** Answered 429. */
+  public static httpStatus = 429
+
+  constructor(message: string = 'error') {
+    super(`throttled:${message}`)
+    this.type = IntentThrottled.typeName
+  }
+}

package/src/intent/flow.ts

@@ -0,0 +1,67 @@
+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 }
+
+/**
+ * The hand-off flow both sides walk.
+ *
+ * `compose` runs on the public site: the prompt is stashed and `handoff` carries the reference to
+ * `land`, whose module is the platform's landing screen — so the site redirects to
+ * `land`'s address with the payload as query. The landing then enters at `land` FRESH (the
+ * reference arrives as `?ref=`, never as a serialized token, which the platform's own sign-in
+ * parses from `?flow=` on every page), and either goes on to `review` (signed in) or parks the flow
+ * with `suspendFlow` at `sign-in`, whose non-explicit way forward is `review` — the home screen —
+ * so whichever sign-in method finishes lands there.
+ *
+ * The steps address CONCRETE entrypoint aliases, never `$`-prefixed references: this flow is never
+ * the live `FlowService` model and nothing here needs `configureFlows`.
+ */
+export const intentFlow: ShallowFlow = {
+  flow: INTENT_FLOW,
+  initialStep: IntentFlowStep.Compose,
+  steps: {
+    [IntentFlowStep.Compose]: {
+      index: 0,
+      step: IntentFlowStep.Compose,
+      service: '',
+      initial: true,
+      payloadMap,
+      transitions: {
+        handoff: { transition: 'handoff', step: IntentFlowStep.Land },
+      },
+    },
+    [IntentFlowStep.Land]: {
+      index: 1,
+      step: IntentFlowStep.Land,
+      service: '',
+      module: intent.landing,
+      initial: true,
+      payloadMap,
+      transitions: {
+        review: { transition: 'review', step: IntentFlowStep.Review },
+        'sign-in': { transition: 'sign-in', step: IntentFlowStep.SignIn, explicit: true },
+      },
+    },
+    [IntentFlowStep.SignIn]: {
+      index: 2,
+      step: IntentFlowStep.SignIn,
+      service: '',
+      module: DISPATCHER,
+      payloadMap,
+      transitions: {
+        next: { transition: 'next', step: IntentFlowStep.Review },
+      },
+    },
+    [IntentFlowStep.Review]: {
+      index: 3,
+      step: IntentFlowStep.Review,
+      service: '',
+      module: HOME,
+      payloadMap,
+      transitions: {},
+    },
+  },
+}

package/src/intent/index.ts

@@ -0,0 +1,6 @@
+export * from './consts.js'
+export * from './schemas.js'
+export * from './errors.js'
+export * from './entrypoints.js'
+export * from './flow.js'
+export type * from './types.js'

package/src/intent/schemas.ts

@@ -0,0 +1,27 @@
+import type { JSONSchemaType } from 'ajv'
+import { INTENT_PROMPT_MAX, INTENT_REF_LENGTH, INTENT_REF_PATTERN } from './consts.js'
+import type { IntentPickupBody, IntentStashBody } from './types.js'
+
+/**
+ * The stash body. `consent` is a constant `true`, not a boolean: the data-processing confirmation is
+ * a precondition of the request existing, so the wire refuses its absence instead of the handler
+ * having to remember to look.
+ */
+export const IntentStashBodySchema: JSONSchemaType<IntentStashBody> = {
+  type: 'object',
+  properties: {
+    prompt: { type: 'string', minLength: 1, maxLength: INTENT_PROMPT_MAX },
+    consent: { type: 'boolean', const: true },
+  },
+  required: ['prompt', 'consent'],
+  additionalProperties: false,
+}
+
+export const IntentPickupBodySchema: JSONSchemaType<IntentPickupBody> = {
+  type: 'object',
+  properties: {
+    ref: { type: 'string', minLength: INTENT_REF_LENGTH, maxLength: INTENT_REF_LENGTH, pattern: INTENT_REF_PATTERN },
+  },
+  required: ['ref'],
+  additionalProperties: false,
+}