@hanzo/rooms 0.1.54 → 0.1.56

package/dist/Orgs.js

@@ -297,9 +297,8 @@ function Veil() {
 /**
  * The room, in the one place every branch that draws it puts it. Under the veil
  * it is inert and hidden from assistive technology, so what the veil covers
- * takes no focus, key or press: Dev's composer focuses itself as it mounts, and
- * a team on Free could otherwise type and send before its ask was drawn. It
- * lays out as its children do.
+ * takes no focus, key or press: a team on Free cannot type and send before its
+ * ask is drawn. It lays out as its children do.
  */
 function Held({ veiled, children }) {
     return (_jsx(View, { render: _jsx("div", { "data-slot": "held", inert: veiled, "aria-hidden": veiled || undefined }), display: "contents", children: children }));

package/dist/lib/host.d.ts

@@ -130,9 +130,16 @@ export declare const WEB = "https://hanzo.ai/chat";
 export declare const guest: (hostname: string) => boolean;
 /**
  * Whether a host is the devnet's: its production twin with `-dev` on the one
- * label under hanzo.ai (app-dev.hanzo.ai, api-dev.hanzo.ai, id-dev.hanzo.ai),
- * and dev.hanzo.ai, the devnet's sandbox checkout. A deeper name
- * (a.b-dev.hanzo.ai) is not one, and neither is a name that only contains the
- * suffix (app-dev.hanzo.ai.example.com).
+ * label under hanzo.ai (app-dev.hanzo.ai, api-dev.hanzo.ai, id-dev.hanzo.ai). A
+ * deeper name (a.b-dev.hanzo.ai) is not one, and neither is a name that only
+ * contains the suffix (app-dev.hanzo.ai.example.com). dev.hanzo.ai is not one
+ * either: it is hanzo.ai/dev's old address and redirects there.
  */
 export declare function devnet(hostname: string): boolean;
+/**
+ * Whether a host answers IAM's sign-in and sign-out calls on its own origin, so
+ * a page there signs in without leaving it. Every devnet host does: app-dev's
+ * /v1 is the devnet cloud, whose IAM is the devnet's own (universe hanzo-devnet
+ * cloud.yaml).
+ */
+export declare const answers: (hostname: string) => boolean;

package/dist/lib/host.js

@@ -201,16 +201,28 @@ export const guest = (hostname) => hostname === 'hanzo.app' || hostname.endsWith
 const DEVNET = '-dev.hanzo.ai';
 /**
  * Whether a host is the devnet's: its production twin with `-dev` on the one
- * label under hanzo.ai (app-dev.hanzo.ai, api-dev.hanzo.ai, id-dev.hanzo.ai),
- * and dev.hanzo.ai, the devnet's sandbox checkout. A deeper name
- * (a.b-dev.hanzo.ai) is not one, and neither is a name that only contains the
- * suffix (app-dev.hanzo.ai.example.com).
+ * label under hanzo.ai (app-dev.hanzo.ai, api-dev.hanzo.ai, id-dev.hanzo.ai). A
+ * deeper name (a.b-dev.hanzo.ai) is not one, and neither is a name that only
+ * contains the suffix (app-dev.hanzo.ai.example.com). dev.hanzo.ai is not one
+ * either: it is hanzo.ai/dev's old address and redirects there.
  */
 export function devnet(hostname) {
-    if (hostname === 'dev.hanzo.ai')
-        return true;
     if (!hostname.endsWith(DEVNET))
         return false;
     const label = hostname.slice(0, -'.hanzo.ai'.length);
     return label.length > '-dev'.length && !label.includes('.');
 }
+/**
+ * The hosts that answer IAM's sign-in and sign-out calls on their own origin:
+ * every host this export is served on and signs in at (universe static-sites
+ * `iam-on-hanzo-ai` and cloud.yaml `iam-signin`), testnet's test.hanzo.ai, and
+ * the dev server's /v1 proxy.
+ */
+const ANSWERS = new Set([...APEX, 'cloud.hanzo.ai', 'hanzo.bot', 'bot.hanzo.ai', 'test.hanzo.ai', 'localhost', '127.0.0.1']);
+/**
+ * Whether a host answers IAM's sign-in and sign-out calls on its own origin, so
+ * a page there signs in without leaving it. Every devnet host does: app-dev's
+ * /v1 is the devnet cloud, whose IAM is the devnet's own (universe hanzo-devnet
+ * cloud.yaml).
+ */
+export const answers = (hostname) => ANSWERS.has(hostname) || devnet(hostname);

package/dist/lib/signout.d.ts

@@ -1,5 +1,5 @@
 import { IAM } from '@hanzo/iam';
-/** Whether the page in front of us is on such an origin. */
+/** Whether the page in front of us is on an origin that answers IAM itself (`answers` in host.ts). */
 export declare const here: () => boolean;
 /** The IAM client for this page; the token exchange at the callback shares its PKCE store. */
 export declare function useClient(): IAM;

package/dist/lib/signout.js

@@ -12,17 +12,9 @@ import { IAM } from '@hanzo/iam';
 import { useIam } from '@hanzo/iam/react';
 import { useSignOut as useUiSignOut } from '@hanzo/ui/auth';
 import { track } from './tags.js';
-import { APEX } from './host.js';
-/**
- * The hosts that answer IAM's sign-in and sign-out calls on their own origin:
- * every host this export is served on and signs in at (universe static-sites
- * `iam-on-hanzo-ai` and cloud.yaml `iam-signin`), each network's own
- * (test.hanzo.ai for testnet, dev.hanzo.ai for devnet), and the dev server's
- * /v1 proxy.
- */
-const HOSTS = new Set([...APEX, 'cloud.hanzo.ai', 'hanzo.bot', 'bot.hanzo.ai', 'test.hanzo.ai', 'dev.hanzo.ai', 'localhost', '127.0.0.1']);
-/** Whether the page in front of us is on such an origin. */
-export const here = () => typeof window !== 'undefined' && HOSTS.has(window.location.hostname);
+import { answers } from './host.js';
+/** Whether the page in front of us is on an origin that answers IAM itself (`answers` in host.ts). */
+export const here = () => typeof window !== 'undefined' && answers(window.location.hostname);
 /** The IAM client for this page; the token exchange at the callback shares its PKCE store. */
 export function useClient() {
     const { config } = useIam();

package/dist/lib/tier.d.ts

@@ -93,10 +93,57 @@ export declare function useSubscription(enabled?: boolean, org?: string | null):
  * are asked.
  */
 export declare function paying(signal?: AbortSignal): Promise<boolean>;
+/** The last tier an organization was read at. */
+export type Read = {
+    org: string | null;
+    tier: Tier;
+};
+/** What a read left held, and for which organization. */
+export type Held = {
+    org: string | null;
+    tier: Tier | null;
+    wrong: unknown;
+};
+/**
+ * Whether a failed read may answer otherwise on the next try: no answer at all
+ * (the network, a timeout), too many asks (429) or billing's own failure (a
+ * 5xx). A 401, 403 or 404 is billing's answer, and stands.
+ */
+export declare function transient(e: unknown): boolean;
+/**
+ * What a read of the tier leaves held, and the tier the next read falls back
+ * on. A read that answers is the tier. One that fails for a moment
+ * (`transient`) keeps the tier this organization was last read at, so a reader
+ * is not swapped out of a room they pay for by a re-read that did not answer
+ * (the gate reads again on focus and on return). Billing's refusal, or a
+ * failure with nothing read for it yet, holds nothing and says why, which keeps
+ * every gate shut; a refusal also forgets the tier read before it, so no later
+ * failure brings it back.
+ */
+export declare function hold(last: Read | null, org: string | null, read: {
+    tier: Tier;
+} | {
+    wrong: unknown;
+}): {
+    tier: Tier | null;
+    wrong: unknown;
+    last: Read | null;
+};
+/**
+ * The tier and the refusal held for `org`, and nothing for any other: what was
+ * read for the organization a reader just left is never the one they are in,
+ * so a switch from a paid organization to a team on Free shows no room while
+ * the new one is read.
+ */
+export declare function standing(held: Held | null, org: string | null): {
+    tier: Tier | null;
+    wrong: unknown;
+};
 /**
  * The tier, held. `null` while unknown — which is BOTH "still asking" and
  * "asked and was refused", so `wrong` is kept beside it rather than swallowed:
- * a row cannot choose between saying nothing and saying why without it.
+ * a row cannot choose between saying nothing and saying why without it. A
+ * re-read that fails keeps the last tier read (`hold`).
  */
 export declare function useTier(enabled?: boolean, org?: string | null): {
     tier: Tier | null;

package/dist/lib/tier.js

@@ -21,7 +21,7 @@
  * reads first, so a refusal here already speaks the vocabulary every room uses.
  * A second Refusal class would be a second vocabulary for the same event.
  */
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 import { api } from './api.js';
 import { bearer, org, orgs, scope } from './session.js';
 import { list } from './list.js';
@@ -147,34 +147,69 @@ export async function paying(signal) {
     }));
     return reads.some((r) => r.status === 'fulfilled' && paid(r.value));
 }
+/**
+ * Whether a failed read may answer otherwise on the next try: no answer at all
+ * (the network, a timeout), too many asks (429) or billing's own failure (a
+ * 5xx). A 401, 403 or 404 is billing's answer, and stands.
+ */
+export function transient(e) {
+    const status = e?.status;
+    return typeof status !== 'number' || status === 408 || status === 429 || status >= 500;
+}
+/**
+ * What a read of the tier leaves held, and the tier the next read falls back
+ * on. A read that answers is the tier. One that fails for a moment
+ * (`transient`) keeps the tier this organization was last read at, so a reader
+ * is not swapped out of a room they pay for by a re-read that did not answer
+ * (the gate reads again on focus and on return). Billing's refusal, or a
+ * failure with nothing read for it yet, holds nothing and says why, which keeps
+ * every gate shut; a refusal also forgets the tier read before it, so no later
+ * failure brings it back.
+ */
+export function hold(last, org, read) {
+    if ('tier' in read)
+        return { tier: read.tier, wrong: null, last: { org, tier: read.tier } };
+    const mine = last && last.org === org ? last : null;
+    if (transient(read.wrong) && mine)
+        return { tier: mine.tier, wrong: null, last: mine };
+    return { tier: null, wrong: read.wrong, last: transient(read.wrong) ? last : null };
+}
+/**
+ * The tier and the refusal held for `org`, and nothing for any other: what was
+ * read for the organization a reader just left is never the one they are in,
+ * so a switch from a paid organization to a team on Free shows no room while
+ * the new one is read.
+ */
+export function standing(held, org) {
+    return held && held.org === org ? { tier: held.tier, wrong: held.wrong } : { tier: null, wrong: null };
+}
 /**
  * The tier, held. `null` while unknown — which is BOTH "still asking" and
  * "asked and was refused", so `wrong` is kept beside it rather than swallowed:
- * a row cannot choose between saying nothing and saying why without it.
+ * a row cannot choose between saying nothing and saying why without it. A
+ * re-read that fails keeps the last tier read (`hold`).
  */
 export function useTier(enabled = true, org = null) {
-    const [tier, setTier] = useState(null);
-    const [wrong, setWrong] = useState(null);
+    const [held, setHeld] = useState(null);
     const [nonce, setNonce] = useState(0);
+    const last = useRef(null);
     useEffect(() => {
         if (!enabled)
             return;
         const stop = new AbortController();
-        setWrong(null);
-        readTier(stop.signal)
-            .then((got) => {
-            if (!stop.signal.aborted)
-                setTier(got);
-        })
-            .catch((e) => {
-            if (!stop.signal.aborted) {
-                setTier(null);
-                setWrong(e);
-            }
-        });
+        // Asking again: the refusal the last read gave is no longer the answer.
+        setHeld((h) => (h && h.org === org ? { ...h, wrong: null } : h));
+        const settle = (read) => {
+            if (stop.signal.aborted)
+                return;
+            const next = hold(last.current, org, read);
+            last.current = next.last;
+            setHeld({ org, tier: next.tier, wrong: next.wrong });
+        };
+        readTier(stop.signal).then((got) => settle({ tier: got }), (e) => settle({ wrong: e }));
         return () => stop.abort();
     }, [enabled, nonce, org]);
-    return { tier, wrong, reload: useCallback(() => setNonce((n) => n + 1), []) };
+    return { ...standing(held, org), reload: useCallback(() => setNonce((n) => n + 1), []) };
 }
 /**
  * Whether an organization is its owner's personal one, off IAM's own row.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzo/rooms",
-  "version": "0.1.54",
+  "version": "0.1.56",
   "description": "The workspace rooms — Home, Chat, Inbox, Contacts, Meet, Cal, Drive, Board, Work, Bots — and the frame that holds them, once, for every Hanzo surface.",
   "type": "module",
   "main": "./dist/index.js",