@ai-matrx/chat 0.4.0 → 0.4.7

package/dist/host/configure.d.ts

@@ -12,7 +12,9 @@
  * port (identity → diagnostics, server → identity + org) always reaches the
  * resolved one — the host's override when it gave one.
  */
-import type { ChatHost, ChatRoutes, ResolvedChatHost } from "./contract.js";
+import type { ChatAppIdentity, ChatHost, ChatRoutes, ResolvedChatHost } from "./contract.js";
+/** What a host that names no `app` is called: the neutral registered producer, never matrx-frontend. */
+export declare const DEFAULT_CHAT_APP: ChatAppIdentity;
 /** The platform's production addresses — the default `routes`. */
 export declare const DEFAULT_CHAT_ROUTES: ChatRoutes;
 export declare function resolveChatHost(host: ChatHost): ResolvedChatHost;
@@ -22,6 +24,12 @@ export declare function configureChat(host: ChatHost): ResolvedChatHost;
 export declare function onChatHostConfigured(listener: () => void): () => void;
 /** The configured host. Throws `ChatHostNotConfiguredError` (with the remedy) when there is none. */
 export declare function getChatHost(): ResolvedChatHost;
+/**
+ * False when the configured host gave a message `source` and no `db` (the db is the stand-in).
+ * The branch every global database read takes FIRST (G-DOOR). Unconfigured: true — the read
+ * then fails loudly on the missing host, as before.
+ */
+export declare function chatHostHasDatabase(): boolean;
 /** True once `configureChat` (or `<ChatProvider>` in a browser) has run. */
 export declare function isChatHostConfigured(): boolean;
 /** Test-only: forget the configured host. */

package/dist/host/configure.js

@@ -8,7 +8,7 @@ import {
   isChatSourceApp
 } from "./defaults/diagnostics.js";
 import { createDbIdentity } from "./defaults/identity.js";
-import { createNoPickerOrg } from "./defaults/org.js";
+import { createStoredOrg } from "./defaults/org.js";
 import { createDefaultServer } from "./defaults/server.js";
 import { createDefaultServerApi } from "./defaults/server-api.js";
 import { createDomNotifier } from "./defaults/notify.js";
@@ -19,6 +19,14 @@ import { createDbCatalogGetter } from "./defaults/catalog.js";
 import { createDefaultChrome } from "./defaults/chrome.js";
 import { createDbFeedback } from "./defaults/feedback.js";
 import { createUnhostedCanvas } from "./defaults/canvas.js";
+import { SIGNED_OUT_IDENTITY } from "./defaults/identity.js";
+import {
+  NO_DATABASE_CODE_PREFIX,
+  createConsoleDiagnostics,
+  createNoDatabaseStandIn,
+  createNoServerApi
+} from "./no-database.js";
+const DEFAULT_CHAT_APP = Object.freeze({ sourceApp: "chat" });
 const DEFAULT_CHAT_ROUTES = Object.freeze({
   workflowStudio: "https://workflows.aimatrx.com"
 });
