waybetter 0.1.0 → 0.6.0

package/dist/shell/frame/site.d.ts

@@ -0,0 +1,206 @@
+import type { ComponentType } from 'react';
+import type { AddressModel } from '../addressModel.ts';
+import type { ColumnSource, DeckColumn } from '../deckModel.ts';
+import type { AccountRules } from '../profileModel.ts';
+import type { IconName } from './icons.tsx';
+import type { ShellMenu } from './menuModel.ts';
+import type { PaletteItem } from './paletteModel.ts';
+import type { ThemeStore } from './themeStore.ts';
+/** An inline completion for a text field (the address bar, a column's value). */
+export type Suggestion = {
+    label: string;
+    insert: string;
+    hint: string;
+};
+/** Completions for what is being typed and how accepting one rewrites the text. */
+export type Completer = {
+    /** Up to `max` completions for the token at `caret`. */
+    suggest(text: string, caret: number, max: number): Suggestion[];
+    apply(text: string, caret: number, insert: string): {
+        text: string;
+        caret: number;
+    };
+    /** Accessible name of the chips ("X search operators"). */
+    label(): string;
+};
+/** One kind of deck column (Home, Notifications, a search, a profile, ...). */
+export type ColumnKind = {
+    kind: string;
+    label: string;
+    icon: IconName;
+    hint: string;
+    /** What the value field asks for (none = no value). */
+    value?: {
+        label: string;
+        placeholder: string;
+    };
+};
+/** A deck column flag the page applies (a site tweak), with its label for settings. */
+export type ColumnFlag = {
+    key: string;
+    label: string;
+    hint: string;
+};
+/** A ready-made set of columns ("Monitor", "Two accounts"). */
+export type DeckPreset = {
+    id: string;
+    label(): string;
+    /** The new deck's name and the preset's row in settings (default: `label`). */
+    name?(): string;
+    /** What the preset's columns are, for settings. */
+    hint?(): string;
+    /** Disabled (with this hint) when only one account exists. */
+    needsTwoAccounts?: () => string;
+    columns(profiles: readonly string[]): Array<Pick<DeckColumn, 'profile' | 'source'>>;
+};
+export type DeckSite = {
+    kinds: readonly ColumnKind[];
+    /** The page a column loads, or null when its value is not valid for its kind. */
+    urlFor(source: ColumnSource): string | null;
+    /** Header title and subtitle for a column. */
+    title(source: ColumnSource, custom?: string): {
+        title: string;
+        detail?: string;
+    };
+    /** The typed value → the stored value, or null when it is not valid for that kind. */
+    parseValue(kind: string, input: string): string | null;
+    /** Why a typed value is not valid for `kind` (shown under the field). */
+    invalid(kind: string): string;
+    /** Completions in a kind's value field (e.g. search operators for a search column). */
+    completer?(kind: string): Completer | null;
+    /** Flags a column may override (listed in settings), and flags the page accepts that are not listed. */
+    flags: readonly ColumnFlag[];
+    extraFlags?: readonly string[];
+    /** Flags every column starts with. */
+    defaultFlags: Record<string, boolean>;
+    /** Flags a column's kind always sets (e.g. X's Following column selects X's own Following tab). */
+    kindFlags?(source: ColumnSource): Record<string, boolean>;
+    presets?: readonly DeckPreset[];
+    /** A page docked at the right of a deck to write in (X: its composer). */
+    compose?: {
+        url: string;
+        width: number;
+        /** The docked page's chrome and placeholder (it registers its placeholder with the frame). */
+        Dock: ComponentType<{
+            deckId: string;
+            left: number;
+        }>;
+        /** The dock's webview reported a page (e.g. load a fresh composer once one was sent). */
+        navigated?(tabId: string, url: string | undefined, loading: boolean | undefined): void;
+    };
+    /** A page title without the site's suffix (" / X"). */
+    pageTitle?(title: string): string;
+};
+export type PaletteSite = {
+    /** The field's placeholder. */
+    placeholder(): string;
+    /** The literal search for the query (listed first; kept as the last resort when ranking). */
+    search?(text: string): PaletteItem | null;
+    /** Completions ranked above everything else while typing (they rewrite the query). */
+    completions?(text: string): PaletteItem[];
+    /** Sections of the app's panel ("Themes", "Plugins", ...). */
+    sections: ReadonlyArray<{
+        id: string;
+        label(): string;
+        keywords: string;
+        icon: IconName;
+    }>;
+    /** The site's own pages and actions (after the tabs, decks and the app's items). */
+    items?(): PaletteItem[];
+    /** Heading for a site group (`PaletteItem.group`); the frame names its own groups. */
+    groupLabel?(group: string): string | undefined;
+};
+export type ShellSite = {
+    /** The site's name in messages ("X"). */
+    name: string;
+    /** The app's name ("wayBetter for X"): the update chip, the brand button, the palette's group. */
+    product: string;
+    /** Match native `AppConfig::defer_window_show`: reveal after the first layout reaches native. */
+    deferWindowShow?: boolean;
+    /** The app's logo (an image URL): titlebar, the panel tab, the new-tab page, the site chip. */
+    logo: string;
+    /** The site's home feed: the first tab, and what an account opens beside. */
+    homeUrl: string;
+    /** The site's own sign-in and sign-out pages (accounts are signed in and out on the site). */
+    loginUrl: string;
+    logoutUrl: string;
+    /** A page of the site itself (https, the site's hosts). */
+    isSiteUrl(url: string): boolean;
+    /** Account handle and avatar rules (as the native `AccountRules`). */
+    accounts: AccountRules;
+    /** Text typed in the address bar or the new-tab page that is not an address: the site's search. */
+    searchUrl(text: string): string;
+    /** Address bar chips for a URL (null: show the raw address). */
+    address(url: string): AddressModel | null;
+    /** Completions while the address is edited. */
+    addressCompleter?: Completer;
+    /** The app's own tab: its settings panel, opened at a section (`openPanelSection`). */
+    panel: {
+        /** Tab id (kept in saved layouts and workspaces). */
+        id: string;
+        title: string;
+        component: ComponentType<{
+            section?: {
+                name: string;
+                nonce: number;
+            };
+        }>;
+    };
+    newTab: {
+        /** The search field's placeholder. */
+        search(): string;
+        /** Quick links (their `url` gets the `homeUrl` setting). */
+        links: ReadonlyArray<{
+            id: string;
+            label(): string;
+            icon: IconName;
+            url(homeUrl: string): string;
+        }>;
+    };
+    palette: PaletteSite;
+    /** Decks of site columns (Power User Mode); omit for none. */
+    deck?: DeckSite;
+    /** Gallery and clipboard panel: which tabs have a composer to attach to; omit for none. */
+    media?: {
+        canAttach(url: string): boolean;
+    };
+    /** The app's theme store (createThemeStore): chrome and pane themes; omit to keep the frame's own style. */
+    themes?: ThemeStore<any, any>;
+    /**
+     * Native features the app serves (waybetter-host modules it wires up): workspaces (`workspaces_*`),
+     * encrypted folder sync (`sync_*`), developer mode (`dev_*`), plugin palette commands
+     * (`tab_run_command`), page zoom, find in page and safe mode (`tab_zoom`, `tab_find`, `safe_mode_*`: the host's own); and what its panel has that the
+     * app menu links to: the Store (`PanelSite.store`) and the updater (`PanelSite.updates`). Each is
+     * on unless set to false; off, the frame shows nothing of it.
+     */
+    features?: {
+        workspaces?: boolean;
+        sync?: boolean;
+        developer?: boolean;
+        pluginCommands?: boolean;
+        zoom?: boolean;
+        find?: boolean;
+        safeMode?: boolean;
+        store?: boolean;
+        updates?: boolean;
+        /** The panel has the Languages section for string packs (`createStringPacksSection`, id `languages`): only when true. */
+        strings?: boolean;
+    };
+    /**
+     * The app menu (the titlebar's "Settings and more", Alt+F / F10): its rows in order (built-in
+     * ones by name, the app's own as objects) and what the Language and Mode submenus need. Omit for
+     * the default menu: every built-in row this app can serve (menuModel.ts `DEFAULT_MENU`).
+     */
+    menu?: ShellMenu;
+    /** Components rendered on top of the shell (they listen to their own events). */
+    overlays?: ReadonlyArray<ComponentType>;
+    /** Called once the dock exists (read site settings, listen to site events). Returns a cleanup. */
+    start?(): (() => void) | undefined;
+};
+/** Sets the site (createShell). */
+export declare function configureSite(value: ShellSite): void;
+export declare function site(): ShellSite;
+/** Whether the app serves a native feature (`site.features`, on by default). */
+export declare const hasFeature: (name: keyof NonNullable<ShellSite["features"]>) => boolean;
+/** The site's runtime text changed (X: the Twitter/X wording): address bars and new-tab pages re-render. */
+export declare function siteChanged(): void;

