@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.3

package/dist/lib/components/app-shell/app-shell-utilities.svelte.js

@@ -0,0 +1,133 @@
+/**
+ * Component-side reader for `app-shell/utility` contributions.
+ *
+ * `captureAppShellUtilities()` must run during component initialization
+ * (Svelte context is readable only then). It reads the runtime the component
+ * was handed through surface-sveltekit context; it never creates a runtime.
+ * `start()` runs after mount, so server render and hydration agree: no
+ * utility is rendered until the browser runtime answers.
+ */
+import { getContext, setContext } from 'svelte';
+import { peekRuntimeSvelteContext } from '@vibesdotdev/surface-sveltekit/svelte/state';
+import { settle, settleNow } from "../../attempt.js";
+import { failureClass } from "../../failure-class.js";
+import { kitLogger } from '../../kit-logger';
+import { resolveAppShellUtilityHost } from "../../app-shell/utility.js";
+import { APP_SHELL_UTILITY_KIND, AppShellUtilityDescriptorSchema, isAppShellUtilityVisible, sortAppShellUtilities } from "./schemas/app-shell-utility.js";
+const logger = kitLogger('vibeskit-app-shell-utility');
+/** Utilities for one Kit surface (the shell chrome, or an error page). */
+export class AppShellUtilities {
+    utilities = $state([]);
+    /** Loaded components, by utility id; a component stays mounted once loaded. */
+    components = $state({});
+    openId = $state(null);
+    /** The trigger that opened the current utility. */
+    openedFrom = $state('header');
+    #store;
+    #viewer;
+    #runtime;
+    constructor(store, viewer) {
+        this.#store = store;
+        this.#viewer = viewer;
+    }
+    get viewer() {
+        return this.#viewer();
+    }
+    /** Every utility this surface shows to its current viewer, in display order. */
+    get visible() {
+        const viewer = this.#viewer();
+        const elsewhere = viewer.shownElsewhere?.() ?? new Set();
+        return this.utilities.filter((utility) => isAppShellUtilityVisible(utility, viewer) && !elsewhere.has(utility.id));
+    }
+    at(placement) {
+        return this.visible.filter((utility) => utility.placement === placement);
+    }
+    /** Ids this surface shows; an enclosed error surface skips them. */
+    shownIds() {
+        return new Set(this.visible.map((utility) => utility.id));
+    }
+    /**
+     * Load descriptors from the handed runtime and attach to its utility host.
+     * Resolves the cleanup. No store, no kind, or a failed load renders nothing.
+     */
+    async start() {
+        if (!this.#store)
+            return () => { };
+        const loaded = await settle(() => this.#store.load());
+        if (!loaded.ok) {
+            logger.warn('App-shell utilities: the handed runtime did not load', {
+                reason: failureClass(loaded.error)
+            });
+            return () => { };
+        }
+        const runtime = loaded.value;
+        if (!runtime.hasKind(APP_SHELL_UTILITY_KIND))
+            return () => { };
+        this.#runtime = runtime;
+        const read = settleNow(() => runtime.query(APP_SHELL_UTILITY_KIND).descriptors());
+        if (!read.ok) {
+            logger.warn('App-shell utilities could not be read', { reason: failureClass(read.error) });
+            return () => { };
+        }
+        const admitted = [];
+        for (const descriptor of read.value) {
+            const parsed = AppShellUtilityDescriptorSchema.safeParse(descriptor);
+            if (parsed.success)
+                admitted.push(parsed.data);
+            else
+                logger.warn('App-shell utility descriptor refused', { reason: 'descriptor-invalid' });
+        }
+        this.utilities = sortAppShellUtilities(admitted);
+        const host = await resolveAppShellUtilityHost(runtime);
+        if (!host)
+            return () => { };
+        return host.attach({
+            open: (id) => {
+                const utility = this.visible.find((candidate) => candidate.id === id);
+                if (!utility)
+                    return false;
+                void this.open(utility, this.#viewer().surface === 'error' ? 'error' : utility.placement);
+                return true;
+            }
+        });
+    }
+    /** Load the utility's component (once) and open it. */
+    async open(utility, from) {
+        this.openedFrom = from;
+        this.openId = utility.id;
+        if (this.components[utility.id] || !this.#runtime)
+            return;
+        const runtime = this.#runtime;
+        const resolved = await settle(() => runtime.query(APP_SHELL_UTILITY_KIND).withId(utility.id).resolve());
+        if (!resolved.ok) {
+            logger.warn('App-shell utility component could not be loaded', {
+                utilityId: utility.id,
+                reason: failureClass(resolved.error)
+            });
+            if (this.openId === utility.id)
+                this.openId = null;
+            return;
+        }
+        this.components = { ...this.components, [utility.id]: resolved.value };
+    }
+    setOpen(id, open) {
+        if (open)
+            this.openId = id;
+        else if (this.openId === id)
+            this.openId = null;
+    }
+}
+const shellUtilitiesKey = Symbol('vibes.kit.app-shell-utilities');
+/** Read the runtime from context and create this surface's utilities. */
+export function captureAppShellUtilities(viewer) {
+    const context = settleNow(() => peekRuntimeSvelteContext());
+    return new AppShellUtilities(context.ok ? context.value : undefined, viewer);
+}
+/** ProductShell publishes its utilities so an enclosed ErrorPage does not repeat them. */
+export function provideShellUtilities(utilities) {
+    setContext(shellUtilitiesKey, utilities);
+}
+export function peekShellUtilities() {
+    const context = settleNow(() => getContext(shellUtilitiesKey));
+    return context.ok ? context.value : undefined;
+}

package/dist/lib/components/app-shell/app-shell-utility.kind.d.ts

@@ -0,0 +1,46 @@
+import { type AppShellUtilityComponent, type AppShellUtilityDescriptor } from './schemas/app-shell-utility.ts';
+/**
+ * `app-shell/utility`: shell affordances contributed through the runtime.
+ *
+ * No default implementation: a descriptor alone never renders a placeholder.
+ * Owners register a browser-scoped loader resolving `{ impl: Component }`.
+ * Single-owner, so one id cannot be claimed by two packages.
+ */
+export declare const appShellUtilityKind: import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<AppShellUtilityComponent>;
+export declare const appShellUtilityHostContextDescriptor: {
+    id: string;
+    kind: "context";
+    name?: string | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+    valueKind?: "data" | "service" | undefined;
+    valueSchema?: unknown;
+    config?: {
+        sources: ("literal" | "workspace" | "floor")[];
+        subset?: true | undefined;
+    } | undefined;
+};
+declare global {
+    /** A bare `runtime.query('app-shell/utility')` is typed by the kind's own contract. */
+    interface VibesKindTypeMap {
+        'app-shell/utility': {
+            descriptor: AppShellUtilityDescriptor;
+            impl: AppShellUtilityComponent;
+        };
+    }
+}

package/dist/lib/components/app-shell/app-shell-utility.kind.js

@@ -0,0 +1,24 @@
+import { createRuntimeKind } from '@vibesdotdev/kernel';
+import { createContextDescriptor } from '@vibesdotdev/kernel/factory/context';
+import * as z from 'zod/v4';
+import { APP_SHELL_UTILITY_HOST_CONTEXT_ID, APP_SHELL_UTILITY_KIND, AppShellUtilityDescriptorSchema } from "./schemas/app-shell-utility.js";
+/** A Svelte 5 component is a function; anything else is a loader defect. */
+const AppShellUtilityComponentSchema = z.custom((value) => z.function().safeParse(value).success, 'app-shell/utility loader must resolve to a Svelte component');
+/**
+ * `app-shell/utility`: shell affordances contributed through the runtime.
+ *
+ * No default implementation: a descriptor alone never renders a placeholder.
+ * Owners register a browser-scoped loader resolving `{ impl: Component }`.
+ * Single-owner, so one id cannot be claimed by two packages.
+ */
+export const appShellUtilityKind = createRuntimeKind({
+    id: APP_SHELL_UTILITY_KIND,
+    descriptorSchema: AppShellUtilityDescriptorSchema,
+    descriptorOwnership: 'single-owner',
+    resolveValue: async (impl) => AppShellUtilityComponentSchema.parse(impl),
+    contexts: ['runtime']
+});
+export const appShellUtilityHostContextDescriptor = createContextDescriptor({
+    id: APP_SHELL_UTILITY_HOST_CONTEXT_ID,
+    description: 'Per-runtime open requests for app-shell utilities (openAppShellUtility).'
+});

package/dist/lib/components/app-shell/descriptor-navigation.d.ts

@@ -0,0 +1,31 @@
+import type { AppSidebarItem } from './schemas/app-navigation.ts';
+/**
+ * The small structural subset of an owner descriptor needed by navigation.
+ *
+ * VibesKit deliberately does not import a feature descriptor package. Hosts
+ * resolve their admitted descriptor kind through the runtime, then project it
+ * through this neutral shell boundary.
+ */
+export interface AppNavigationDescriptor {
+    id: string;
+    name: string;
+    description?: string;
+    identity?: {
+        glyph?: string;
+    };
+    tags?: readonly string[];
+}
+export interface AppNavigationPlacement {
+    descriptorId: string;
+    href: string;
+}
+export interface AppNavigationPage {
+    path: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    keywords?: string[];
+}
+export declare function appNavigationMetadata(descriptor: AppNavigationDescriptor | null | undefined, descriptorId: string): AppNavigationDescriptor | null;
+export declare function descriptorSidebarItem(placement: AppNavigationPlacement, descriptor: AppNavigationDescriptor | null | undefined, options?: Omit<AppSidebarItem, 'value' | 'label' | 'href' | 'description' | 'icon'>): AppSidebarItem | null;
+export declare function descriptorCommandPalettePage(placement: AppNavigationPlacement, descriptor: AppNavigationDescriptor | null | undefined): AppNavigationPage | null;

package/dist/lib/components/app-shell/descriptor-navigation.js

@@ -0,0 +1,36 @@
+import * as z from 'zod/v4';
+const DescriptorDisplayName = z.string().trim().min(1);
+export function appNavigationMetadata(descriptor, descriptorId) {
+    if (!descriptor ||
+        descriptor.id !== descriptorId ||
+        !DescriptorDisplayName.safeParse(descriptor.name).success) {
+        return null;
+    }
+    return descriptor;
+}
+export function descriptorSidebarItem(placement, descriptor, options = {}) {
+    const metadata = appNavigationMetadata(descriptor, placement.descriptorId);
+    if (!metadata)
+        return null;
+    return {
+        ...options,
+        value: placement.descriptorId,
+        label: metadata.name,
+        description: metadata.description,
+        href: placement.href,
+        icon: metadata.identity?.glyph
+    };
+}
+export function descriptorCommandPalettePage(placement, descriptor) {
+    const metadata = appNavigationMetadata(descriptor, placement.descriptorId);
+    if (!metadata)
+        return null;
+    return {
+        path: placement.href,
+        title: metadata.name,
+        description: metadata.description,
+        // The command-palette renderer adds the Lucide collection prefix.
+        icon: metadata.identity?.glyph?.replace(/^lucide:/, ''),
+        keywords: metadata.tags ? [...metadata.tags] : undefined
+    };
+}

package/dist/lib/components/app-shell/index.d.ts

@@ -0,0 +1,29 @@
+export { default as AppShell } from './AppShell.svelte';
+export { default as AppMenuChip } from './AppMenuChip.svelte';
+export { default as ShellAmbientCanvas } from './ShellAmbientCanvas.svelte';
+export { default as ShellStyleMenu } from './ShellStyleMenu.svelte';
+export { SHELL_STYLES, SHELL_STYLE_COOKIE_NAME, SHELL_STYLE_MAX_AGE, SHELL_STYLE_META, SHELL_STYLE_QUERY_PARAM, SHELL_STYLE_STORAGE_KEY, coerceShellStyle, persistShellStylePreference, readClientShellStyle, readShellStyleCookie, resolveShellStyle } from './shell-style';
+export type { ShellStyle } from './shell-style';
+export { resolveAppShellLocation } from './shell-location.ts';
+export type { AppShellLocation, ResolvedAppShellLocation } from './shell-location.ts';
+export { ShellStyleStore } from './shell-style-store.svelte.ts';
+export { currentShellStyleStore } from '../../preferences/preference-stores.ts';
+export { isNavItemActive, normalizeNavPath } from './nav-active';
+export { default as AppShellOmnibar } from './AppShellOmnibar.svelte';
+export type { OmnibarHit, OmnibarApp } from './AppShellOmnibar.svelte';
+export { default as AppSwitcherRail } from './AppSwitcherRail.svelte';
+export { default as ProductShell } from './ProductShell.svelte';
+export { default as ProductShellHeader } from './ProductShellHeader.svelte';
+export { default as RightSidebarPanel } from './RightSidebarPanel.svelte';
+export { default as SidebarNavigation } from './SidebarNavigation.svelte';
+export { default as UserMenu } from './UserMenu.svelte';
+export { default as WorkspaceLink } from './WorkspaceLink.svelte';
+export { default as OrgSwitcher } from './OrgSwitcher.svelte';
+export { APP_SHELL_INTERFACE_TYPES, INTERFACE_TYPE_CHANGE_EVENT, INTERFACE_TYPE_STORAGE_KEY, coerceAppShellInterfaceType, dispatchInterfaceTypeChanged, readStoredInterfaceType, writeStoredInterfaceType } from './interface-type';
+export type { AppShellInterfaceType } from './interface-type';
+export { appNavigationMetadata, descriptorCommandPalettePage, descriptorSidebarItem } from './descriptor-navigation.ts';
+export type { AppNavigationDescriptor, AppNavigationPage, AppNavigationPlacement } from './descriptor-navigation.ts';
+export { PERSONAL_ORGANIZATION_SWITCH_ID, activeOrgRequestBody, buildAccountOrganizationOverviewUrl, organizationSwitchTargetId, switchActiveOrganizationAndNavigate } from './org-switch-navigation';
+export type { OrganizationSwitchNavigationLocation, OrganizationSwitchNavigationOptions } from './org-switch-navigation';
+export type { AppShellNavigationProjection, VibesAppLink, VibesAppGroup, VibesAppBrand, VibesAppAudience, AppShellUser, AppShellViewer, AppSidebarItem, AppSidebarGroup } from './schemas/app-navigation';
+export type { VibesAppOriginMap } from './app-navigation';

package/dist/lib/components/app-shell/index.js

@@ -0,0 +1,21 @@
+export { default as AppShell } from './AppShell.svelte';
+export { default as AppMenuChip } from './AppMenuChip.svelte';
+export { default as ShellAmbientCanvas } from './ShellAmbientCanvas.svelte';
+export { default as ShellStyleMenu } from './ShellStyleMenu.svelte';
+export { SHELL_STYLES, SHELL_STYLE_COOKIE_NAME, SHELL_STYLE_MAX_AGE, SHELL_STYLE_META, SHELL_STYLE_QUERY_PARAM, SHELL_STYLE_STORAGE_KEY, coerceShellStyle, persistShellStylePreference, readClientShellStyle, readShellStyleCookie, resolveShellStyle } from './shell-style';
+export { resolveAppShellLocation } from "./shell-location.js";
+export { ShellStyleStore } from "./shell-style-store.svelte.js";
+export { currentShellStyleStore } from "../../preferences/preference-stores.js";
+export { isNavItemActive, normalizeNavPath } from './nav-active';
+export { default as AppShellOmnibar } from './AppShellOmnibar.svelte';
+export { default as AppSwitcherRail } from './AppSwitcherRail.svelte';
+export { default as ProductShell } from './ProductShell.svelte';
+export { default as ProductShellHeader } from './ProductShellHeader.svelte';
+export { default as RightSidebarPanel } from './RightSidebarPanel.svelte';
+export { default as SidebarNavigation } from './SidebarNavigation.svelte';
+export { default as UserMenu } from './UserMenu.svelte';
+export { default as WorkspaceLink } from './WorkspaceLink.svelte';
+export { default as OrgSwitcher } from './OrgSwitcher.svelte';
+export { APP_SHELL_INTERFACE_TYPES, INTERFACE_TYPE_CHANGE_EVENT, INTERFACE_TYPE_STORAGE_KEY, coerceAppShellInterfaceType, dispatchInterfaceTypeChanged, readStoredInterfaceType, writeStoredInterfaceType } from './interface-type';
+export { appNavigationMetadata, descriptorCommandPalettePage, descriptorSidebarItem } from "./descriptor-navigation.js";
+export { PERSONAL_ORGANIZATION_SWITCH_ID, activeOrgRequestBody, buildAccountOrganizationOverviewUrl, organizationSwitchTargetId, switchActiveOrganizationAndNavigate } from './org-switch-navigation';

package/dist/lib/components/app-shell/interface-type.d.ts

@@ -0,0 +1,9 @@
+import { type Settled } from '../../attempt';
+export declare const INTERFACE_TYPE_STORAGE_KEY = "vibes:user-type";
+export declare const INTERFACE_TYPE_CHANGE_EVENT = "vibes:user-type-changed";
+export declare const APP_SHELL_INTERFACE_TYPES: readonly ["simple", "creative", "power", "developer"];
+export type AppShellInterfaceType = (typeof APP_SHELL_INTERFACE_TYPES)[number];
+export declare function coerceAppShellInterfaceType(value: string | null | undefined): AppShellInterfaceType;
+export declare function readStoredInterfaceType(storage: Pick<Storage, 'getItem'> | null | undefined): AppShellInterfaceType | null;
+export declare function writeStoredInterfaceType(storage: Pick<Storage, 'setItem'> | null | undefined, value: AppShellInterfaceType): Settled<void>;
+export declare function dispatchInterfaceTypeChanged(target: Pick<Window, 'dispatchEvent'> | null | undefined, value: AppShellInterfaceType): void;

package/dist/lib/components/app-shell/interface-type.js

@@ -0,0 +1,39 @@
+import { settleNow } from '../../attempt';
+import { failureClass } from "../../failure-class.js";
+import { kitLogger } from '../../kit-logger';
+const logger = kitLogger('vibeskit-app-shell-interface-type');
+export const INTERFACE_TYPE_STORAGE_KEY = 'vibes:user-type';
+export const INTERFACE_TYPE_CHANGE_EVENT = 'vibes:user-type-changed';
+export const APP_SHELL_INTERFACE_TYPES = ['simple', 'creative', 'power', 'developer'];
+function isAppShellInterfaceType(value) {
+    return APP_SHELL_INTERFACE_TYPES.some((type) => type === value);
+}
+export function coerceAppShellInterfaceType(value) {
+    // Legacy value (pre-`'superuser' → 'power'` rename) — map forward so stale
+    // localStorage entries and old clients keep working.
+    if (value === 'superuser') {
+        return 'power';
+    }
+    if (value && isAppShellInterfaceType(value)) {
+        return value;
+    }
+    return 'simple';
+}
+export function readStoredInterfaceType(storage) {
+    // Storage that refuses the read (private mode, blocked storage) holds no preference.
+    const stored = settleNow(() => storage?.getItem(INTERFACE_TYPE_STORAGE_KEY));
+    if (!stored.ok) {
+        logger.warn('Interface type storage read refused', { reason: failureClass(stored.error) });
+        return null;
+    }
+    return stored.value ? coerceAppShellInterfaceType(stored.value) : null;
+}
+export function writeStoredInterfaceType(storage, value) {
+    // The outcome is returned, never thrown, so a refused local write cannot stop the server-side write.
+    return settleNow(() => storage?.setItem(INTERFACE_TYPE_STORAGE_KEY, value));
+}
+export function dispatchInterfaceTypeChanged(target, value) {
+    target?.dispatchEvent(new CustomEvent(INTERFACE_TYPE_CHANGE_EVENT, {
+        detail: { value }
+    }));
+}

package/dist/lib/components/app-shell/nav-active.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Active-state matching for AppSidebarItem hrefs — the ONE home for the
+ * pathname/match rules shared by SidebarNavigation rows and Canvas scope
+ * segments. `match: 'startsWith'` claims the subtree; default is exact.
+ */
+import type { AppSidebarItem } from './schemas/app-navigation';
+export declare function normalizeNavPath(target: string): string;
+export declare function isNavItemActive(item: AppSidebarItem, pathname: string): boolean;

package/dist/lib/components/app-shell/nav-active.js

@@ -0,0 +1,15 @@
+const NAV_PATH_BASE = 'https://example.com';
+export function normalizeNavPath(target) {
+    return URL.canParse(target, NAV_PATH_BASE) ? new URL(target, NAV_PATH_BASE).pathname : target;
+}
+export function isNavItemActive(item, pathname) {
+    if (item.isActive === true || item.isActive === false)
+        return item.isActive;
+    if (item.external)
+        return false;
+    const hrefPath = normalizeNavPath(item.href);
+    if (item.match === 'startsWith') {
+        return pathname === hrefPath || pathname.startsWith(`${hrefPath}/`);
+    }
+    return pathname === hrefPath;
+}

package/dist/lib/components/app-shell/org-switch-navigation.d.ts

@@ -0,0 +1,43 @@
+export declare const PERSONAL_ORGANIZATION_SWITCH_ID = "__personal__";
+export type OrganizationSwitchNavigationLocation = Pick<Location, 'assign' | 'reload'>;
+export type OrganizationSwitchNavigationOptions = {
+    organizationId: string;
+    accountOrigin: string;
+    organizationPath?: string;
+    fetcher?: typeof fetch;
+    location?: OrganizationSwitchNavigationLocation;
+    logger?: Pick<Console, 'warn'>;
+    /**
+     * When true, a successful switch to a real organization reloads the current
+     * location instead of navigating to `${accountOrigin}/organization`.
+     * The default behavior navigates to account-web. Apps whose own data is org-scoped in
+     * place (e.g. HQ) pass this so switching org keeps the user where they are.
+     */
+    stayInApp?: boolean;
+    /**
+     * Called when the switch request fails (non-ok response or network error)
+     * so the caller can surface feedback (e.g. a toast) instead of the switch
+     * failing silently. Invoked before the location is reloaded.
+     */
+    onError?: (error: {
+        status?: number;
+    }) => void;
+};
+export declare function organizationSwitchTargetId(organizationId: string): string | null;
+export declare function buildAccountOrganizationOverviewUrl(accountOrigin: string, organizationPath?: string): string;
+/**
+ * The request body `POST /api/account/active-org` accepts.
+ *
+ * The field is `orgId`. It was `organizationId` here for long enough to ship a
+ * dead org switcher in every app that mounts the shell: the endpoint answers
+ * 400 "Invalid request body", this helper takes the `!response.ok` branch, and
+ * the user sees the page reload on the org they already had. The kit unit test
+ * asserted the wrong name too, so it stayed green the whole time. Account-web
+ * owns the endpoint and now drives THIS builder against its real handler
+ * (`active-org.server.test.ts`), so the two ends fail together or not at all.
+ */
+export type ActiveOrgRequestBody = {
+    orgId: string | null;
+};
+export declare function activeOrgRequestBody(organizationId: string): ActiveOrgRequestBody;
+export declare function switchActiveOrganizationAndNavigate({ organizationId, accountOrigin, organizationPath, fetcher, location, logger, stayInApp, onError }: OrganizationSwitchNavigationOptions): Promise<void>;

package/dist/lib/components/app-shell/org-switch-navigation.js

@@ -0,0 +1,50 @@
+import { settle } from '../../attempt';
+import { failureClass } from "../../failure-class.js";
+export const PERSONAL_ORGANIZATION_SWITCH_ID = '__personal__';
+export function organizationSwitchTargetId(organizationId) {
+    return organizationId === PERSONAL_ORGANIZATION_SWITCH_ID ? null : organizationId;
+}
+function buildAccountUrl(accountOrigin, path) {
+    const origin = accountOrigin.endsWith('/') ? accountOrigin.slice(0, -1) : accountOrigin;
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${origin}${normalizedPath}`;
+}
+export function buildAccountOrganizationOverviewUrl(accountOrigin, organizationPath = '/organization') {
+    return buildAccountUrl(accountOrigin, organizationPath);
+}
+export function activeOrgRequestBody(organizationId) {
+    return { orgId: organizationSwitchTargetId(organizationId) };
+}
+export async function switchActiveOrganizationAndNavigate({ organizationId, accountOrigin, organizationPath = '/organization', fetcher = globalThis.fetch, location = globalThis.window?.location, logger = console, stayInApp = false, onError }) {
+    const target = organizationSwitchTargetId(organizationId);
+    // `switched` is false when the endpoint refused (already reported and reloaded).
+    const sent = await settle(async () => {
+        const response = await fetcher(buildAccountUrl(accountOrigin, '/api/account/active-org'), {
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(activeOrgRequestBody(organizationId))
+        });
+        if (!response.ok) {
+            logger.warn('Org switch failed', response.status);
+            onError?.({ status: response.status });
+            location?.reload();
+            return { switched: false };
+        }
+        return { switched: true };
+    });
+    if (!sent.ok) {
+        // The request never completed (network failure): the caller learns it failed, and the page reloads.
+        logger.warn('Org switch request failed', { reason: failureClass(sent.error) });
+        onError?.({});
+        location?.reload();
+        return;
+    }
+    if (!sent.value.switched)
+        return;
+    if (target && !stayInApp) {
+        location?.assign(buildAccountOrganizationOverviewUrl(accountOrigin, organizationPath));
+        return;
+    }
+    location?.reload();
+}

package/dist/lib/components/app-shell/packaged-navigation.d.ts

@@ -0,0 +1,2 @@
+/** Packaged SvelteKit routes are separate HTML documents, not client routes. */
+export declare function requiresDocumentNavigation(href: string): boolean;

package/dist/lib/components/app-shell/packaged-navigation.js

@@ -0,0 +1,4 @@
+/** Packaged SvelteKit routes are separate HTML documents, not client routes. */
+export function requiresDocumentNavigation(href) {
+    return /(?:^|\/)[^/?#]+\.html(?:[?#]|$)/.test(href);
+}

package/dist/lib/components/app-shell/product-shell-scroll.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ProductShell scroll ownership contract.
+ *
+ * The shell freezes the viewport (`SidebarProvider`: h-svh + overflow-hidden).
+ * Page scroll lives on `#main-content` only; never on `SidebarInset`.
+ *
+ * Nested `overflow-y-auto` on both inset and main is a known mobile trap:
+ * touch/wheel is claimed by the outer main (no overflow) while the inner
+ * `#main-content` has scrollHeight > clientHeight and scrollTop stuck at 0.
+ *
+ * Apps that need inner panes to own scroll (chat rooms) pass a marker class
+ * on the content wrapper and zero main overflow themselves; see chat-web
+ * `chat-shell-scroll-lock`.
+ */
+/** Stretch inside the shell's inset margins without becoming a second scrollport. */
+export declare const PRODUCT_SHELL_INSET_CLASS = "flex min-h-0 flex-col overflow-hidden";
+/** Classes for `#main-content`: sole page scrollport. */
+export declare const PRODUCT_SHELL_MAIN_CLASS = "min-h-0 flex-1 overflow-y-auto";
+/** Resolve the one shell scroll contract explicitly for page or pane surfaces. */
+export declare function productShellMainClass(contentScroll?: 'page' | 'pane'): string;

package/dist/lib/components/app-shell/product-shell-scroll.js

@@ -0,0 +1,22 @@
+/**
+ * ProductShell scroll ownership contract.
+ *
+ * The shell freezes the viewport (`SidebarProvider`: h-svh + overflow-hidden).
+ * Page scroll lives on `#main-content` only; never on `SidebarInset`.
+ *
+ * Nested `overflow-y-auto` on both inset and main is a known mobile trap:
+ * touch/wheel is claimed by the outer main (no overflow) while the inner
+ * `#main-content` has scrollHeight > clientHeight and scrollTop stuck at 0.
+ *
+ * Apps that need inner panes to own scroll (chat rooms) pass a marker class
+ * on the content wrapper and zero main overflow themselves; see chat-web
+ * `chat-shell-scroll-lock`.
+ */
+/** Stretch inside the shell's inset margins without becoming a second scrollport. */
+export const PRODUCT_SHELL_INSET_CLASS = 'flex min-h-0 flex-col overflow-hidden';
+/** Classes for `#main-content`: sole page scrollport. */
+export const PRODUCT_SHELL_MAIN_CLASS = 'min-h-0 flex-1 overflow-y-auto';
+/** Resolve the one shell scroll contract explicitly for page or pane surfaces. */
+export function productShellMainClass(contentScroll = 'page') {
+    return contentScroll === 'pane' ? 'min-h-0 flex-1 overflow-y-hidden' : PRODUCT_SHELL_MAIN_CLASS;
+}