@@ -41,24 +49,41 @@ const PORTS = [
 const EMPTY_REGISTRATIONS = Object.freeze({});
 function assertDb(host) {
   const db = host?.db;
-  if (!db) throw new ChatHostInvalidError("`db` is missing");
+  if (!db) {
+    if (host?.source) return;
+    throw new ChatHostInvalidError("`db` is missing (pass `db`, or a message `source`)");
+  }
   if (typeof db.rpc !== "function" || typeof db.from !== "function" || !db.auth) {
     throw new ChatHostInvalidError(
       "`db` is not a Supabase client (no auth/rpc/from)"
     );
   }
 }
+const SOURCE_ONLY_IDENTITY = Object.freeze({
+  current: () => SOURCE_ONLY_IDENTITY_VALUE,
+  subscribe: () => () => {
+  },
+  getAccessToken: async () => null
+});
+const SOURCE_ONLY_IDENTITY_VALUE = Object.freeze({ ...SIGNED_OUT_IDENTITY, authReady: true });
 function resolveChatHost(host) {
   assertDb(host);
-  const { db } = host;
+  const hasDatabase = Boolean(host.db);
+  const reportNoDatabase = (feature) => {
+    ref.diagnostics.capture(new Error(`no database: ${feature}`), {
+      area: "host-source",
+      code: `${NO_DATABASE_CODE_PREFIX}${feature}`
+    });
+  };
+  const db = host.db ?? createNoDatabaseStandIn(reportNoDatabase);
   const overridden = new Set(
     PORTS.filter((name) => host[name] !== void 0)
   );
   const ref = {};
-  const diagnostics = host.diagnostics ?? createLogClientErrorDiagnostics(db, { sourceApp: host.sourceApp });
+  const diagnostics = host.diagnostics ?? (hasDatabase ? createLogClientErrorDiagnostics(db, { sourceApp: host.sourceApp }) : createConsoleDiagnostics());
   const notify = host.notify ?? createDomNotifier();
-  const identity = host.identity ?? createDbIdentity(db, () => ref.diagnostics);
-  const org = host.org ?? createNoPickerOrg(
+  const identity = host.identity ?? (hasDatabase ? createDbIdentity(db, () => ref.diagnostics) : SOURCE_ONLY_IDENTITY);
+  const org = host.org ?? createStoredOrg(
     () => ref.notify,
     () => ref.diagnostics
   );
@@ -68,7 +93,10 @@ function resolveChatHost(host) {
   );
   const server = {
     ...serverPort,
-    api: serverPort.api ?? defaultServerApi(() => ref)
+    api: serverPort.api ?? (hasDatabase || host.server ? defaultServerApi(() => ref) : createNoServerApi(
+      reportNoDatabase,
+      defaultServerApi(() => ref)
+    ))
   };
   const prefs = host.prefs ?? createWebPrefs();
   const navigation = host.navigation ?? createWindowNavigation();
@@ -81,7 +109,10 @@ function resolveChatHost(host) {
   );
   Object.assign(ref, {
     db,
+    hasDatabase,
+    source: host.source ?? null,
     sourceApp: isChatSourceApp(host.sourceApp) ? host.sourceApp : null,
+    app: host.app ?? DEFAULT_CHAT_APP,
     identity,
     org,
     server,
@@ -106,7 +137,7 @@ function defaultServerApi(host) {
 let configured = null;
 function configureChat(host) {
   if (configured?.host === host) return configured.resolved;
-  if (configured && configured.host.db !== host.db) {
+  if (configured && configured.host.db && host.db && configured.host.db !== host.db) {
     announceOnce(
       "configure-replaced-db",
       "configureChat was called again with a different `db`; the newest host replaces the first. Configure the chat host once per page."
@@ -131,6 +162,9 @@ function getChatHost() {
   if (!configured) throw new ChatHostNotConfiguredError();
   return configured.resolved;
 }
+function chatHostHasDatabase() {
+  return configured ? configured.resolved.hasDatabase : true;
+}
 function isChatHostConfigured() {
   return configured !== null;
 }
@@ -138,8 +172,10 @@ function _resetChatHostForTests() {
   configured = null;
 }
 export {
+  DEFAULT_CHAT_APP,
   DEFAULT_CHAT_ROUTES,
   _resetChatHostForTests,
+  chatHostHasDatabase,
   configureChat,
   getChatHost,
   isChatHostConfigured,

package/dist/host/contract.d.ts

@@ -24,6 +24,7 @@ import type { CanvasJson } from "@ai-matrx/canvas";
 import type { ChatCanvasTabKind } from "./canvas-tabs.js";
 import type { ChatWindowOpeners } from "./window-openers.js";
 import type { DefaultChatServerApi, DefaultChatServerTypes } from "./defaults/server-api.js";
+import type { ChatMessageSource } from "./source.js";
 /**
  * The connection contract (R10). Authenticated, RLS applies. Typed with the
  * package's own `ChatDatabase` (`./db-types`, generated: the schemas the
@@ -89,6 +90,11 @@ export interface ChatOrgPort {
      * Never picks one on the person's behalf.
      */
     require(reason: string, options?: ChatOrgRequireOptions): Promise<string>;
+    /**
+     * The person picked an organization in the package's own picker (the bare-host
+     * `WorkspaceGate`). Absent on a host that brings its own picker (matrx-frontend).
+     */
+    choose?(org: ChatOrganization): void;
 }
 /**
  * The host's server client and its types, REGISTERED by module augmentation —
@@ -718,15 +724,39 @@ export interface ChatCanvasPort {
     useOpeners(): ChatCanvasOpeners;
     useTab(tab: ChatCanvasTabRef): ChatCanvasTab;
 }
+/** How a host names itself on the conversations it starts. */
+export interface ChatAppIdentity {
+    /** `chat.conversation.source_app` — a producer registered with the server. */
+    sourceApp: string;
+    /** `source_feature` for every conversation this app starts; absent keeps each screen's own. */
+    sourceFeature?: string;
+}
 export interface ChatHost {
-    /** R10 connection contract — the ONLY required value. Authenticated, RLS applies. */
-    db: ChatDb;
+    /**
+     * R10 connection contract. Authenticated, RLS applies. Required unless `source` is given: a
+     * host with no database gets the no-database stand-in (`./no-database`), which refuses and
+     * says so per feature.
+     */
+    db?: ChatDb;
+    /**
+     * A host-owned message source (`./source`, HOST-OWNED-SOURCE-PLAN §2.2): conversations bound
+     * to it (`useHostConversation`) load, stream and send through the host, never a database.
+     * Both may be given; at least one is required.
+     */
+    source?: ChatMessageSource;
     /**
      * Which client this is, for the platform errors system (`log_client_error`'s
      * closed `p_source_app` list). Absent or off the list: diagnostics stay on the
      * console and say so once.
      */
     sourceApp?: ChatSourceApp;
+    /**
+     * What this app calls itself on the conversations it starts (`source_app`, and when given a
+     * `source_feature` that replaces the per-screen one). Both must be registered with the server
+     * (`source_attribution`). Absent: the neutral app `chat` and each screen's own feature — a host
+     * that is not matrx-frontend never labels its rows as the main app's.
+     */
+    app?: ChatAppIdentity;
     /** Default: from db.auth (getSession + onAuthStateChange); admin level from admin.admins. */
     identity?: ChatIdentityPort;
     /** Default: no active org; `require` refuses loudly (never auto-picks). */
@@ -765,8 +795,15 @@ export interface ChatHost {
 export type ChatPortName = "identity" | "org" | "server" | "notify" | "diagnostics" | "prefs" | "navigation" | "windows" | "catalog" | "registry" | "chrome" | "feedback" | "routes" | "canvas";
 /** Every port present. `overridden` names the ports the host supplied itself. */
 export interface ResolvedChatHost {
+    /** The host's client, or the no-database stand-in when it gave only a `source`. */
     db: ChatDb;
+    /** False when `db` is the stand-in. */
+    hasDatabase: boolean;
+    /** The host's message source, or null. */
+    source: ChatMessageSource | null;
     sourceApp: ChatSourceApp | null;
+    /** The app's identity on the conversations it starts (`DEFAULT_CHAT_APP` when the host gave none). */
+    app: ChatAppIdentity;
     identity: ChatIdentityPort;
     org: ChatOrgPort;
     server: ResolvedChatServerPort;

package/dist/host/db-types.d.ts

@@ -7156,6 +7156,13 @@ export type ChatDatabase = {
                         referencedRelation: "user_request_summary";
                         referencedColumns: ["id"];
                     },
+                    {
+                        foreignKeyName: "fk_cx_tool_call_parent";
+                        columns: ["parent_call_id"];
+                        isOneToOne: false;
+                        referencedRelation: "_tool_call_facts";
+                        referencedColumns: ["tool_call_id"];
+                    },
                     {
                         foreignKeyName: "fk_cx_tool_call_parent";
                         columns: ["parent_call_id"];
@@ -7559,6 +7566,48 @@ export type ChatDatabase = {
             };
         };
         Views: {
+            _tool_call_facts: {
+                Row: {
+                    after_trim: number | null;
+                    agent_id: string | null;
+                    chars_refetched_same_data: number | null;
+                    conversation_id: string | null;
+                    created_at: string | null;
+                    gap_calls: number | null;
+                    gap_secs: number | null;
+                    is_repeat: number | null;
+                    new_data: number | null;
+                    output_chars: number | null;
+                    person_id: string | null;
+                    same_data: number | null;
+                    tool_call_id: string | null;
+                    tool_name: string | null;
+                    unknown_data: number | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "cx_tool_call_conversation_id_fkey";
+                        columns: ["conversation_id"];
+                        isOneToOne: false;
+                        referencedRelation: "admin_conversation_summary";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "cx_tool_call_conversation_id_fkey";
+                        columns: ["conversation_id"];
+                        isOneToOne: false;
+                        referencedRelation: "conversation";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "cx_tool_call_conversation_id_fkey";
+                        columns: ["conversation_id"];
+                        isOneToOne: false;
+                        referencedRelation: "conversation_summary";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
             admin_conversation_summary: {
                 Row: {
                     conversation_type: string | null;
@@ -30382,6 +30431,14 @@ export type ChatDatabase = {
                 Args: never;
                 Returns: Json;
             };
+            drill_def__tool_refetch: {
+                Args: never;
+                Returns: Json;
+            };
+            drill_def__user_acquisition: {
+                Args: never;
+                Returns: Json;
+            };
             drill_def__workflow_runs: {
                 Args: never;
                 Returns: Json;
@@ -51548,7 +51605,30 @@ export type ChatDatabase = {
             };
         };
         Views: {
-            [_ in never]: never;
+            _acquisition_facts: {
+                Row: {
+                    blocked: boolean | null;
+                    campaign: string | null;
+                    converted_at: string | null;
+                    cost: number | null;
+                    created_at: string | null;
+                    guest_id: string | null;
+                    identity_id: string | null;
+                    identity_state: string | null;
+                    landing_host: string | null;
+                    landing_path: string | null;
+                    person_id: string | null;
+                    referrer: string | null;
+                    referrer_host: string | null;
+                    referrer_state: string | null;
+                    requests: number | null;
+                    traffic_kind: string | null;
+                    utm_campaign: string | null;
+                    utm_medium: string | null;
+                    utm_source: string | null;
+                };
+                Relationships: [];
+            };
         };
         Functions: {
             _set_own_organization_choice: {
@@ -51558,6 +51638,20 @@ export type ChatDatabase = {
                 };
                 Returns: string;
             };
+            acquisition_host_is_local: {
+                Args: {
+                    p_host: string;
+                };
+                Returns: boolean;
+            };
+            acquisition_traffic_kind: {
+                Args: {
+                    p_landing_host: string;
+                    p_referrer: string;
+                    p_user_agent: string;
+                };
+                Returns: string;
+            };
             admin_account_facts: {
                 Args: never;
                 Returns: {
@@ -51633,6 +51727,10 @@ export type ChatDatabase = {
                 Args: never;
                 Returns: number;
             };
+            my_organization_choices: {
+                Args: never;
+                Returns: Json;
+            };
             my_organization_vault_access: {
                 Args: {
                     p_organization_id: string;

package/dist/host/defaults/navigation-hooks.d.ts

@@ -1,3 +1,5 @@
 import type { ChatSearchParams } from "../contract.js";
+/** Fired after the default port moves the address with the history API (no page load). */
+export declare const CHAT_NAVIGATED_EVENT = "ai-matrx-chat:navigated";
 export declare function useWindowPathname(): string;
 export declare function useWindowSearchParams(): ChatSearchParams;

package/dist/host/defaults/navigation-hooks.js

@@ -1,11 +1,16 @@
 "use client";
 import { useSyncExternalStore } from "react";
 const hasWindow = () => typeof window !== "undefined";
+const CHAT_NAVIGATED_EVENT = "ai-matrx-chat:navigated";
 function subscribeToHistory(listener) {
   if (!hasWindow()) return () => {
   };
   window.addEventListener("popstate", listener);
-  return () => window.removeEventListener("popstate", listener);
+  window.addEventListener(CHAT_NAVIGATED_EVENT, listener);
+  return () => {
+    window.removeEventListener("popstate", listener);
+    window.removeEventListener(CHAT_NAVIGATED_EVENT, listener);
+  };
 }
 function useWindowPathname() {
   return useSyncExternalStore(
@@ -32,6 +37,7 @@ function useWindowSearchParams() {
   return paramsFor(search);
 }
 export {
+  CHAT_NAVIGATED_EVENT,
   useWindowPathname,
   useWindowSearchParams
 };

package/dist/host/defaults/navigation.d.ts

@@ -1,7 +1,8 @@
 /**
- * Default navigation port: full page loads through `window.location`, links as
- * plain anchors, the path and query read from `window.location` (kept current
- * across back/forward). matrx-frontend overrides with the package's Next
+ * Default navigation port: CLIENT-SIDE navigation through the history API (no page load, the
+ * mounted chat keeps its state), links as anchors that navigate the same way, the path and query
+ * read from `window.location` (kept current across back/forward and the port's own moves). An
+ * address on another origin is a real page load. matrx-frontend overrides with the package's Next
  * binding (`next/navigation`).
  */
 import type { ChatNavigationPort } from "../contract.js";

package/dist/host/defaults/navigation.js

@@ -1,18 +1,49 @@
 import { createElement } from "react";
-import { useWindowPathname, useWindowSearchParams } from "./navigation-hooks.js";
-function PlainLink({ prefetch, replace, scroll, ...anchor }) {
+import { CHAT_NAVIGATED_EVENT, useWindowPathname, useWindowSearchParams } from "./navigation-hooks.js";
+const hasWindow = () => typeof window !== "undefined";
+function sameOriginAddress(href) {
+  if (!hasWindow()) return null;
+  try {
+    const url = new URL(href, window.location.href);
+    return url.origin === window.location.origin ? url.pathname + url.search + url.hash : null;
+  } catch {
+    return null;
+  }
+}
+function move(href, mode) {
+  if (!hasWindow()) return;
+  const address = sameOriginAddress(href);
+  if (address === null) {
+    if (mode === "push") window.location.assign(href);
+    else window.location.replace(href);
+    return;
+  }
+  if (mode === "push") window.history.pushState(null, "", address);
+  else window.history.replaceState(null, "", address);
+  window.dispatchEvent(new Event(CHAT_NAVIGATED_EVENT));
+}
+function PlainLink({ prefetch, replace, scroll, onClick, ...anchor }) {
   void prefetch;
-  void replace;
   void scroll;
-  return createElement("a", anchor);
+  return createElement("a", {
+    ...anchor,
+    onClick: (event) => {
+      onClick?.(event);
+      const href = typeof anchor.href === "string" ? anchor.href : null;
+      if (event.defaultPrevented || !href || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || anchor.target && anchor.target !== "_self" || sameOriginAddress(href) === null) {
+        return;
+      }
+      event.preventDefault();
+      move(href, replace ? "replace" : "push");
+    }
+  });
 }
-const hasWindow = () => typeof window !== "undefined";
 const windowRouter = {
   push(href) {
-    if (hasWindow()) window.location.assign(href);
+    move(href, "push");
   },
   replace(href) {
-    if (hasWindow()) window.location.replace(href);
+    move(href, "replace");
   },
   back() {
     if (hasWindow()) window.history.back();

package/dist/host/defaults/org.d.ts

@@ -1,8 +1,16 @@
 /**
- * Default org port. A bare host has no organization picker, and the platform
- * rule is hold-and-set — never auto-pick. So: no active org, and `require`
- * refuses with a named, remedied error that is also shown and recorded.
- * A host with a picker (matrx-frontend) overrides this port.
+ * Org ports for a host that brings no organization port of its own.
+ *
+ * `createStoredOrg` (the default): the person picks in the package's own
+ * `WorkspaceGate` picker (`./workspace-gate.tsx`, memberships read over `db`),
+ * the choice is remembered on this device, and `require` resolves it. Nothing is
+ * ever picked on the person's behalf (hold-and-set); with no choice yet `require`
+ * refuses exactly like `createNoPickerOrg`, and the gate shows the picker.
+ * `createNoPickerOrg`: never an organization — for a host that must not write.
+ * A host with its own picker (matrx-frontend) overrides the port.
  */
 import type { ChatDiagnosticsPort, ChatNotifyPort, ChatOrgPort } from "../contract.js";
 export declare function createNoPickerOrg(notify: () => ChatNotifyPort, diagnostics: () => ChatDiagnosticsPort): ChatOrgPort;
+/** Where the bare-host choice is remembered (this device only). */
+export declare const CHAT_ACTIVE_ORG_STORAGE_KEY = "matrx-chat:active-organization";
+export declare function createStoredOrg(notify: () => ChatNotifyPort, diagnostics: () => ChatDiagnosticsPort): ChatOrgPort;

package/dist/host/defaults/org.js

@@ -18,6 +18,44 @@ function createNoPickerOrg(notify, diagnostics) {
     }
   };
 }
+const CHAT_ACTIVE_ORG_STORAGE_KEY = "matrx-chat:active-organization";
+function readStored() {
+  try {
+    if (typeof window === "undefined" || !window.localStorage) return null;
+    const raw = window.localStorage.getItem(CHAT_ACTIVE_ORG_STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    return typeof parsed.id === "string" ? { id: parsed.id, name: parsed.name ?? null } : null;
+  } catch {
+    return null;
+  }
+}
+function createStoredOrg(notify, diagnostics) {
+  const refuse = createNoPickerOrg(notify, diagnostics);
+  let active = readStored();
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    active: () => active,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    require(reason, options) {
+      if (active) return Promise.resolve(active.id);
+      return refuse.require(reason, options);
+    },
+    choose(org) {
+      active = { id: org.id, name: org.name };
+      try {
+        window.localStorage?.setItem(CHAT_ACTIVE_ORG_STORAGE_KEY, JSON.stringify(active));
+      } catch {
+      }
+      for (const listener of [...listeners]) listener();
+    }
+  };
+}
 export {
-  createNoPickerOrg
+  CHAT_ACTIVE_ORG_STORAGE_KEY,
+  createNoPickerOrg,
+  createStoredOrg
 };

package/dist/host/defaults/prefs.d.ts

@@ -23,3 +23,14 @@ export declare const PREFERENCE_FIELDS: Readonly<Record<string, keyof ChatPrefer
 export declare function createUnhostedKnobs(): ChatKnobsPort;
 export declare const CHAT_PREFS_PREFIX = "ai-matrx-chat:";
 export declare function createWebPrefs(): ChatPrefsPort;
+/**
+ * A prefs port the HOST keeps (HOST-OWNED-SOURCE-PLAN §2.2 "Drafts"): a page whose origin
+ * changes between launches (a local host on a new port, a desktop window) cannot keep drafts in
+ * web storage. The host reads its saved values once (`initial`) and receives every change
+ * (`persist`, `null` = removed) to write where it keeps them — a file, an IPC store. Reads are
+ * synchronous from memory, so the first render already sees the saved draft.
+ */
+export declare function createHostKeptPrefs(options: {
+    initial: Readonly<Record<string, string>>;
+    persist: (key: string, value: string | null) => void;
+}): ChatPrefsPort;

package/dist/host/defaults/prefs.js

@@ -168,11 +168,54 @@ function createWebPrefs() {
   };
   return port;
 }
+function createHostKeptPrefs(options) {
+  const memory = new Map(Object.entries(options.initial));
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = (key) => {
+    for (const listener of listeners) listener(key);
+  };
+  const write = (key, value) => {
+    try {
+      options.persist(key, value);
+    } catch (error) {
+      announceOnce(
+        "prefs-host-write-failed",
+        `The host could not save a chat preference or draft (${error instanceof Error ? error.message : String(error)}); it is kept for this session.`
+      );
+    }
+  };
+  const port = {
+    get: (key) => memory.get(key) ?? null,
+    set(key, value) {
+      if (memory.get(key) === value) return;
+      memory.set(key, value);
+      write(key, value);
+      emit(key);
+    },
+    remove(key) {
+      if (!memory.has(key)) return;
+      memory.delete(key);
+      write(key, null);
+      emit(key);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    knob: (key, fallback) => parseKnob(memory.get(key) ?? null, fallback),
+    knobs: createUnhostedKnobs(),
+    snapshot: () => Object.fromEntries(memory)
+  };
+  return port;
+}
 export {
   CHAT_PREFS_PREFIX,
   DEFAULT_CHAT_PREFERENCES,
   PREFERENCE_FIELDS,
   applyPreferenceWrite,
+  createHostKeptPrefs,
   createUnhostedKnobs,
   createWebPrefs
 };

package/dist/host/defaults/workspace-gate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The bare-host `WorkspaceGate`: when a surface is blocked on "no organization chosen",
+ * the same area lists the organizations the person belongs to (read over `host.db`) and
+ * picking one makes it active (`host.org.choose`). Nothing is picked for the person.
+ * A host with its own picker (matrx-frontend) registers its own gate.
+ */
+import { type ReactNode } from "react";
+export interface DefaultWorkspaceGateProps {
+    blocked: boolean;
+    sentence: string;
+    description?: string;
+    children?: ReactNode;
+    compact?: boolean;
+    className?: string;
+}
+export declare function DefaultWorkspaceGate({ blocked, sentence, description, children, className }: DefaultWorkspaceGateProps): import("react").JSX.Element;