@kortix/ui 0.0.0-stage → 0.14.4

package/dist/internal/lib/capability-tab-routes.js

@@ -0,0 +1,176 @@
+import { customizePath, uiRoutes } from '../../lib/routes.js';
+/**
+ * This array is the tab order, the sidebar order, and — via the first entry
+ * the caller may read — the landing tab. `TAB_PREFERENCE` in
+ * `project-sidebar/project-settings-nav.tsx` mirrors it and is asserted
+ * against it, so reordering here moves the landing tab too.
+ *
+ * ## Agents lead, everything else is their library
+ *
+ * Customize is agent-centric (Marko, 2026-09-01). An agent is the only
+ * object a project manager grants a person or a group access to — the object
+ * policy for `agent` is `closed`, every other resource is `open`
+ * (`apps/api/src/iam/authorize.ts`) — so it is the primitive every other
+ * decision hangs off: which model it thinks with, which skills it loads,
+ * which connectors and secrets it may reach, when a trigger starts it. The
+ * bar is ordered the way that decision is made: Agents leads, alone, and the
+ * resources an agent draws on — Skills first among them — follow behind a
+ * seam. `PRIMARY_TABS` below names the leading group so the bar can draw it.
+ *
+ * Every tab lives under `/projects/<id>/customize/<segment>` (Marko,
+ * 2026-09-03); `CAPABILITY_SEGMENT` maps a key to its segment. The Agents key
+ * stays singular for stability, its segment is `agents`, and one agent lives
+ * one level deeper, at `agentHref` (`/projects/<id>/customize/agents/<name>`).
+ *
+ * There is no Settings tab. `/projects/<id>/config` — the bar's trailing
+ * "Settings" tab, a sub-nav over General / Sandbox templates / Review /
+ * Feature flags / Upgrades — was retired on 2026-09-02 (Jay). Its
+ * configuration sections live in the Settings overlay's Workspace group
+ * (`settings/rail.ts`, opened with Cmd+, or from the workspace switcher).
+ * `settings-tabs.ts` redirects every retired `/config?section=` link.
+ *
+ * Review is a tab again (Marko, 2026-10-17). It was one from 2026-09-02 to
+ * 2026-10-02, then its own sidebar row and page. That row showed an empty
+ * inbox to members who can act on nothing in it. As a tab it follows the
+ * Customize rule: only a caller holding `project.review.act` sees it.
+ *
+ * Reminders is a tab (Marko, 2026-10-19). It was a sidebar row, shown to every
+ * member while a reminder could still fire. It follows the Triggers rule: a
+ * reminder is a session-scoped trigger, so the tab shows only to a caller who
+ * can configure triggers.
+ *
+ * Two tabs are flag-gated: Repo needs the `drives` flag, Reminders the
+ * `reminders` flag (`capabilityAccess()`). Every other tab is always painted.
+ */
+export const CAPABILITY_TABS = [
+    { key: 'agent', label: 'Agents' },
+    { key: 'skills', label: 'Skills' },
+    { key: 'connectors', label: 'Connectors' },
+    { key: 'triggers', label: 'Triggers' },
+    { key: 'reminders', label: 'Reminders' },
+    { key: 'models', label: 'Models' },
+    { key: 'secrets', label: 'Secrets' },
+    { key: 'files', label: 'Repo' },
+    { key: 'review', label: 'Review' },
+    { key: 'config', label: 'Settings' },
+];
+/**
+ * The tab the bar is built around. Agents alone (Marko, 2026-09-03): the
+ * agent is the object a person is granted, and everything to the right of
+ * the seam — Skills included — is what an agent draws on. The bar draws a
+ * hairline seam after it, and it is the landing tab.
+ */
+export const PRIMARY_TABS = ['agent'];
+/**
+ * A tab's URL segment. Keys are stable identifiers used across the app
+ * (`TAB_PREFERENCE`, the palette, tests); segments are what a person reads in
+ * the address bar. The two differ where the key predates the URL: `agent`
+ * (singular key, kept so nothing keyed on it moves) lives at `agents`, and
+ * `config` — named to dodge the Preferences overlay's `/settings` route back
+ * when tabs sat directly under the project — lives at `settings` now that
+ * every tab sits under `/customize/`.
+ */
+export const CAPABILITY_SEGMENT = {
+    agent: 'agents',
+    skills: 'skills',
+    connectors: 'connectors',
+    triggers: 'triggers',
+    reminders: 'reminders',
+    models: 'models',
+    secrets: 'secrets',
+    files: 'repo',
+    review: 'review',
+    config: 'settings',
+};
+/** The root every capability tab hangs off (Marko, 2026-09-03: "always
+ *  /customize/agents, /customize/skills"). */
+export function customizeHref(projectId) {
+    return customizePath(projectId);
+}
+/** The tab's URL: the host's `customize` route (`setUiRoutes`) with the tab segment. */
+export function capabilityTabHref(projectId, key) {
+    return customizePath(projectId, CAPABILITY_SEGMENT[key]);
+}
+/**
+ * A link to a capability tab from outside the customize pages (sidebar, session
+ * header, hover cards). Null when the host serves no customize pages
+ * (`setUiRoutes({ customize: () => null })`): the caller hides the link.
+ * `capabilityTabHref` is the customize pages' own tab URL and never null.
+ */
+export function capabilityLinkHref(projectId, key) {
+    return uiRoutes().customize(projectId, CAPABILITY_SEGMENT[key]);
+}
+/**
+ * The Review Center: the Customize Review tab, or null when the host serves no
+ * customize pages. `/projects/<id>/review`, its address from 2026-10-02 to
+ * 2026-10-17, redirects here.
+ */
+export function reviewHref(projectId) {
+    return capabilityLinkHref(projectId, 'review');
+}
+/**
+ * The Reminders page: the Customize Reminders tab, or null when the host
+ * serves no customize pages. `/projects/<id>/reminders`, its address until
+ * 2026-10-19, redirects here.
+ */
+export function remindersHref(projectId) {
+    return capabilityLinkHref(projectId, 'reminders');
+}
+/**
+ * One agent's page — the configuration of a single `agents.<name>` block,
+ * routed rather than modal so it has a URL a person can be sent to. The name
+ * is the manifest key, which may carry characters a path segment cannot, so
+ * it is encoded here and decoded in the page (`decodeURIComponent`).
+ */
+export function agentHref(projectId, agentName) {
+    return `${capabilityTabHref(projectId, 'agent')}/${encodeURIComponent(agentName)}`;
+}
+/**
+ * The scope value the Connectors page reads out of `?scope=` to show Channels.
+ * Exported so the three places that link to Channels — the retired
+ * `/projects/<id>/channels` route, the `GRADUATED` map in `settings-tabs.ts`,
+ * and the project-home setup tile — cannot drift from the page that parses it.
+ */
+export const CHANNELS_SCOPE = 'channels';
+/**
+ * Where Channels lives now: a scope of the Connectors page, not a route of its
+ * own. `/projects/<id>/channels` still resolves — it redirects here — so every
+ * bookmark taken while it was a tab keeps working.
+ */
+export function channelsHref(projectId) {
+    return `${capabilityTabHref(projectId, 'connectors')}?scope=${CHANNELS_SCOPE}`;
+}
+/**
+ * The tab a pathname is on, matched against the shape `capabilityTabHref`
+ * builds — `/projects/<id>/customize/<segment>` exactly — plus the deeper
+ * shapes this group owns: `agentHref`'s `/projects/<id>/customize/agents/<name>`,
+ * which lights the Agents tab (an agent's page is the Agents tab, opened on
+ * one agent), and the app and connector pages under
+ * `/projects/<id>/customize/connectors`, which light Connectors.
+ *
+ * The shape check is load-bearing, not defensive tidying. This used to match on
+ * the LAST segment alone, which was harmless while every key was unique to this
+ * route group. It stopped being harmless when Schedules and Webhooks arrived:
+ * the Settings overlay is also routable, at `/projects/<id>/settings/<tab>`, so
+ * a last-segment match reported `/projects/p1/settings/schedules` as the
+ * Schedules capability tab and lit the sidebar's Customize row from inside
+ * Settings. The agent branch is therefore keyed on the THIRD segment being
+ * `agent`, never on the last one.
+ */
+export function activeCapabilityTab(pathname) {
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments[0] !== 'projects' || segments[2] !== 'customize')
+        return null;
+    if (segments.length === 5 && segments[3] === CAPABILITY_SEGMENT.agent)
+        return 'agent';
+    // An app's page (`/connectors/<app>`) and a connector's page
+    // (`/connectors/<app>/<connector>`) are the Connectors tab, opened on one.
+    if ((segments.length === 5 || segments.length === 6) &&
+        segments[3] === CAPABILITY_SEGMENT.connectors) {
+        return 'connectors';
+    }
+    if (segments.length !== 4)
+        return null;
+    const hit = CAPABILITY_TABS.find((t) => CAPABILITY_SEGMENT[t.key] === segments[3]);
+    return hit ? hit.key : null;
+}