package/dist/shell/frame/site.js

@@ -0,0 +1,22 @@
+// What a wayBetter app tells the shell frame about its site: names, pages, the address bar chips,
+// the new-tab page, the palette's site items, deck column kinds, the app's own panel and the
+// overlays it adds. `createShell(site)` sets it; every frame module reads it through `site()`.
+// Everything here is data or small functions; the frame owns the behavior (tabs, splits, the
+// titlebar, overlays, layout sync, workspaces, sync, developer mode).
+let current = null;
+/** Sets the site (createShell). */
+export function configureSite(value) {
+    current = value;
+}
+export function site() {
+    if (!current)
+        throw new Error('wayBetter shell: createShell(site) first');
+    return current;
+}
+/** Whether the app serves a native feature (`site.features`, on by default). */
+export const hasFeature = (name) => site().features?.[name] !== false;
+/** The site's runtime text changed (X: the Twitter/X wording): address bars and new-tab pages re-render. */
+export function siteChanged() {
+    window.dispatchEvent(new CustomEvent('bt-site'));
+}
+//# sourceMappingURL=site.js.map

package/dist/shell/frame/site.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"site.js","sourceRoot":"","sources":["../../../../../../shell/src/frame/site.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,6FAA6F;AAC7F,+FAA+F;AAC/F,6FAA6F;AAC7F,sEAAsE;AAoKtE,IAAI,OAAO,GAAqB,IAAI,CAAC;AAErC,mCAAmC;AACnC,MAAM,UAAU,aAAa,CAAC,KAAgB;IAC5C,OAAO,GAAG,KAAK,CAAC;AAClB,CAAC;AAED,MAAM,UAAU,IAAI;IAClB,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAC1E,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,gFAAgF;AAChF,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,IAA8C,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC;AAEhH,4GAA4G;AAC5G,MAAM,UAAU,WAAW;IACzB,MAAM,CAAC,aAAa,CAAC,IAAI,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC;AACnD,CAAC","sourcesContent":["// What a wayBetter app tells the shell frame about its site: names, pages, the address bar chips,\n// the new-tab page, the palette's site items, deck column kinds, the app's own panel and the\n// overlays it adds. `createShell(site)` sets it; every frame module reads it through `site()`.\n// Everything here is data or small functions; the frame owns the behavior (tabs, splits, the\n// titlebar, overlays, layout sync, workspaces, sync, developer mode).\n\nimport type { ComponentType } from 'react';\nimport type { AddressModel } from '../addressModel.ts';\nimport type { ColumnSource, DeckColumn } from '../deckModel.ts';\nimport type { AccountRules } from '../profileModel.ts';\nimport type { IconName } from './icons.tsx';\nimport type { ShellMenu } from './menuModel.ts';\nimport type { PaletteItem } from './paletteModel.ts';\nimport type { ThemeStore } from './themeStore.ts';\n\n/** An inline completion for a text field (the address bar, a column's value). */\nexport type Suggestion = { label: string; insert: string; hint: string };\n\n/** Completions for what is being typed and how accepting one rewrites the text. */\nexport type Completer = {\n  /** Up to `max` completions for the token at `caret`. */\n  suggest(text: string, caret: number, max: number): Suggestion[];\n  apply(text: string, caret: number, insert: string): { text: string; caret: number };\n  /** Accessible name of the chips (\"X search operators\"). */\n  label(): string;\n};\n\n/** One kind of deck column (Home, Notifications, a search, a profile, ...). */\nexport type ColumnKind = {\n  kind: string;\n  label: string;\n  icon: IconName;\n  hint: string;\n  /** What the value field asks for (none = no value). */\n  value?: { label: string; placeholder: string };\n};\n\n/** A deck column flag the page applies (a site tweak), with its label for settings. */\nexport type ColumnFlag = { key: string; label: string; hint: string };\n\n/** A ready-made set of columns (\"Monitor\", \"Two accounts\"). */\nexport type DeckPreset = {\n  id: string;\n  label(): string;\n  /** The new deck's name and the preset's row in settings (default: `label`). */\n  name?(): string;\n  /** What the preset's columns are, for settings. */\n  hint?(): string;\n  /** Disabled (with this hint) when only one account exists. */\n  needsTwoAccounts?: () => string;\n  columns(profiles: readonly string[]): Array<Pick<DeckColumn, 'profile' | 'source'>>;\n};\n\nexport type DeckSite = {\n  kinds: readonly ColumnKind[];\n  /** The page a column loads, or null when its value is not valid for its kind. */\n  urlFor(source: ColumnSource): string | null;\n  /** Header title and subtitle for a column. */\n  title(source: ColumnSource, custom?: string): { title: string; detail?: string };\n  /** The typed value → the stored value, or null when it is not valid for that kind. */\n  parseValue(kind: string, input: string): string | null;\n  /** Why a typed value is not valid for `kind` (shown under the field). */\n  invalid(kind: string): string;\n  /** Completions in a kind's value field (e.g. search operators for a search column). */\n  completer?(kind: string): Completer | null;\n  /** Flags a column may override (listed in settings), and flags the page accepts that are not listed. */\n  flags: readonly ColumnFlag[];\n  extraFlags?: readonly string[];\n  /** Flags every column starts with. */\n  defaultFlags: Record<string, boolean>;\n  /** Flags a column's kind always sets (e.g. X's Following column selects X's own Following tab). */\n  kindFlags?(source: ColumnSource): Record<string, boolean>;\n  presets?: readonly DeckPreset[];\n  /** A page docked at the right of a deck to write in (X: its composer). */\n  compose?: {\n    url: string;\n    width: number;\n    /** The docked page's chrome and placeholder (it registers its placeholder with the frame). */\n    Dock: ComponentType<{ deckId: string; left: number }>;\n    /** The dock's webview reported a page (e.g. load a fresh composer once one was sent). */\n    navigated?(tabId: string, url: string | undefined, loading: boolean | undefined): void;\n  };\n  /** A page title without the site's suffix (\" / X\"). */\n  pageTitle?(title: string): string;\n};\n\nexport type PaletteSite = {\n  /** The field's placeholder. */\n  placeholder(): string;\n  /** The literal search for the query (listed first; kept as the last resort when ranking). */\n  search?(text: string): PaletteItem | null;\n  /** Completions ranked above everything else while typing (they rewrite the query). */\n  completions?(text: string): PaletteItem[];\n  /** Sections of the app's panel (\"Themes\", \"Plugins\", ...). */\n  sections: ReadonlyArray<{ id: string; label(): string; keywords: string; icon: IconName }>;\n  /** The site's own pages and actions (after the tabs, decks and the app's items). */\n  items?(): PaletteItem[];\n  /** Heading for a site group (`PaletteItem.group`); the frame names its own groups. */\n  groupLabel?(group: string): string | undefined;\n};\n\nexport type ShellSite = {\n  /** The site's name in messages (\"X\"). */\n  name: string;\n  /** The app's name (\"wayBetter for X\"): the update chip, the brand button, the palette's group. */\n  product: string;\n  /** Match native `AppConfig::defer_window_show`: reveal after the first layout reaches native. */\n  deferWindowShow?: boolean;\n  /** The app's logo (an image URL): titlebar, the panel tab, the new-tab page, the site chip. */\n  logo: string;\n  /** The site's home feed: the first tab, and what an account opens beside. */\n  homeUrl: string;\n  /** The site's own sign-in and sign-out pages (accounts are signed in and out on the site). */\n  loginUrl: string;\n  logoutUrl: string;\n  /** A page of the site itself (https, the site's hosts). */\n  isSiteUrl(url: string): boolean;\n  /** Account handle and avatar rules (as the native `AccountRules`). */\n  accounts: AccountRules;\n  /** Text typed in the address bar or the new-tab page that is not an address: the site's search. */\n  searchUrl(text: string): string;\n  /** Address bar chips for a URL (null: show the raw address). */\n  address(url: string): AddressModel | null;\n  /** Completions while the address is edited. */\n  addressCompleter?: Completer;\n  /** The app's own tab: its settings panel, opened at a section (`openPanelSection`). */\n  panel: {\n    /** Tab id (kept in saved layouts and workspaces). */\n    id: string;\n    title: string;\n    component: ComponentType<{ section?: { name: string; nonce: number } }>;\n  };\n  newTab: {\n    /** The search field's placeholder. */\n    search(): string;\n    /** Quick links (their `url` gets the `homeUrl` setting). */\n    links: ReadonlyArray<{ id: string; label(): string; icon: IconName; url(homeUrl: string): string }>;\n  };\n  palette: PaletteSite;\n  /** Decks of site columns (Power User Mode); omit for none. */\n  deck?: DeckSite;\n  /** Gallery and clipboard panel: which tabs have a composer to attach to; omit for none. */\n  media?: { canAttach(url: string): boolean };\n  /** The app's theme store (createThemeStore): chrome and pane themes; omit to keep the frame's own style. */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  themes?: ThemeStore<any, any>;\n  /**\n   * Native features the app serves (waybetter-host modules it wires up): workspaces (`workspaces_*`),\n   * encrypted folder sync (`sync_*`), developer mode (`dev_*`), plugin palette commands\n   * (`tab_run_command`), page zoom, find in page and safe mode (`tab_zoom`, `tab_find`, `safe_mode_*`: the host's own); and what its panel has that the\n   * app menu links to: the Store (`PanelSite.store`) and the updater (`PanelSite.updates`). Each is\n   * on unless set to false; off, the frame shows nothing of it.\n   */\n  features?: { workspaces?: boolean; sync?: boolean; developer?: boolean; pluginCommands?: boolean; zoom?: boolean; find?: boolean; safeMode?: boolean; store?: boolean; updates?: boolean;\n    /** The panel has the Languages section for string packs (`createStringPacksSection`, id `languages`): only when true. */\n    strings?: boolean };\n  /**\n   * The app menu (the titlebar's \"Settings and more\", Alt+F / F10): its rows in order (built-in\n   * ones by name, the app's own as objects) and what the Language and Mode submenus need. Omit for\n   * the default menu: every built-in row this app can serve (menuModel.ts `DEFAULT_MENU`).\n   */\n  menu?: ShellMenu;\n  /** Components rendered on top of the shell (they listen to their own events). */\n  overlays?: ReadonlyArray<ComponentType>;\n  /** Called once the dock exists (read site settings, listen to site events). Returns a cleanup. */\n  start?(): (() => void) | undefined;\n};\n\nlet current: ShellSite | null = null;\n\n/** Sets the site (createShell). */\nexport function configureSite(value: ShellSite) {\n  current = value;\n}\n\nexport function site(): ShellSite {\n  if (!current) throw new Error('wayBetter shell: createShell(site) first');\n  return current;\n}\n\n/** Whether the app serves a native feature (`site.features`, on by default). */\nexport const hasFeature = (name: keyof NonNullable<ShellSite['features']>) => site().features?.[name] !== false;\n\n/** The site's runtime text changed (X: the Twitter/X wording): address bars and new-tab pages re-render. */\nexport function siteChanged() {\n  window.dispatchEvent(new CustomEvent('bt-site'));\n}\n"]}

