cortena-ui 1.14.0 → 1.16.0

package/CHANGELOG.md

@@ -3,6 +3,204 @@
 Notable changes per release. Versions before 1.6.0 are recorded in the git log
 and in `../../CONSUMING.md`; this file starts where the changelog does.
 
+## 1.16.0
+
+### Fixed
+
+- **The login screen asks for the organisation** (DESIGN-126, found by the
+  DESIGN-125 pilot). cortena-auth's `POST /api/auth/login` takes
+  `{ orgId, email, password }` and rejects a body without `orgId` with a 400
+  before it looks at the credentials. `LoginScreen` collected email and
+  password only, and `CortenaApp` declared `auth.orgId` and read it nowhere —
+  so a fresh browser opening an extension URL directly, with no `?org=` and
+  nothing remembered, posted a login that could not succeed and read back a
+  validation error it could do nothing about. Every extension on the frame had
+  it. The launch path (a `?token=` from CortenaWeb) and a returning browser
+  were never affected, which is why it survived.
+
+  Sign-in is now the two steps cortena-auth's own hosted page asks:
+  the organisation, then the credentials. The organisation step is *skipped*
+  whenever the caller knows the answer — `CortenaApp` passes `auth.orgId`
+  through as `LoginScreen`'s default — so the returning browser that is the
+  overwhelmingly common case is never asked. Where the app does not know, the
+  screen asks rather than posting a request that cannot succeed.
+
+### Added
+
+- **`LoginScreen`: `orgId` and `onOrg`.** `orgId` is the default for the
+  organisation step — the `?org=` on the launch URL, or the value this browser
+  used last — and supplying it skips the step. It is a default, not a value:
+  the user can change it from the credentials step, and a caller that learns
+  the organisation late (an `auth-info` call, a remembered value read after
+  mount) can pass it then and the screen moves on without a flash of the wrong
+  step. `onOrg` lets the app resolve what the user typed —
+  `GET /api/orgs/:orgId/auth-info` — and hand back a fresh `methods` list;
+  return a promise and the screen waits on it, rejecting to stay on the step
+  with your message. The fetch stays in the app, as `methods` always has.
+- **`CortenaApp`: `auth.onOrg`**, the same seam on the frame's contract, and
+  `auth.orgId` now reaches the screen instead of being decorative.
+- **Validation in the user's words**, and three different sentences for three
+  different problems, because the user's next move differs in each. An empty
+  organisation says "Enter your organization ID to continue." A lookup the app
+  refused says the app's own message, or "We could not find that organization.
+  Check the ID with your administrator." A lookup that never reached the
+  service — `fetch` rejecting with a `TypeError`, an `AbortError` — says "We
+  could not reach the sign-in service. Check your connection and try again.",
+  because a dropped connection says nothing about the organisation and sending
+  a user with a valid ID to their administrator over dead Wi-Fi helps nobody.
+  A lookup that threw a bug (a `SyntaxError` from a body that was not JSON)
+  says "Something went wrong looking up that organization. Try again." **and
+  warns in development**, so the author hears about it instead of it vanishing.
+  The existing `error` and `loading` props keep their meanings exactly.
+- **A way out of a lookup that never comes back.** An `onOrg` that never
+  settles used to leave the step disabled for the rest of the session with no
+  control on the page that did anything. A Cancel button appears beside
+  Continue for the screen's own wait — not for the caller's `loading`, which is
+  the caller's to end.
+- **The step announces itself.** A visually hidden `role="status"` line says
+  which of the two steps is on screen, so a screen-reader user who has just
+  pressed Continue hears something move.
+- **The organisation on the credentials step**, with "Use a different
+  organization" beside it, so a user signed in to the wrong one — or turned
+  away by a 400 the caller surfaced through `error` — has something to do about
+  it rather than a dead screen. It is a real control: the button scale's own
+  smallest step (32px, over WCAG 2.2 AA 2.5.8's 24px floor) and underlined at
+  rest, so colour is not the only thing marking it as one.
+
+### Changed
+
+- **`PasswordCredentials` gains `orgId`**, always non-empty and already
+  trimmed, and `onProvider` gains a second argument, the organisation —
+  cortena-auth requires `orgId` beside a provider's `idToken` exactly as it does
+  beside a password.
+
+  **Why this is a minor and not a major, said plainly.** Both shapes are
+  produced by the component and consumed by the caller, so a caller gains a
+  field and an argument rather than owing either; a one-argument `onProvider`
+  handler still satisfies the type, and a handler that reads `credentials.email`
+  is unaffected. There are exactly two ways to break a compile on this, and both
+  are producer-side: constructing a `PasswordCredentials` literal by hand (a
+  test double, a story fixture) or *calling* `onProvider` yourself. Neither
+  exists anywhere in the fleet — checked across cortena-extensions, where the
+  conformance fixture and the Tasks pilot both only pass handlers in. The
+  behavioural change is the new step, and passing `orgId` suppresses it
+  entirely, which `CortenaApp` now does.
+- **A `methods` list is pinned to the organisation it describes.** `methods`
+  comes from one org's `auth-info`, and nothing in the props said which, so the
+  screen now keeps the pairing itself and falls back to password when the user
+  moves to a different organisation without a fresh list arriving. Without this
+  an SSO-only org's provider buttons survived onto the next org — running the
+  first org's Firebase project while the sign-in posted the second org's id,
+  with no password form either: a screen with no working way in. Where this
+  fallback fires and no `onOrg` was given, it says so in a development warning.
+- The organisation field is a plain `<input>` with `autocomplete="organization"`
+  — deliberately not a Combobox. There is no list of organisations to offer, and
+  an empty combobox is a listbox a screen reader announces and cannot type its
+  way out of.
+
+## 1.15.0
+
+### Added
+
+- **`cortena-ui/app` — `CortenaApp`, the whole frame** (DESIGN-119). Everything
+  around an extension's content, mounted once instead of assembled eight ways:
+  the launch, `LoginScreen` with the methods the org advertises, the signed-out
+  state with a `returnTo`, exactly one session guard, `AppShell`,
+  `AgentChatPopup` in `agentSlot`, the tab title, and the standard Profile /
+  Settings / Permissions pages. The 2026-09-14 re-audit is what it replaces:
+  seven local login pages across eight extensions, three of them with dummy
+  users; a guard mounted with a different subset of its behaviour in each; a
+  pop-up mounted without the user's token or the agent slug; a Settings item
+  greyed out in every one of the six shell swaps.
+- **A `host` role.** `role="host"` leaves the agent slot empty, because
+  CortenaWeb *is* the chat and its own guard is the one that renews and pushes
+  tokens into framed extensions. Host-only navigation is `nav` and `headerSlot`
+  configuration, not a special case inside the composition. cortena-auth's
+  hosted pages are the third consumer.
+- **`readCortenaLaunch({ hostOrigins })`**, and with it the rule that a framed
+  extension trusts the host's guard **only when the host declares it**. The
+  declaration — a `cortenaGuard=host` parameter beside the token, or the first
+  bridge message — is origin-checked against an allow-list the app supplies
+  from its own configuration, never from the request. Declared: no guard here,
+  and renewed tokens arrive through `session.onTokenRenewed`. Absent: a
+  countdown from the access token's own `exp`, the standard warning with no
+  Continue, then the signed-out state. Not framed: the full `SessionGuard`. One
+  of the three, ever — never two countdowns for one session, and never the old
+  behaviour of inferring "the host is guarding me" from the absence of a
+  refresh token.
+- **The standard pages**, at `/me`, `/settings` and `/settings/permissions`:
+  Profile, then Permissions from `AdminPermissions` against the §14.3 admin
+  routes when the caller may administer, then the extension's own settings from
+  a declared zod schema — or one plain line, "Nothing to configure for <name>
+  yet." The avatar menu's Settings item is never disabled again. Exported
+  individually as `CortenaSettingsPage`, `CortenaProfilePage` and
+  `ProfileSection`, with `matchCortenaStandardRoute` for an app that would
+  rather place them under its own router.
+- **`session.hostOrigins`**, and with it the bridge path for the declaration:
+  the composition listens for the host's first
+  `{ type: "cortena-session", guarded, accessToken }` and takes the declaration
+  and any renewal from it. Prefer this over the launch parameter —
+  `event.origin` is the browser's and cannot be forged from inside the sending
+  page, where the parameter's check falls back to `document.referrer` on a
+  browser with no `ancestorOrigins`. The gap is downgrade-only (a forged
+  declaration mounts *no* guard, never a second one) and is written down in
+  `launch.ts`.
+- **`session.expiresAt`**, for a token whose `exp` cannot be read — an opaque
+  token, or one the decoder failed on. Exactly `SessionToken`'s own escape
+  hatch, and the way to keep such a session guarded rather than landing on the
+  signed-out screen.
+- **A development warning** where a non-framed launch omits `session.refresh`.
+  Without it the guard reaches the proactive refresh at about 75% of the access
+  token's life, is rejected, and signs the user out — §10.4.1's half-dead
+  screen arriving from the inside, with nothing on screen to explain it.
+- **`CortenaApp` is router- and environment-agnostic**: `pathname` in,
+  `onNavigate` out, real `href`s, configuration and tokens as props, no browser
+  API touched during a first render, and `documentTitle={false}` for a surface
+  that does not own the tab. That is what lets CortenaWeb adopt it inside a
+  Next.js root layout instead of keeping a second shell.
+
+### Fixed
+
+- **A signed-out screen you could not leave.** The state was cleared only where
+  a *host* pushed a token, and that path exists only in a host-guarded frame.
+  On a standalone launch or an undeclared frame the signed-out screen
+  short-circuits the whole render, so a successful sign-in set the token and
+  the user stayed on "You were signed out" for ever with nothing on screen to
+  explain it. A new token now clears it wherever it comes from — the launch,
+  the app's own store, `session.onTokenRenewed`, or the bridge.
+- **A frame with an unreadable token was silently unguarded.** A token with no
+  readable `exp` took the countdown branch and then counted nothing: no
+  warning, no expiry, no signed-out state — the exact state decision (b)
+  removed, arriving through the back door. It is now reported as already over,
+  which lands on the signed-out screen with a `returnTo`, and says why in a
+  development warning. Warning rather than expiring was considered and
+  rejected: a warning's entire content is a number there is none of, and its
+  only way out is Log out, which lands on the same screen anyway.
+- **A rejected sign-out** left an unhandled rejection and the user on a shell
+  whose session was over. It is caught, and the screen stops pretending either
+  way — `SessionGuard` makes the same call.
+- **`settings.load()` is no longer called** for a declaration with no readable
+  fields. The card renders one sentence; a GET behind it is a request nothing
+  on screen is waiting for.
+
+### Notes
+
+- **The frame is light and stays light.** `cortena-ui/app` measures **285.6 kB
+  eager** against a 340 kB ceiling — the shell probe's 212.8 kB plus the
+  standard pages — with **no heavy package eager at all**. `AdminPermissions`
+  (TanStack Table, and exceljs behind `DataTable`'s export) and the agent mount
+  (`AgentChat`, react-markdown, the A2UI renderer) are both `React.lazy`, and
+  `test/bundle-probe.test.mjs` measures that rather than assuming it.
+- **`@ag-ui/client` is still reachable from `cortena-ui/agent-chat` alone.** The
+  transport factory is passed in as `agent.createClient` rather than imported,
+  so an extension writes one named import and the composition still owns every
+  argument the pop-up is built with.
+- **This package imports no zod.** A settings schema is typed structurally and
+  only ever called — `safeParse` to validate, `.shape` to derive fields — so it
+  works across zod 3 and 4 and costs the frame nothing.
+- The favicon and the `<title>` no longer need hand-copied files: the generator
+  ships as a Vite plugin from `cortena-design/vite` (cortena-design 3.6.0).
+
 ## 1.14.0
 
 ### Added

package/README.md

@@ -36,6 +36,7 @@ consumer's bundler getting tree-shaking right:
 | `cortena-ui/a2ui` | the A2UI catalogue and renderer | most of the package, by design |
 | `cortena-ui/sortable-list` | `SortableList`, `SortableHandle`, `arrayMove` | dnd-kit |
 | `cortena-ui/agent-chat` | `AgentChatPopup`, `AgentChat`, `createAguiAgentChatClient` | the A2UI catalogue, plus `@ag-ui/client` (rxjs, zod 3, uuid, protobuf) |
+| `cortena-ui/app` | `CortenaApp` — the whole frame, and `readCortenaLaunch` | 285.6 kB eagerly; the standard pages that are heavy arrive in chunks of their own |
 | `cortena-ui/rich-text-editor` | `RichTextEditor`, `parseMarkdown`, `serializeMarkdown` | TipTap on ProseMirror, 619 kB — the heaviest entry in the package |
 
 Each component has exactly one home, so the barrel re-exports every entry
@@ -129,6 +130,210 @@ regression; `test/chart-bundle.test.tsx` says which line caused it.
   check in light, dark and system-dark; add an entry with every variant and
   size when adding a component.
 
+## The frame
+
+`AppShell` owns what renders after sign-in. Everything around it — the sign-in
+screen, the signed-out state, the session guard, the agent pop-up, the tab
+title and the Profile / Settings / Permissions pages — used to be each
+extension's to assemble, and a 2026-09-14 re-audit of eight of them found eight
+answers: seven local login pages, three still with dummy users; a guard mounted
+with a different subset of its behaviour in each; a pop-up mounted without the
+user's token or the agent slug; a Settings item greyed out in every shell.
+
+`cortena-ui/app` is the assembly (DESIGN-119):
+
+```tsx
+// main.tsx — synchronously, before createRoot (§7.3)
+import { readCortenaLaunch } from "cortena-ui/app";
+const launch = readCortenaLaunch({ hostOrigins: [config.cortenaWebOrigin] });
+
+// App.tsx
+import { CortenaApp } from "cortena-ui/app";
+import { createAguiAgentChatClient } from "cortena-ui/agent-chat";
+
+<CortenaApp
+  extension={{ id: "tasks", name: "Tasks" }}
+  user={user}
+  auth={{ publicAuthUrl, orgId, methods, onPassword, onProvider }}
+  session={{ launch, getToken, refresh, signOut, onTokenRenewed }}
+  nav={{ groups, pathname, onNavigate: (item, e) => { e.preventDefault(); navigate(item.href); } }}
+  agent={{ slug: "tasks", gatewayUrl: "/api/agent", createClient: createAguiAgentChatClient, relay, tokensCss }}
+  permissions={{ api: adminApi, canAdminister: isAdmin }}
+  settings={{ schema, load, save }}
+  help={{ source: HELP_DOCUMENT_URL }}
+  pathname={pathname}
+  onNavigate={(href) => navigate(href)}
+  documentTitle={pageTitle}
+>
+  <Outlet />
+</CortenaApp>
+```
+
+It does things in this order, and the order is the contract:
+
+1. the launch, from `session.launch`;
+2. no token → `LoginScreen` with the methods the org advertises;
+3. the session ended → `LoginScreen` with `signedOut` and a `returnTo`;
+4. exactly one session guard, at the top, above the shell and the pop-up alike;
+5. `AppShell`, with Profile / Settings / Log out in the avatar menu;
+6. `AgentChatPopup` in `agentSlot`, in the `extension` role only;
+7. the standard pages when `pathname` names one, your `children` otherwise.
+
+### It is a client component, and router-agnostic
+
+Navigation is `pathname` in and `onNavigate` out, over real `href`s, exactly as
+`AppShell` already does. Configuration and tokens are props: the composition
+fetches nothing, reads no browser API during a first render, and does not
+assume it owns the document — `documentTitle={false}` turns off even the tab
+title. That is not style. The third consumer is CortenaWeb, in a `host` role,
+inside its own Next.js root layout; without every one of those the fleet keeps
+two shells.
+
+`role="host"` leaves the agent slot empty, because the host *is* the chat, and
+its own guard is the one that renews and pushes tokens into framed extensions.
+Host-only navigation — an Apps list, an org switcher, platform admin — is `nav`
+and `headerSlot` configuration, not a special case in here.
+
+### Reading the launch, and who guards the session
+
+A framed extension cannot refresh: CortenaWeb holds the refresh token and hands
+down access tokens (`refreshToken=none`). Inferring "the host is guarding me"
+from that absence is trust by assumption — a frame opened by anything at all
+got no warning and no signed-out state, and nothing said so. So:
+
+| the launch | what mounts |
+| --- | --- |
+| framed, and the host **declared** it guards the session | no guard here; renewed tokens arrive through `session.onTokenRenewed` |
+| framed, and it did not | a countdown from the access token's own `exp`, the standard warning with no Continue, then the signed-out state with a `returnTo` |
+| not framed | the full `SessionGuard`: idle clock, proactive refresh, cross-tab `BroadcastChannel` |
+
+One of the three, ever. Never two countdowns for one session.
+
+There are two ways the declaration can arrive, and they are not equally strong.
+
+```tsx
+// The launch parameter: ?token=…&cortenaGuard=host
+const launch = readCortenaLaunch({ hostOrigins: [config.cortenaWebOrigin] });
+
+// The first bridge message. Give the same allow-list to the composition and it
+// listens for `{ type: "cortena-session", guarded: true, accessToken? }` itself.
+<CortenaApp session={{ launch, hostOrigins: [config.cortenaWebOrigin], … }} />
+```
+
+Both are checked against an allow-list **your app supplies from its own
+configuration**, never against anything in the request. With no `hostOrigins`
+nothing is ever trusted, which is the safe direction: the frame then runs its
+own countdown rather than trusting a parent it cannot name.
+
+**Prefer the bridge.** `readCortenaSessionMessage` checks `event.origin`, which
+the browser sets from the sending document and which cannot be forged from
+inside the page that sent it. The launch parameter is checked against
+`ancestorOrigins`, which is WebKit/Blink only; everywhere else the input is
+`document.referrer`, and an open redirect on the CortenaWeb origin can produce
+one that reads as CortenaWeb's. The failure is downgrade-only — a forged
+declaration mounts *no* guard, it cannot mount a second one or obtain a token —
+but "no guard" is the state decision (b) exists to remove, so pass
+`hostOrigins` and let the host say it on the bridge. `launch.ts` carries the
+whole note.
+
+Token renewals arrive the same way: over the bridge where `hostOrigins` is set,
+or through `session.onTokenRenewed` for an app that would rather own the
+listener. Either one, and a token the app itself signs in with, clears the
+signed-out state.
+
+Call it in your store's initialiser, synchronously, before `createRoot`. §7.3
+is the single most common embedding failure: a token read in an effect is read
+after a `ProtectedRoute` has already redirected and stripped the query string,
+and the user sees a login page inside CortenaWeb with nothing to explain it.
+
+`session.signOut` is optional, and omitting it is meaningful: in a framed launch
+with no host sign-out message to send, the avatar menu's Log out is disabled
+rather than silently doing nothing.
+
+### The standard pages
+
+`/me`, `/settings` and `/settings/permissions` are the composition's, reachable
+from the avatar menu, and the Settings item is **never** disabled:
+
+- **Profile** — the person's own name, avatar and account link. cortena-auth
+  owns the user record, so the page shows it and links to it rather than
+  pretending an extension can edit it.
+- **Permissions** — `AdminPermissions` against the §14.3 admin routes, rendered
+  only when `permissions.canAdminister`. Absent otherwise, not disabled: "you
+  may not" is not a screen. The admin tabs push
+  `/settings/permissions/<screen>`, so they are deep-linkable.
+
+  **`canAdminister` comes from your own permissions client, against the §14.3
+  routes — never from an `orgRole` claim on the JWT.** Whether somebody may
+  administer *your extension* is your `may()`'s answer over your own matrix
+  (§14.2, §14.4); cortena-auth's org role says who owns the organisation, which
+  is a different question and one the bootstrap already answered once. Reading
+  the claim looks equivalent, hides the screen from an administrator your
+  matrix granted, shows it to an org owner your matrix did not, and neither is
+  visible until somebody complains. This flag only decides whether the section
+  renders; the routes behind it enforce the real thing either way.
+- **The extension's own settings** — whatever it declares, or one plain line:
+  "Nothing to configure for <name> yet." An extension that later gains settings
+  declares a schema rather than building a page.
+
+The routing is your router's. The composition compares `pathname` to the three
+paths and renders its own page instead of `children` when one matches, so it
+works under any router at all — mount it as a layout and give the router a
+route for those paths that renders nothing of its own:
+
+```tsx
+// react-router
+<Route element={<Frame />}>
+  <Route path="/me" element={null} />
+  <Route path="/settings/*" element={null} />
+  …
+</Route>
+
+// Next.js: app/me/page.tsx and app/settings/[[...rest]]/page.tsx, each
+// rendering null. The frame is in the layout, and it is "use client".
+```
+
+`matchCortenaStandardRoute(pathname)` is exported for an app that would rather
+place `CortenaSettingsPage` and `CortenaProfilePage` itself: it is the same
+rule, not a second copy of it.
+
+### The settings declaration
+
+```tsx
+const settings = z.object({
+  alertThreshold: z.number().describe("Raise an alert when a stream falls this far behind."),
+  pauseOnFailure: z.boolean(),
+  alertChannel: z.enum(["email", "channels", "none"]),
+});
+
+<CortenaApp settings={{ schema: settings, load, save }} … />
+```
+
+The fields are derived from the object's shape, and `safeParse` validates a
+save. This package imports no zod: the schema is typed structurally and only
+ever called, so it works across zod 3 and 4, whose internals differ, and costs
+the frame nothing. Reading the shape is deliberately tolerant — a schema it
+cannot read gives no fields, which draws the "nothing to configure" line rather
+than throwing on a settings page.
+
+Pass `fields` where the schema alone does not say enough — a select's options,
+a longer description, a textarea. `load` and `save` are the extension's own
+`/settings` route; the composition never stores anything.
+
+### What it does not do
+
+There is **no consent route**. cortena-auth is the authorisation server and
+renders consent; the content comes from the `scopes` section of the extension's
+own `x-cortena` identity block, which cortena-auth reads from the registered
+in-cluster address. An extension ships no consent screen.
+
+And `@ag-ui/client` is reachable from `cortena-ui/agent-chat` and nowhere else,
+including here. The transport factory is a prop — `agent.createClient` — rather
+than an import, which is one named import for the extension and leaves the
+composition owning every argument the pop-up is built with: the user's token,
+read fresh on every request, and the agent slug. Those are the two an extension
+shipped without.
+
 ## Shell chrome
 
 `AppShell` is the chrome every extension wears (§9 of

package/dist/app.d.ts

@@ -0,0 +1,6 @@
+"use client";
+import { CORTENA_GUARD_HOST, CORTENA_GUARD_PARAM, CORTENA_SESSION_MESSAGE, CortenaLaunch, CortenaSessionMessage, ReadCortenaLaunchOptions, isHostGuardDeclared, readCortenaLaunch, readCortenaSessionMessage } from "./components/app/launch.js";
+import { CortenaAppAgent } from "./components/app/agent-mount.js";
+import { CortenaAppPermissions, CortenaAppUser, CortenaProfilePage, CortenaSettingsControl, CortenaSettingsDeclaration, CortenaSettingsField, CortenaSettingsPage, CortenaSettingsPageProps, CortenaSettingsSchema, ProfileSection, ProfileSectionProps, settingsFields } from "./components/app/settings.js";
+import { CORTENA_STANDARD_ROUTES, CortenaApp, CortenaAppAuth, CortenaAppExtension, CortenaAppProps, CortenaAppRoutes, CortenaSessionAdapter, CortenaStandardRoute, matchCortenaStandardRoute } from "./components/app/cortena-app.js";
+export { CORTENA_GUARD_HOST, CORTENA_GUARD_PARAM, CORTENA_SESSION_MESSAGE, CORTENA_STANDARD_ROUTES, CortenaApp, type CortenaAppAgent, type CortenaAppAuth, type CortenaAppExtension, type CortenaAppPermissions, type CortenaAppProps, type CortenaAppRoutes, type CortenaAppUser, type CortenaLaunch, CortenaProfilePage, type CortenaSessionAdapter, type CortenaSessionMessage, type CortenaSettingsControl, type CortenaSettingsDeclaration, type CortenaSettingsField, CortenaSettingsPage, type CortenaSettingsPageProps, type CortenaSettingsSchema, type CortenaStandardRoute, ProfileSection, type ProfileSectionProps, type ReadCortenaLaunchOptions, isHostGuardDeclared, matchCortenaStandardRoute, readCortenaLaunch, readCortenaSessionMessage, settingsFields };

package/dist/app.js

@@ -0,0 +1,5 @@
+"use client";
+import { CORTENA_GUARD_HOST, CORTENA_GUARD_PARAM, CORTENA_SESSION_MESSAGE, isHostGuardDeclared, readCortenaLaunch, readCortenaSessionMessage } from "./components/app/launch.js";
+import { CortenaProfilePage, CortenaSettingsPage, ProfileSection, settingsFields } from "./components/app/settings.js";
+import { CORTENA_STANDARD_ROUTES, CortenaApp, matchCortenaStandardRoute } from "./components/app/cortena-app.js";
+export { CORTENA_GUARD_HOST, CORTENA_GUARD_PARAM, CORTENA_SESSION_MESSAGE, CORTENA_STANDARD_ROUTES, CortenaApp, CortenaProfilePage, CortenaSettingsPage, ProfileSection, isHostGuardDeclared, matchCortenaStandardRoute, readCortenaLaunch, readCortenaSessionMessage, settingsFields };

package/dist/components/admin-permissions/index.js

@@ -0,0 +1,11 @@
+"use client";
+"use client";
+import { ADMIN_ROUTES, ADMIN_ROUTE_LABELS, adminErrorMessage, effectiveRolesOf, sourceGroupOf } from "./types.js";
+import { AdminPermissionsProvider, useAdminPermissions } from "./context.js";
+import { AdminLicenceScreen } from "./licence.js";
+import { AdminMatrix } from "./matrix.js";
+import { DirectRoles, EffectiveRoles, RoleAssignmentDialog } from "./role-assignment.js";
+import { AdminMembers } from "./members.js";
+import { AdminRoles } from "./roles.js";
+import { AdminPermissions } from "./admin-permissions.js";
+export { ADMIN_ROUTES, ADMIN_ROUTE_LABELS, AdminLicenceScreen, AdminMatrix, AdminMembers, AdminPermissions, AdminPermissionsProvider, AdminRoles, DirectRoles, EffectiveRoles, RoleAssignmentDialog, adminErrorMessage, effectiveRolesOf, sourceGroupOf, useAdminPermissions };

package/dist/components/app/agent-mount.d.ts

@@ -0,0 +1,53 @@
+"use client";
+import { AgentChatClient } from "../../agent-chat/types.js";
+import { McpAppToolCaller } from "../../agent-chat/mcp-app/bridge.js";
+import "react";
+//#region src/components/app/agent-mount.d.ts
+/**
+ * The agent pop-up, wired the way §19 says and not the way each extension
+ * remembered it.
+ *
+ * This module is loaded lazily by `CortenaApp`, and that is the whole reason
+ * it is a module at all: `AgentChatPopup` reaches `AgentChat`, which reaches
+ * `Markdown` and the A2UI renderer. An extension's first screen must not carry
+ * a markdown pipeline for a chat the user has not opened, so the frame imports
+ * this by `import()` and a bundler splits it off.
+ *
+ * `createClient` is passed in rather than imported for a different reason.
+ * `createAguiAgentChatClient` reaches `@ag-ui/client` — rxjs, zod 3, uuid,
+ * protobuf — and `test/bundle-probe.test.mjs` fails if `@ag-ui/*` is reachable
+ * from any entry but `cortena-ui/agent-chat`. Keeping the factory a prop keeps
+ * that guarantee exactly as it is, and still leaves the composition owning
+ * every argument the pop-up is built with: the user's token, read fresh on
+ * every request, and the agent slug. Both were the ones an extension shipped
+ * without.
+ */
+export interface CortenaAppAgent {
+  /** The AgentTemplate slug. Usually the extension id; §19.1. */
+  slug: string;
+  /** This extension's own gateway, never cortenacore. Default `/api/agent`. */
+  gatewayUrl?: string;
+  /**
+   * `createAguiAgentChatClient` from `cortena-ui/agent-chat`, passed through.
+   * One named import, and the composition supplies every argument.
+   */
+  createClient: (options: {
+    baseUrl: string;
+    agentId: string;
+    getToken: () => string;
+  }) => AgentChatClient;
+  /**
+   * How a screen drawn inside the pop-up reaches this extension's own MCP
+   * server, with the user's credential (§19.2, step 4). Omitted, tool results
+   * stay ordinary cards.
+   */
+  relay?: McpAppToolCaller;
+  /**
+   * `cortena-design/tokens.css?raw`. The sandboxed document has an opaque
+   * origin and `default-src 'none'`, so it can fetch nothing: the tokens go in
+   * as text or the screen renders unstyled.
+   */
+  tokensCss?: string;
+}
+//#endregion
+//# sourceMappingURL=agent-mount.d.ts.map

package/dist/components/app/agent-mount.js

@@ -0,0 +1,40 @@
+"use client";
+"use client";
+import { AgentChatPopup } from "../agent-chat-popup.js";
+import { renderMcpAppToolCall } from "../../agent-chat/mcp-app/render-tool-call.js";
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+//#region src/components/app/agent-mount.tsx
+function AgentMount({ extension, agent, getToken }) {
+	const identity = React.useRef({
+		agent,
+		getToken
+	});
+	identity.current = {
+		agent,
+		getToken
+	};
+	const client = React.useMemo(() => identity.current.agent.createClient({
+		baseUrl: identity.current.agent.gatewayUrl ?? "/api/agent",
+		agentId: identity.current.agent.slug,
+		getToken: () => identity.current.getToken()
+	}), []);
+	const renderToolCall = React.useMemo(() => {
+		const relay = identity.current.agent.relay;
+		if (!relay) return;
+		return renderMcpAppToolCall({
+			extensionId: extension.id,
+			callTool: relay,
+			tokensCss: identity.current.agent.tokensCss
+		});
+	}, [extension.id]);
+	return /* @__PURE__ */ jsx(AgentChatPopup, {
+		extension,
+		client,
+		renderToolCall
+	});
+}
+//#endregion
+export { AgentMount as default };
+
+//# sourceMappingURL=agent-mount.js.map

package/dist/components/app/agent-mount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-mount.js","names":[],"sources":["../../../src/components/app/agent-mount.tsx"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\nimport { AgentChatPopup } from \"@/components/agent-chat-popup\";\nimport { renderMcpAppToolCall } from \"@/agent-chat/mcp-app/render-tool-call\";\nimport type { McpAppToolCaller } from \"@/agent-chat/mcp-app/bridge\";\nimport type { AgentChatClient } from \"@/agent-chat/types\";\n\n/**\n * The agent pop-up, wired the way §19 says and not the way each extension\n * remembered it.\n *\n * This module is loaded lazily by `CortenaApp`, and that is the whole reason\n * it is a module at all: `AgentChatPopup` reaches `AgentChat`, which reaches\n * `Markdown` and the A2UI renderer. An extension's first screen must not carry\n * a markdown pipeline for a chat the user has not opened, so the frame imports\n * this by `import()` and a bundler splits it off.\n *\n * `createClient` is passed in rather than imported for a different reason.\n * `createAguiAgentChatClient` reaches `@ag-ui/client` — rxjs, zod 3, uuid,\n * protobuf — and `test/bundle-probe.test.mjs` fails if `@ag-ui/*` is reachable\n * from any entry but `cortena-ui/agent-chat`. Keeping the factory a prop keeps\n * that guarantee exactly as it is, and still leaves the composition owning\n * every argument the pop-up is built with: the user's token, read fresh on\n * every request, and the agent slug. Both were the ones an extension shipped\n * without.\n */\n\nexport interface CortenaAppAgent {\n  /** The AgentTemplate slug. Usually the extension id; §19.1. */\n  slug: string;\n  /** This extension's own gateway, never cortenacore. Default `/api/agent`. */\n  gatewayUrl?: string;\n  /**\n   * `createAguiAgentChatClient` from `cortena-ui/agent-chat`, passed through.\n   * One named import, and the composition supplies every argument.\n   */\n  createClient: (options: {\n    baseUrl: string;\n    agentId: string;\n    getToken: () => string;\n  }) => AgentChatClient;\n  /**\n   * How a screen drawn inside the pop-up reaches this extension's own MCP\n   * server, with the user's credential (§19.2, step 4). Omitted, tool results\n   * stay ordinary cards.\n   */\n  relay?: McpAppToolCaller;\n  /**\n   * `cortena-design/tokens.css?raw`. The sandboxed document has an opaque\n   * origin and `default-src 'none'`, so it can fetch nothing: the tokens go in\n   * as text or the screen renders unstyled.\n   */\n  tokensCss?: string;\n}\n\nexport interface AgentMountProps {\n  extension: { id: string; name: string };\n  agent: CortenaAppAgent;\n  /** Read on every request rather than captured, so a renewal is picked up. */\n  getToken: () => string;\n}\n\nfunction AgentMount({ extension, agent, getToken }: AgentMountProps) {\n  // Built once for the life of the mount. The chat re-subscribes to the run\n  // stream and refetches its session list whenever the client's identity\n  // changes, so a client rebuilt per render is a session list refetched per\n  // render. The identity is constant by construction: the slug is a string and\n  // the token is read through a function rather than captured as a value.\n  const identity = React.useRef({ agent, getToken });\n  identity.current = { agent, getToken };\n\n  const client = React.useMemo(\n    () =>\n      identity.current.agent.createClient({\n        baseUrl: identity.current.agent.gatewayUrl ?? \"/api/agent\",\n        agentId: identity.current.agent.slug,\n        getToken: () => identity.current.getToken(),\n      }),\n    [],\n  );\n\n  const renderToolCall = React.useMemo(() => {\n    const relay = identity.current.agent.relay;\n    if (!relay) {\n      return undefined;\n    }\n    return renderMcpAppToolCall({\n      extensionId: extension.id,\n      callTool: relay,\n      tokensCss: identity.current.agent.tokensCss,\n      // `onMessage` is left unset on purpose: the surface's own `send` takes\n      // it, so a click inside a screen starts the next turn as the screen\n      // rather than as a user who typed nothing (DESIGN-80).\n    });\n    // The extension id is fixed for the life of the app; rebuilding this would\n    // reload a screen that is already running.\n  }, [extension.id]);\n\n  return <AgentChatPopup extension={extension} client={client} renderToolCall={renderToolCall} />;\n}\n\nexport default AgentMount;\n"],"mappings":";;;;;;;AA+DA,SAAS,WAAW,EAAE,WAAW,OAAO,YAA6B;CAMnE,MAAM,WAAW,MAAM,OAAO;EAAE;EAAO;CAAS,CAAC;CACjD,SAAS,UAAU;EAAE;EAAO;CAAS;CAErC,MAAM,SAAS,MAAM,cAEjB,SAAS,QAAQ,MAAM,aAAa;EAClC,SAAS,SAAS,QAAQ,MAAM,cAAc;EAC9C,SAAS,SAAS,QAAQ,MAAM;EAChC,gBAAgB,SAAS,QAAQ,SAAS;CAC5C,CAAC,GACH,CAAC,CACH;CAEA,MAAM,iBAAiB,MAAM,cAAc;EACzC,MAAM,QAAQ,SAAS,QAAQ,MAAM;EACrC,IAAI,CAAC,OACH;EAEF,OAAO,qBAAqB;GAC1B,aAAa,UAAU;GACvB,UAAU;GACV,WAAW,SAAS,QAAQ,MAAM;EAIpC,CAAC;CAGH,GAAG,CAAC,UAAU,EAAE,CAAC;CAEjB,OAAO,oBAAC,gBAAD;EAA2B;EAAmB;EAAwB;CAAiB,CAAA;AAChG"}