package/dist/internal/lib/chunk-load-recovery.d.ts

@@ -0,0 +1,46 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * One automatic reload recovers a stale-deploy chunk-load failure.
+ *
+ * A deploy replaces the hashed `_next/static/chunks` assets. A tab that holds
+ * stale HTML or a stale client bundle then requests chunk URLs the current
+ * deployment no longer serves, the import fails, and the nearest error
+ * boundary renders the crash card — while a reload re-fetches the current
+ * deploy and heals the page. Reported on dev as a full-page crash on a direct
+ * navigation to /settings/profile right after a deploy (KRTX-1613).
+ *
+ * The reload happens exactly once: a second sighting inside the window renders
+ * the real error card instead, so a persistent failure (bad deploy, blocked
+ * network) can never reload-loop. sessionStorage holds the mark because it
+ * survives a reload and dies with the tab. Without storage (disabled in some
+ * webviews) there is no guard, so there is no unguarded reload either.
+ *
+ * Telemetry already filters this class (`sentry.client.config.ts` ignores
+ * `ChunkLoadError` and `Failed to fetch`; `browser-noise/rules/chunk-load.ts`
+ * classifies the stale runtime shape), so a recovered throw stays silent and
+ * the recurring failure only ever shows the card.
+ */
+/** How long one reload mark suppresses further automatic reloads. */
+export declare const CHUNK_RELOAD_WINDOW_MS = 45000;
+/**
+ * Whether the boundary's error is a failed script-chunk load: webpack's
+ * `ChunkLoadError` (`Loading chunk <n> failed.`), a native dynamic-import
+ * failure, or the stale webpack runtime lookup whose stack points at the
+ * runtime chunk. A message that merely mentions a dynamic import names the
+ * same recovery class; the once-guard bounds any over-match to one reload.
+ */
+export declare function isChunkLoadError(error: unknown): boolean;
+export interface ChunkReloadDeps {
+    now?: () => number;
+    storage?: Pick<Storage, 'getItem' | 'setItem'> | null;
+    reload?: () => void;
+}
+/**
+ * Classify `error` and, on the first chunk-load failure inside the window,
+ * trigger one document reload. Returns whether a reload was triggered — the
+ * caller renders nothing while it lands, and the plain error card when it
+ * returns false.
+ */
+export declare function reloadForChunkLoadError(error: unknown, deps?: ChunkReloadDeps): boolean;
+/** Shared tab budget for bootstrap, lazy imports and React boundaries. */
+export declare function reloadForStaleChunk(deps?: ChunkReloadDeps): boolean;