package/dist/shell/frame/state.d.ts

@@ -0,0 +1,99 @@
+import type { DockviewApi, IDockviewPanel } from 'dockview';
+import { type ProfileSettings } from '../profileModel.ts';
+import type { PaneInfo } from './accountModel.ts';
+import type { PaletteAction } from './paletteModel.ts';
+/** `profile`: the account profile (WebView data directory) the tab runs in; missing = default. */
+/** `besideOf`: the group whose "beside" link opened this tab; its group is that group's side pane. */
+export type WebParams = {
+    kind: 'web';
+    url: string;
+    profile?: string;
+    title?: string;
+    favicon?: string;
+    loading?: boolean;
+    pinned?: boolean;
+    besideOf?: string;
+};
+/** The app's own tab (its settings panel, `site.panel`). */
+export type PanelParams = {
+    kind: 'panel';
+    section?: string;
+    nonce?: number;
+    pinned?: boolean;
+};
+/** The new-tab page: drawn by the shell itself (no webview); `profile` is the account it opens links in. */
+export type StartParams = {
+    kind: 'start';
+    profile?: string;
+    pinned?: boolean;
+};
+/** A deck of site columns (DeckView.tsx); its columns are tab webviews of their own. */
+export type DeckParams = {
+    kind: 'deck';
+    deckId: string;
+    pinned?: boolean;
+};
+export type TabParams = WebParams | PanelParams | StartParams | DeckParams;
+/** Shared, non-React shell state: pane placeholders and the native webview reconciliation. */
+export declare const shell: {
+    api: DockviewApi | null;
+    placeholders: Map<string, HTMLElement>;
+    /**
+     * Open shell overlays (menus, dialogs, palette, drag zones). While > 0 the shell webview is raised
+     * above the tab webviews (panes stay visible under it), or, where it cannot be, they are hidden.
+     */
+    overlay: number;
+    /** Recently closed web tabs, newest last (Ctrl+Shift+T, new-tab page). */
+    closed: Array<{
+        url: string;
+        profile?: string;
+        title?: string;
+    }>;
+    profiles: ProfileSettings;
+    restoring: boolean;
+    /** Toolbar actions implemented by Shell.tsx (split view, the app's panel). */
+    split: (_id: string, _direction: "right" | "below") => void;
+    openPanel: (_from?: string) => void;
+    /** Opens the new-tab page in the given profile. */
+    newTab: (_profile: string) => void;
+    /** The `homeUrl` setting (new-tab page "Home" link, first tab); `site.homeUrl` until read. */
+    homeUrl: string;
+    /** Opens `url` from the new-tab page: replaces that page (`startId`) or, without one, adds a tab. */
+    openFromStart: (_url: string, _profile: string, _startId?: string) => void;
+    /** Account switcher click: focus a visible pane of that account or open its feed beside (Shell.tsx). */
+    openAccount: (_profile: string, _options?: {
+        force?: boolean;
+        url?: string;
+    }) => void;
+    /** Opens `url` as a web tab in `profile` (a deck column's "Open as tab"). */
+    openUrl: (_url: string, _profile: string) => void;
+    /** Opens the app's panel at a section (e.g. the deck's settings button). */
+    openPanelSection: (_section: string) => void;
+    /** Runs a shell shortcut by name as if its keys were pressed (`new-tab`, `split-right`, `command-palette`, ...). */
+    shortcut: (_name: string) => void;
+    /** Runs a palette action (navigation only: open a deck, add a column, restore a workspace, ...). */
+    run: (_action: PaletteAction) => void;
+};
+/** The app's panel tab id (`site.panel.id`, kept in saved layouts). */
+export declare const panelId: () => string;
+/** Replaces the profile list (after a native save) and tells mounted switchers and tabs. */
+export declare function setProfiles(value: unknown): void;
+export declare const newTabId: () => string;
+export declare const isWeb: (panel: IDockviewPanel) => boolean;
+/** Every tab as the account switcher sees it. */
+export declare function paneInfos(): PaneInfo[];
+/** Merge params without ever passing `undefined` (dockview deletes keys set to undefined). */
+export declare function patchParams(panel: IDockviewPanel, patch: Partial<WebParams>): void;
+export declare function scheduleSync(): void;
+/** Sends the layout again even though nothing moved: native code asked to build every tab webview anew (`tabs-rebuild`). */
+export declare function resync(): void;
+/** Sends the tab rectangles now (e.g. so native code knows closed tabs are gone before a profile removal). */
+export declare function flushSync(): Promise<void>;
+export declare function setOverlay(delta: number): void;
+/** The startup probe (createShell): whether this platform can raise the shell above its tabs. */
+export declare function probeLayer(): void;
+/** Wait until the startup cover has either raised the shell or hidden the native tabs. */
+export declare function flushLayer(): Promise<void>;
+export declare function saveLayoutSoon(): void;
+export declare function loadLayout(): unknown;
+export declare const tabAction: (id: string, action: "back" | "forward" | "reload" | "stop" | "focus") => Promise<unknown>;