package/dist/internal/lib/chunk-load-recovery.js

@@ -0,0 +1,107 @@
+/**
+ * One automatic reload recovers a stale-deploy chunk-load failure.
+ *
+ * A deploy replaces the hashed `_next/static/chunks` assets. A tab that holds
+ * stale HTML or a stale client bundle then requests chunk URLs the current
+ * deployment no longer serves, the import fails, and the nearest error
+ * boundary renders the crash card — while a reload re-fetches the current
+ * deploy and heals the page. Reported on dev as a full-page crash on a direct
+ * navigation to /settings/profile right after a deploy (KRTX-1613).
+ *
+ * The reload happens exactly once: a second sighting inside the window renders
+ * the real error card instead, so a persistent failure (bad deploy, blocked
+ * network) can never reload-loop. sessionStorage holds the mark because it
+ * survives a reload and dies with the tab. Without storage (disabled in some
+ * webviews) there is no guard, so there is no unguarded reload either.
+ *
+ * Telemetry already filters this class (`sentry.client.config.ts` ignores
+ * `ChunkLoadError` and `Failed to fetch`; `browser-noise/rules/chunk-load.ts`
+ * classifies the stale runtime shape), so a recovered throw stays silent and
+ * the recurring failure only ever shows the card.
+ */
+/** How long one reload mark suppresses further automatic reloads. */
+export const CHUNK_RELOAD_WINDOW_MS = 45_000;
+const CHUNK_RELOAD_MARK = 'kortix:chunk-reload-at';
+/** The stale webpack runtime lookup, already classified for Sentry in `browser-noise/rules/chunk-load.ts`. */
+const STALE_RUNTIME_MESSAGE = "Cannot read properties of undefined (reading 'call')";
+const WEBPACK_RUNTIME_CHUNK = /\/_next\/static\/chunks\/webpack-/;
+/** Native dynamic-import failure spellings per engine: Chrome, Safari, Firefox. */
+const DYNAMIC_IMPORT_PATTERNS = [
+    'Failed to fetch dynamically imported module',
+    'Importing a module script failed',
+    'error loading dynamically imported module',
+];
+/**
+ * Whether the boundary's error is a failed script-chunk load: webpack's
+ * `ChunkLoadError` (`Loading chunk <n> failed.`), a native dynamic-import
+ * failure, or the stale webpack runtime lookup whose stack points at the
+ * runtime chunk. A message that merely mentions a dynamic import names the
+ * same recovery class; the once-guard bounds any over-match to one reload.
+ */
+export function isChunkLoadError(error) {
+    const err = error;
+    if (!err || typeof err !== 'object')
+        return false;
+    const name = typeof err.name === 'string' ? err.name : '';
+    const message = typeof err.message === 'string' ? err.message : '';
+    if (name === 'ChunkLoadError' || message.includes('ChunkLoadError'))
+        return true;
+    const loading = message.indexOf('Loading chunk ');
+    if (loading >= 0 && message.indexOf(' failed.', loading + 'Loading chunk '.length) >= 0)
+        return true;
+    if (DYNAMIC_IMPORT_PATTERNS.some((pattern) => message.includes(pattern)))
+        return true;
+    // The stale runtime TypeError is only a chunk-load failure when the throwing
+    // frame is the webpack runtime chunk; the error object carries that in its
+    // stack text. A real `.call()` TypeError inside app code has an app stack.
+    if (message === STALE_RUNTIME_MESSAGE) {
+        return typeof err.stack === 'string' && WEBPACK_RUNTIME_CHUNK.test(err.stack);
+    }
+    return false;
+}
+function browserSessionStorage() {
+    try {
+        if (typeof window === 'undefined')
+            return null;
+        return window.sessionStorage;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Classify `error` and, on the first chunk-load failure inside the window,
+ * trigger one document reload. Returns whether a reload was triggered — the
+ * caller renders nothing while it lands, and the plain error card when it
+ * returns false.
+ */
+export function reloadForChunkLoadError(error, deps = {}) {
+    return isChunkLoadError(error) && reloadForStaleChunk(deps);
+}
+/** Shared tab budget for bootstrap, lazy imports and React boundaries. */
+export function reloadForStaleChunk(deps = {}) {
+    const now = deps.now ?? (() => Date.now());
+    const storage = deps.storage !== undefined ? deps.storage : browserSessionStorage();
+    if (!storage)
+        return false;
+    const reload = deps.reload ?? (() => window.location.reload());
+    let mark = null;
+    try {
+        mark = storage.getItem(CHUNK_RELOAD_MARK);
+    }
+    catch {
+        return false;
+    }
+    const last = mark === null ? null : Number(mark);
+    if (last !== null && Number.isFinite(last) && now() - last < CHUNK_RELOAD_WINDOW_MS) {
+        return false;
+    }
+    try {
+        storage.setItem(CHUNK_RELOAD_MARK, String(now()));
+    }
+    catch {
+        return false;
+    }
+    reload();
+    return true;
+}

package/dist/internal/lib/chunk-reload.d.ts

@@ -0,0 +1,31 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * One-shot recovery from a stale-deploy chunk failure.
+ *
+ * After a deploy, a tab still running the previous build requests chunk file
+ * names that no longer exist, and the first lazy `next/dynamic` import
+ * rejects — on /settings/profile that surfaced as an error page instead of
+ * the panel. The App Router wraps `next/dynamic` in Suspense, so the
+ * rejection never reaches `error.tsx`; and the dev turbopack loader leaves a
+ * failed import pending forever instead of rejecting. The fix that covers
+ * both lives at the loader: a rejected or hung import is a dead chunk —
+ * reload the tab once (a fresh load requests the current build's chunks) and
+ * hold the Suspense boundary while the navigation runs. The sessionStorage
+ * guard is the loop brake: one auto-reload per 45 s per tab, so a chunk
+ * failure that survives the reload lands on the existing error card instead
+ * of spinning.
+ */
+import { reloadForStaleChunk } from './chunk-load-recovery.js';
+export { reloadForStaleChunk };
+export declare function isChunkLoadError(error: unknown): boolean;
+/**
+ * Wrap a `next/dynamic` loader with the one-shot stale-chunk recovery.
+ *
+ * A rejected import recovers when it matches `isChunkLoadError`; a hung one
+ * (the dev loader) is treated as dead after 15 s — ponytail: a healthy import
+ * slower than that reloads once, then the guard brakes; raise the timeout if
+ * slow-network users report a needless reload. Any other rejection goes
+ * straight to the existing error card, and so does a recovery the guard
+ * refuses.
+ */
+export declare function withStaleChunkRecovery<T>(loader: () => Promise<T>): () => Promise<T>;

package/dist/internal/lib/chunk-reload.js

@@ -0,0 +1,59 @@
+/**
+ * One-shot recovery from a stale-deploy chunk failure.
+ *
+ * After a deploy, a tab still running the previous build requests chunk file
+ * names that no longer exist, and the first lazy `next/dynamic` import
+ * rejects — on /settings/profile that surfaced as an error page instead of
+ * the panel. The App Router wraps `next/dynamic` in Suspense, so the
+ * rejection never reaches `error.tsx`; and the dev turbopack loader leaves a
+ * failed import pending forever instead of rejecting. The fix that covers
+ * both lives at the loader: a rejected or hung import is a dead chunk —
+ * reload the tab once (a fresh load requests the current build's chunks) and
+ * hold the Suspense boundary while the navigation runs. The sessionStorage
+ * guard is the loop brake: one auto-reload per 45 s per tab, so a chunk
+ * failure that survives the reload lands on the existing error card instead
+ * of spinning.
+ */
+import { isChunkLoadError as isChunkFailure, reloadForStaleChunk } from './chunk-load-recovery.js';
+export { reloadForStaleChunk };
+export function isChunkLoadError(error) {
+    return error instanceof Error && isChunkFailure(error);
+}
+const IMPORT_HANG_TIMEOUT_MS = 15_000;
+/**
+ * Wrap a `next/dynamic` loader with the one-shot stale-chunk recovery.
+ *
+ * A rejected import recovers when it matches `isChunkLoadError`; a hung one
+ * (the dev loader) is treated as dead after 15 s — ponytail: a healthy import
+ * slower than that reloads once, then the guard brakes; raise the timeout if
+ * slow-network users report a needless reload. Any other rejection goes
+ * straight to the existing error card, and so does a recovery the guard
+ * refuses.
+ */
+export function withStaleChunkRecovery(loader) {
+    return () => {
+        let hung = false;
+        const attempt = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                hung = true;
+                reject(new Error('lazy chunk did not settle within 15s'));
+            }, IMPORT_HANG_TIMEOUT_MS);
+            loader().then((value) => {
+                clearTimeout(timer);
+                resolve(value);
+            }, (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+        return attempt.then(undefined, (error) => {
+            if (!hung && !isChunkLoadError(error))
+                throw error;
+            if (!reloadForStaleChunk())
+                throw error;
+            // Hold the Suspense boundary with a promise that never settles while
+            // the reload tears the page down, so no error card flashes first.
+            return new Promise(() => { });
+        });
+    };
+}

package/dist/internal/lib/code-theme.d.ts

@@ -0,0 +1,22 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * The one syntax palette for every Shiki-rendered code surface in apps/web:
+ * markdown code blocks, the docs MDX pipeline, the easy-panel file viewer and
+ * the diff viewer all render under this pair.
+ *
+ * This module has NO imports, on purpose. `source.config.ts` is compiled by the
+ * fumadocs-mdx pipeline, outside the Next.js module graph, where `@/` aliases do
+ * not resolve — it reaches these constants by relative path. An import here
+ * would drag the app's module graph into the docs build.
+ *
+ * Keeping the values in one place is the whole point: the previous duplicate in
+ * `source.config.ts` drifted to a different palette AND named the wrong file in
+ * its own "keep in sync" comment.
+ */
+export declare const SHIKI_THEME_DARK = "min-dark";
+export declare const SHIKI_THEME_LIGHT = "min-light";
+/**
+ * The only two themes any code surface may render. Widening this type is how a
+ * second palette would get back in — don't.
+ */
+export type CodeThemeName = typeof SHIKI_THEME_DARK | typeof SHIKI_THEME_LIGHT;

package/dist/internal/lib/code-theme.js

@@ -0,0 +1,16 @@
+/**
+ * The one syntax palette for every Shiki-rendered code surface in apps/web:
+ * markdown code blocks, the docs MDX pipeline, the easy-panel file viewer and
+ * the diff viewer all render under this pair.
+ *
+ * This module has NO imports, on purpose. `source.config.ts` is compiled by the
+ * fumadocs-mdx pipeline, outside the Next.js module graph, where `@/` aliases do
+ * not resolve — it reaches these constants by relative path. An import here
+ * would drag the app's module graph into the docs build.
+ *
+ * Keeping the values in one place is the whole point: the previous duplicate in
+ * `source.config.ts` drifted to a different palette AND named the wrong file in
+ * its own "keep in sync" comment.
+ */
+export const SHIKI_THEME_DARK = 'min-dark';
+export const SHIKI_THEME_LIGHT = 'min-light';

package/dist/internal/lib/codemirror-pierre-theme.d.ts

@@ -0,0 +1,3 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+export declare const pierreDarkCm: import("@codemirror/state").Extension;
+export declare const pierreLightCm: import("@codemirror/state").Extension;

package/dist/internal/lib/codemirror-pierre-theme.js

@@ -0,0 +1,138 @@
+/**
+ * CodeMirror theme that mirrors Pierre Dark / Pierre Light, the same palette
+ * used by Shiki (markdown code blocks, file thumbnails) and `@pierre/diffs`.
+ *
+ * Without this the file viewer (CodeMirror) and the thumbnail (Shiki) draw
+ * the same file with two completely different colour schemes — confusing as
+ * hell. This module is the single source of truth that brings them in line.
+ *
+ * Palette source: `@pierre/theme/pierre-{dark,light}` JSON (`colors` block +
+ * `semanticTokenColors`). Token mappings: Lezer tags from `@lezer/highlight`
+ * matched to Pierre's semantic categories.
+ */
+import { tags as t } from '@lezer/highlight';
+import { createTheme } from '@uiw/codemirror-themes';
+// ---------- Pierre Dark palette ----------
+const dark = {
+    bg: '#070707',
+    fg: '#fbfbfb',
+    cursor: '#009fff',
+    lineHl: '#19283c8c',
+    selection: '#19283c',
+    selectionMatch: '#009fff4d',
+    gutterFg: '#84848A',
+    gutterActiveFg: '#adadb1',
+    comment: '#84848A',
+    string: '#5ecc71',
+    number: '#68cdf2',
+    regexp: '#64d1db',
+    keyword: '#ff678d',
+    variable: '#ffa359',
+    parameter: '#adadb1',
+    property: '#ffa359',
+    function: '#9d6afb',
+    type: '#d568ea',
+    namespace: '#ffca00',
+    enumMember: '#08c0ef',
+    constant: '#ffd452',
+    defaultLib: '#ffca00',
+    operator: '#79797F',
+    punctuation: '#79797F',
+    tag: '#ff6762',
+    attribute: '#61d5c0',
+    heading: '#ff6762',
+    link: '#ff678d',
+};
+// ---------- Pierre Light palette ----------
+const light = {
+    bg: '#ffffff',
+    fg: '#070707',
+    cursor: '#009fff',
+    lineHl: '#dfebff8c',
+    selection: '#dfebff',
+    selectionMatch: '#009fff2e',
+    gutterFg: '#84848A',
+    gutterActiveFg: '#6C6C71',
+    comment: '#84848A',
+    string: '#199f43',
+    number: '#1ca1c7',
+    regexp: '#17a5af',
+    keyword: '#fc2b73',
+    variable: '#d47628',
+    parameter: '#79797F',
+    property: '#d47628',
+    function: '#7b43f8',
+    type: '#c635e4',
+    namespace: '#d5a910',
+    enumMember: '#08c0ef',
+    constant: '#d5a910',
+    defaultLib: '#d5a910',
+    operator: '#79797F',
+    punctuation: '#79797F',
+    tag: '#d63a37',
+    attribute: '#0a8b76',
+    heading: '#d63a37',
+    link: '#fc2b73',
+};
+/**
+ * The editor surface follows the interface theme's canvas (`--background`),
+ * so Light / Dark (soft) and Pure light / Pure dark each get a matching editor
+ * instead of a pure white / black block. Pierre's `bg` is the no-CSS fallback;
+ * the token palette stays Pierre's.
+ */
+const canvas = (fallback) => `var(--background, ${fallback})`;
+function buildTheme(theme, p) {
+    return createTheme({
+        theme,
+        settings: {
+            background: canvas(p.bg),
+            foreground: p.fg,
+            caret: p.cursor,
+            selection: p.selection,
+            selectionMatch: p.selectionMatch,
+            lineHighlight: p.lineHl,
+            gutterBackground: canvas(p.bg),
+            gutterForeground: p.gutterFg,
+            gutterActiveForeground: p.gutterActiveFg,
+            gutterBorder: 'transparent',
+        },
+        styles: [
+            {
+                tag: [t.comment, t.lineComment, t.blockComment, t.docComment],
+                color: p.comment,
+                fontStyle: 'italic',
+            },
+            { tag: [t.string, t.special(t.string), t.regexp], color: p.string },
+            { tag: t.regexp, color: p.regexp },
+            { tag: [t.number, t.bool, t.null], color: p.number },
+            { tag: t.atom, color: p.enumMember },
+            {
+                tag: [t.keyword, t.controlKeyword, t.moduleKeyword, t.modifier, t.operatorKeyword],
+                color: p.keyword,
+            },
+            { tag: t.definitionKeyword, color: p.keyword },
+            { tag: [t.variableName, t.propertyName], color: p.variable },
+            { tag: [t.local(t.variableName), t.special(t.variableName)], color: p.variable },
+            { tag: t.definition(t.variableName), color: p.variable },
+            { tag: t.definition(t.propertyName), color: p.property },
+            { tag: [t.function(t.variableName), t.function(t.propertyName)], color: p.function },
+            { tag: [t.typeName, t.className, t.namespace], color: p.type },
+            { tag: t.constant(t.variableName), color: p.constant },
+            { tag: t.standard(t.variableName), color: p.defaultLib },
+            { tag: t.operator, color: p.operator },
+            { tag: [t.punctuation, t.separator, t.bracket, t.paren, t.brace], color: p.punctuation },
+            { tag: t.tagName, color: p.tag },
+            { tag: t.attributeName, color: p.attribute, fontStyle: 'normal' },
+            { tag: t.attributeValue, color: p.string },
+            { tag: t.heading, color: p.heading, fontWeight: 'bold' },
+            { tag: [t.link, t.url], color: p.link, textDecoration: 'underline' },
+            { tag: t.emphasis, fontStyle: 'italic' },
+            { tag: t.strong, fontWeight: 'bold' },
+            { tag: t.strikethrough, textDecoration: 'line-through' },
+            { tag: t.escape, color: p.number },
+            { tag: t.invalid, color: '#ff2e3f' },
+        ],
+    });
+}
+export const pierreDarkCm = buildTheme('dark', dark);
+export const pierreLightCm = buildTheme('light', light);

package/dist/internal/lib/delivered-but-disconnected.d.ts

@@ -0,0 +1,4 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+export declare function isDeliveredButDisconnected(message: string | null | undefined): boolean;
+/** Pull a comparable message out of whatever the send path threw. */
+export declare function errorMessageOf(err: unknown): string;