package/dist/shell/frame/state.js

@@ -0,0 +1,284 @@
+// Shared, non-React shell state: the dock, pane placeholders and the native webview reconciliation
+// (`tabs_sync`, one layout in flight at a time), shell overlays (the shell webview is raised above
+// the tab webviews while a menu, dialog or drag is open), profiles and session layout persistence.
+import { cssRgb, paneVisibility, raiseSupported, withNavRedundant } from "../paneModel.js";
+import { defaultProfiles, normalizeProfiles, tabProfile } from "../profileModel.js";
+import { currentWindow, invoke } from "./bridge.js";
+import { columnSourceUrl, composeTabId, deckById, decks } from "./deckStore.js";
+import { diag } from "./diag.js";
+import { site } from "./site.js";
+import { latestOnly } from "./syncGate.js";
+const LAYOUT_KEY = 'bt.shell.layout.v1';
+/** Shared, non-React shell state: pane placeholders and the native webview reconciliation. */
+export const shell = {
+    api: null,
+    placeholders: new Map(),
+    /**
+     * Open shell overlays (menus, dialogs, palette, drag zones). While > 0 the shell webview is raised
+     * above the tab webviews (panes stay visible under it), or, where it cannot be, they are hidden.
+     */
+    overlay: 0,
+    /** Recently closed web tabs, newest last (Ctrl+Shift+T, new-tab page). */
+    closed: [],
+    profiles: defaultProfiles(),
+    restoring: false,
+    /** Toolbar actions implemented by Shell.tsx (split view, the app's panel). */
+    split: (_id, _direction) => { },
+    openPanel: (_from) => { },
+    /** Opens the new-tab page in the given profile. */
+    newTab: (_profile) => { },
+    /** The `homeUrl` setting (new-tab page "Home" link, first tab); `site.homeUrl` until read. */
+    homeUrl: '',
+    /** Opens `url` from the new-tab page: replaces that page (`startId`) or, without one, adds a tab. */
+    openFromStart: (_url, _profile, _startId) => { },
+    /** Account switcher click: focus a visible pane of that account or open its feed beside (Shell.tsx). */
+    openAccount: (_profile, _options) => { },
+    /** Opens `url` as a web tab in `profile` (a deck column's "Open as tab"). */
+    openUrl: (_url, _profile) => { },
+    /** Opens the app's panel at a section (e.g. the deck's settings button). */
+    openPanelSection: (_section) => { },
+    /** Runs a shell shortcut by name as if its keys were pressed (`new-tab`, `split-right`, `command-palette`, ...). */
+    shortcut: (_name) => { },
+    /** Runs a palette action (navigation only: open a deck, add a column, restore a workspace, ...). */
+    run: (_action) => { },
+};
+/** The app's panel tab id (`site.panel.id`, kept in saved layouts). */
+export const panelId = () => site().panel.id;
+/** Replaces the profile list (after a native save) and tells mounted switchers and tabs. */
+export function setProfiles(value) {
+    shell.profiles = normalizeProfiles(value, site().accounts);
+    window.dispatchEvent(new CustomEvent('bt-profiles'));
+    scheduleSync();
+}
+export const newTabId = () => `t${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+export const isWeb = (panel) => panel.params?.kind === 'web';
+/** Every tab as the account switcher sees it. */
+export function paneInfos() {
+    return (shell.api?.panels ?? []).map(panel => {
+        const params = panel.params;
+        return {
+            id: panel.id,
+            kind: !params || params.kind === 'deck' ? 'panel' : params.kind,
+            profile: params && params.kind !== 'panel' && params.kind !== 'deck' ? params.profile : undefined,
+            url: params?.kind === 'web' ? params.url : undefined,
+            visible: panel.api.isVisible,
+        };
+    });
+}
+/** Merge params without ever passing `undefined` (dockview deletes keys set to undefined). */
+export function patchParams(panel, patch) {
+    const clean = Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
+    if (Object.keys(clean).length)
+        panel.api.updateParameters(clean);
+}
+let frame = 0;
+let lastPayload = '';
+/** Last `navRedundant` per tab; a hidden tab keeps its value so it shows up without a flicker. */
+const navRedundant = new Map();
+export function scheduleSync() {
+    if (frame)
+        return;
+    frame = requestAnimationFrame(() => { frame = 0; void syncTabs(); });
+}
+/** Sends the layout again even though nothing moved: native code asked to build every tab webview anew (`tabs-rebuild`). */
+export function resync() {
+    lastPayload = '';
+    scheduleSync();
+}
+/** Sends the tab rectangles now (e.g. so native code knows closed tabs are gone before a profile removal). */
+export function flushSync() {
+    if (frame) {
+        cancelAnimationFrame(frame);
+        frame = 0;
+    }
+    return syncTabs();
+}
+function syncTabs() {
+    const api = shell.api;
+    if (!api)
+        return Promise.resolve();
+    const boxes = api.panels.filter(isWeb).map(panel => {
+        const params = panel.params;
+        const el = shell.placeholders.get(panel.id);
+        const rect = el?.isConnected ? el.getBoundingClientRect() : null;
+        const shown = !!rect && rect.width > 1 && rect.height > 1 && panel.api.isVisible;
+        const { visible, parked } = paneVisibility({ shown, overlay: shell.overlay, raiseSupported: layer.supported });
+        return {
+            id: panel.id,
+            url: params.url,
+            profile: tabProfile(shell.profiles, params.profile).id,
+            x: Math.round(rect?.left ?? 0),
+            y: Math.round(rect?.top ?? 0),
+            width: Math.round(rect?.width ?? 1),
+            height: Math.round(rect?.height ?? 1),
+            visible,
+            // Not shown for a reason other than a shell overlay: only these drop to low memory.
+            parked,
+        };
+    });
+    // Only visible panes are judged (a shell overlay hides them all and so changes nothing).
+    const items = withNavRedundant([...boxes, ...columnBoxes()], site().isSiteUrl, navRedundant);
+    const payload = JSON.stringify(items);
+    if (payload === lastPayload)
+        return Promise.resolve();
+    lastPayload = payload;
+    saveLayoutSoon();
+    // `viewport`: the window size this layout is for; native code re-bases it if the window was
+    // resized while it was in flight (it also follows resizes itself, before the shell re-lays out).
+    return sendLayout({ items, viewport: [window.innerWidth, window.innerHeight] });
+}
+/** One tabs_sync in flight at a time; during a drag only the newest layout waits (syncGate.ts). */
+const sendLayout = latestOnly(args => invoke('tabs_sync', args).then(() => { }, error => console.error('[shell] tabs_sync', error)));
+/**
+ * Deck columns (and each deck's compose dock) of every open deck tab. A column on another page of
+ * its deck has no placeholder: hidden, and parked (low memory) when the setting says so; a deck
+ * tab in the background parks all of its columns.
+ */
+function columnBoxes() {
+    const api = shell.api;
+    const composeUrl = site().deck?.compose?.url;
+    if (!api)
+        return [];
+    const boxes = [];
+    for (const panel of api.panels) {
+        const params = panel.params;
+        if (params?.kind !== 'deck')
+            continue;
+        const deck = deckById(params.deckId);
+        if (!deck)
+            continue;
+        const deckShown = panel.api.isVisible;
+        const entries = deck.columns.map(column => ({ id: column.tabId, profile: column.profile, url: columnSourceUrl(column.source) }));
+        const compose = decks.compose.get(deck.id);
+        if (compose && composeUrl)
+            entries.push({ id: composeTabId(deck.id), profile: compose.profile, url: composeUrl });
+        for (const entry of entries) {
+            if (!entry.url || !decks.ready.has(entry.id))
+                continue;
+            const el = shell.placeholders.get(entry.id);
+            const rect = el?.isConnected ? el.getBoundingClientRect() : null;
+            const shown = !!rect && rect.width > 1 && rect.height > 1 && deckShown;
+            boxes.push({
+                id: entry.id,
+                url: entry.url,
+                profile: tabProfile(shell.profiles, entry.profile).id,
+                x: Math.round(rect?.left ?? 0),
+                y: Math.round(rect?.top ?? 0),
+                width: Math.round(rect?.width ?? 1),
+                height: Math.round(rect?.height ?? 1),
+                visible: paneVisibility({ shown, overlay: shell.overlay, raiseSupported: layer.supported }).visible,
+                parked: !shown && (decks.settings.parkOffPage || !deckShown),
+                role: 'column',
+            });
+        }
+    }
+    return boxes;
+}
+export function setOverlay(delta) {
+    const before = shell.overlay;
+    shell.overlay = Math.max(0, before + delta);
+    diag(`overlay ${before} -> ${shell.overlay}`);
+    if ((before === 0) !== (shell.overlay === 0)) {
+        window.dispatchEvent(new Event('bt-overlay-changed'));
+        syncLayer();
+    }
+    scheduleSync();
+}
+/**
+ * The shell webview's place relative to the tab webviews. `supported`: `shell_raise` works here
+ * (Windows, Linux, macOS; probed once at startup, which also lowers a shell left raised by a reload). While raised,
+ * `html.bt-raised` makes the page see-through where panes are (shell.css).
+ */
+const layer = { supported: false, raised: false, queue: Promise.resolve(), probed: false };
+let layerProbe = Promise.resolve();
+const frames = () => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(() => resolve())));
+/** The startup probe (createShell): whether this platform can raise the shell above its tabs. */
+export function probeLayer() {
+    if (layer.probed)
+        return;
+    layer.probed = true;
+    // `localStorage['bt.dev.noRaise'] = '1'` (then reload): overlays hide the tabs as where raising
+    // is not supported, for before/after comparisons.
+    const off = (() => { try {
+        return localStorage.getItem('bt.dev.noRaise') === '1';
+    }
+    catch {
+        return false;
+    } })();
+    layerProbe = invoke('shell_raise', { on: false }).then(ok => { layer.supported = raiseSupported(ok, off); syncLayer(); scheduleSync(); }, () => { });
+}
+/** Wait until the startup cover has either raised the shell or hidden the native tabs. */
+export async function flushLayer() {
+    await layerProbe;
+    await layer.queue;
+}
+/**
+ * While the shell is see-through, the few px of gutter between panes show the window's own
+ * background: paint it the theme's ground (read before `bt-raised` clears the page's).
+ */
+let windowGround = '';
+function paintWindowGround() {
+    const ground = cssRgb(getComputedStyle(document.documentElement).backgroundColor);
+    if (!ground || ground.join() === windowGround)
+        return;
+    windowGround = ground.join();
+    currentWindow().setBackgroundColor([...ground, 255]).catch(() => { windowGround = ''; });
+}
+function syncLayer() {
+    if (!layer.supported)
+        return;
+    layer.queue = layer.queue.then(async () => {
+        const want = shell.overlay > 0;
+        if (want === layer.raised)
+            return;
+        const root = document.documentElement;
+        if (want) {
+            // See-through first (still under the tabs, so nothing changes on screen), then on top.
+            paintWindowGround();
+            root.classList.add('bt-raised');
+            await frames();
+            layer.raised = true;
+            diag('raise: on');
+            await invoke('shell_raise', { on: true });
+            diag(`raised (hasFocus=${document.hasFocus()})`);
+        }
+        else {
+            // Under the tabs first, then opaque again: the panes never blink.
+            const refocus = document.hasFocus() && (!document.activeElement || document.activeElement === document.body);
+            layer.raised = false;
+            diag('raise: off');
+            await invoke('shell_raise', { on: false });
+            diag(`lowered (hasFocus=${document.hasFocus()})`);
+            await frames();
+            if (shell.overlay === 0)
+                root.classList.remove('bt-raised');
+            // Closed from the keyboard or a click in the shell (not by the window losing focus) with
+            // nothing in the shell focused: typing goes back to the active pane.
+            const active = shell.api?.activePanel;
+            if (refocus && shell.overlay === 0 && active && isWeb(active))
+                void tabAction(active.id, 'focus');
+        }
+    }).catch(error => console.error('[shell] shell_raise', error));
+}
+let saveTimer;
+export function saveLayoutSoon() {
+    clearTimeout(saveTimer);
+    saveTimer = setTimeout(() => {
+        if (!shell.api || shell.restoring)
+            return;
+        try {
+            localStorage.setItem(LAYOUT_KEY, JSON.stringify(shell.api.toJSON()));
+        }
+        catch { /* Session restore is best effort. */ }
+    }, 400);
+}
+export function loadLayout() {
+    try {
+        return JSON.parse(localStorage.getItem(LAYOUT_KEY) || 'null');
+    }
+    catch {
+        return null;
+    }
+}
+export const tabAction = (id, action) => invoke('tab_action', { id, action }).catch(() => { });
+//# sourceMappingURL=state.js.map