fauna-api 1.0.686 → 1.0.692

package/dist/src/marmot/web.js

@@ -726,8 +726,9 @@ function frameScopedRule(rule) {
     return `${text.slice(0, open)}{ ${inner.join("\n")} }`;
 }
 /**
- * Re-render a `WebSnapshot` into a target document (typically an isolated iframe
- * or shadow root on the viewer) and apply incoming `WebMutation`s. The replayer
+ * Re-render a shared page into a frame inside `mount` and apply incoming `WebMutation`s.
+ * The page is someone else's, so the frame is sandboxed without scripts: the replayer
+ * writes into it from this page, and nothing the page carries ever runs. The replayer
  * keeps its own id->Node map mirroring the recorder's synthetic ids.
  */
 export class DomReplayer {
@@ -756,8 +757,8 @@ export class DomReplayer {
             writable: true,
             value: null
         });
-        // Mutations that arrive while a full document's frame loads. They follow its
-        // snapshot, so they apply once its ids are bound; a newer snapshot drops them.
+        // Mutations that arrive while a frame loads. They follow its snapshot, so they
+        // apply once its ids are bound; a newer snapshot drops them.
         Object.defineProperty(this, "queued", {
             enumerable: true,
             configurable: true,
@@ -806,64 +807,65 @@ export class DomReplayer {
         return this.mount;
     }
     /**
-     * Apply a full cleaned HTML document (or fragment). Uses an iframe when the
-     * payload looks like a full document so `<html>/<head>/<body>` structure and
-     * DFS ids match the host.
+     * A fresh frame for a replay, loaded with `srcdoc`. Same origin without scripts: this
+     * page can write into it, and the shared page can't run anything there. Null when a
+     * newer replay started while it loaded.
+     */
+    async openFrame(srcdoc, load) {
+        this.queued = [];
+        this.mount.replaceChildren();
+        const iframe = this.mount.ownerDocument.createElement("iframe");
+        iframe.setAttribute("sandbox", "allow-same-origin");
+        iframe.style.cssText = "border:0;width:100%;height:100%;background:#fff;display:block;";
+        this.mount.appendChild(iframe);
+        this.iframe = iframe;
+        try {
+            await new Promise((resolve, reject) => {
+                iframe.onload = () => resolve();
+                iframe.onerror = () => reject(new Error("Failed to load shared page frame."));
+                iframe.srcdoc = srcdoc;
+            });
+        }
+        catch (err) {
+            if (load === this.loads)
+                this.queued = null;
+            throw err;
+        }
+        return load === this.loads ? iframe : null;
+    }
+    flushQueued() {
+        const queued = this.queued ?? [];
+        this.queued = null;
+        for (const mutation of queued)
+            this.mutate(mutation);
+    }
+    /**
+     * Apply a cleaned HTML document, or a fragment, which the frame parses into one.
+     * The `<html>/<head>/<body>` structure and DFS ids match the host's.
      */
     async applyHtml(html, viewport) {
         this.nodes.clear();
         this._viewport = viewport ?? null;
-        const looksFull = /<html[\s>]/i.test(html);
         const load = ++this.loads;
-        if (looksFull) {
-            this.queued = [];
-            this.mount.replaceChildren();
-            const iframe = this.mount.ownerDocument.createElement("iframe");
-            // Scripts/handlers are stripped on the host; keep the frame inert.
-            // No allow-scripts — shared pages must not execute host JS in the guest.
-            iframe.setAttribute("sandbox", "allow-same-origin allow-forms");
-            iframe.style.cssText = "border:0;width:100%;height:100%;background:#fff;display:block;";
-            this.mount.appendChild(iframe);
-            this.iframe = iframe;
-            // Defense in depth: drop scripts that survived capture so Chrome doesn't spam
-            // sandbox console errors (no allow-scripts by design). Script preloads stay as
-            // inert links: the host numbers them, so removing one would shift every id after.
-            const inert = html
-                .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "")
-                .replace(/<script\b[^>]*\/>/gi, "")
-                .replace(/<link\b[^>]*rel=["'][^"']*preload[^"']*["'][^>]*>/gi, (tag) => /\bas=["'](script|module)["']/i.test(tag) || /rel=["']modulepreload["']/i.test(tag)
-                ? tag.replace(/rel=["'][^"']*["']/i, 'rel="fauna-inert"')
-                : tag);
-            try {
-                await new Promise((resolve, reject) => {
-                    iframe.onload = () => resolve();
-                    iframe.onerror = () => reject(new Error("Failed to load shared page frame."));
-                    iframe.srcdoc = inert;
-                });
-            }
-            catch (err) {
-                if (load === this.loads)
-                    this.queued = null;
-                throw err;
-            }
-            if (load !== this.loads)
-                return;
-            this.bindIds();
-            this.restyle();
-            // A textarea shows its text, not its value attribute.
-            for (const field of Array.from(iframe.contentDocument?.querySelectorAll("textarea[value]") ?? [])) {
-                field.value = field.getAttribute("value") ?? "";
-            }
-            const queued = this.queued ?? [];
-            this.queued = null;
-            for (const mutation of queued)
-                this.mutate(mutation);
+        // Drop scripts that survived capture so Chrome doesn't log a sandbox error for each.
+        // Script preloads stay as inert links: the host numbers them, so removing one would
+        // shift every id after.
+        const inert = html
+            .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "")
+            .replace(/<script\b[^>]*\/>/gi, "")
+            .replace(/<link\b[^>]*rel=["'][^"']*preload[^"']*["'][^>]*>/gi, (tag) => /\bas=["'](script|module)["']/i.test(tag) || /rel=["']modulepreload["']/i.test(tag)
+            ? tag.replace(/rel=["'][^"']*["']/i, 'rel="fauna-inert"')
+            : tag);
+        const iframe = await this.openFrame(inert, load);
+        if (!iframe)
             return;
-        }
-        this.queued = null;
-        this.iframe = null;
-        this.mount.innerHTML = html;
         this.bindIds();
+        this.restyle();
+        // A textarea shows its text, not its value attribute.
+        for (const field of Array.from(iframe.contentDocument?.querySelectorAll("textarea[value]") ?? [])) {
+            field.value = field.getAttribute("value") ?? "";
+        }
+        this.flushQueued();
     }
     /** Bind synthetic ids: from the ids a recorded snapshot carries, else in DFS order to
      *  match a recorder that numbers in that order. */
@@ -1056,16 +1058,24 @@ export class DomReplayer {
     ownerDoc() {
         return this.iframe?.contentDocument ?? this.mount.ownerDocument;
     }
-    build(id, map) {
+    /** `seen` keeps a subtree that names a node twice (or itself) from building forever. */
+    build(id, map, seen = new Set()) {
         const spec = map[id];
-        if (!spec)
+        if (!spec || seen.has(id))
             return null;
+        seen.add(id);
         if (spec.kind === "text") {
             const text = this.ownerDoc().createTextNode(spec.text);
             this.nodes.set(id, text);
             return text;
         }
-        const el = this.ownerDoc().createElement(spec.tag);
+        let el;
+        try {
+            el = this.ownerDoc().createElement(spec.tag);
+        }
+        catch {
+            return null;
+        }
         for (const [name, value] of Object.entries(spec.attributes)) {
             try {
                 el.setAttribute(name, value);
@@ -1074,7 +1084,7 @@ export class DomReplayer {
         }
         this.nodes.set(id, el);
         for (const childId of spec.children) {
-            const child = this.build(childId, map);
+            const child = this.build(childId, map, seen);
             if (child)
                 el.appendChild(child);
         }
@@ -1087,16 +1097,20 @@ export class DomReplayer {
         return this.build(node.id, map);
     }
     /** Render a fresh snapshot, replacing whatever the mount currently holds. */
-    apply(snapshot) {
-        this.loads++;
-        this.queued = null;
+    async apply(snapshot) {
         this.nodes.clear();
-        this.iframe = null;
-        this.mount.innerHTML = "";
         this._viewport = snapshot.viewport ?? null;
+        const load = ++this.loads;
+        const iframe = await this.openFrame("<!doctype html><html><head></head><body></body></html>", load);
+        if (!iframe)
+            return;
+        const doc = iframe.contentDocument;
         const root = this.build(snapshot.root, snapshot.nodes);
-        if (root)
-            this.mount.appendChild(root);
+        if (root?.nodeName === "HTML")
+            doc.replaceChild(root, doc.documentElement);
+        else if (root)
+            doc.body.replaceChildren(root);
+        this.flushQueued();
     }
     /** Apply one incremental mutation to the rendered tree. */
     mutate(mutation) {
@@ -1370,6 +1384,11 @@ export function pageToHtml(root = document.documentElement) {
                     wrap.appendChild(frameClone);
                     return wrap;
                 }
+                // The host streams this frame's document into the wrapper itself.
+                if (recorder?.remote(el)) {
+                    wrap.setAttribute("data-fauna-iframe", "remote");
+                    return wrap;
+                }
                 wrap.setAttribute("data-fauna-iframe", "blocked");
                 wrap.setAttribute("style", "display:flex;align-items:center;justify-content:center;min-height:48px;background:#f3f3f3;color:#666;font:12px/1.4 system-ui,sans-serif;border:1px dashed #bbb;");
                 wrap.appendChild(markedText("Embedded frame unavailable in share", recorder?.placeholder(el)));
@@ -1487,10 +1506,18 @@ export function pageToHtml(root = document.documentElement) {
         cssUrls: frozen.urls,
     };
 }
-/** Install a MutationObserver that posts WebMutations to `window[pushName]`.
+/** Install a MutationObserver that posts WebMutations to `window[pushName]` as
+ *  `{ token, mutation }`, so the host knows which recorder sent each one.
  *  Framed documents are walked, observed, and re-inlined on navigation, with
- *  their html, head, and body addressed as the divs `pageToHtml` emits. */
-export function pageInstallRecorder(pushName) {
+ *  their html, head, and body addressed as the divs `pageToHtml` emits.
+ *  With `remoteFrames`, a frame whose document this page can't read is left to
+ *  the host, which streams it from the frame itself: its wrapper says
+ *  `data-fauna-iframe="remote"` and holds nothing. With `framed`, this document
+ *  is such a frame, recorded the way a parent would inline it, and
+ *  `__faunaRecorder.snapshot()` serializes it. */
+export function pageInstallRecorder(pushName, options) {
+    const framed = options.framed === true;
+    const remoteFrames = options.remoteFrames === true;
     const BLOCKED_ATTR_PREFIXES = ["on"];
     const BLOCKED_TAGS = new Set(["SCRIPT", "NOSCRIPT"]);
     const FRAME_TAGS = new Set(["IFRAME", "FRAME", "OBJECT", "EMBED"]);
@@ -1664,7 +1691,7 @@ export function pageInstallRecorder(pushName) {
         if (!node)
             return null;
         if (node.nodeType === Node.DOCUMENT_NODE)
-            return node === document ? null : node.documentElement;
+            return node === document && !framed ? null : node.documentElement;
         return node.nodeType === Node.ELEMENT_NODE ? node : null;
     };
     const scrollOf = (el) => {
@@ -1715,7 +1742,8 @@ export function pageInstallRecorder(pushName) {
         doc.removeEventListener("input", onInput, true);
         doc.removeEventListener("scroll", onScroll, true);
     };
-    const push = window[pushName];
+    const binding = window[pushName];
+    const push = binding ? (mutation) => binding({ token: options.token, mutation }) : undefined;
     const isBlockedAttr = (name) => BLOCKED_ATTR_PREFIXES.some((p) => name.toLowerCase().startsWith(p));
     const idFor = (node) => {
         let id = ids.get(node);
@@ -1735,7 +1763,7 @@ export function pageInstallRecorder(pushName) {
         }
     };
     const frameRootTag = (el) => {
-        if (el.ownerDocument === document)
+        if (el.ownerDocument === document && !framed)
             return "";
         const tag = el.tagName.toLowerCase();
         return tag === "html" || tag === "head" || tag === "body" ? tag : "";
@@ -1784,7 +1812,7 @@ export function pageInstallRecorder(pushName) {
     // node holding its rules, like pageToHtml, so both number the same nodes. Viewers fetch
     // nothing cross origin, and the copy can scope it. A sheet still loading sends its
     // rules when it loads.
-    const isFrameSheet = (el) => el.tagName === "LINK" && el.ownerDocument !== document && /\bstylesheet\b/i.test(el.getAttribute("rel") ?? "");
+    const isFrameSheet = (el) => el.tagName === "LINK" && (el.ownerDocument !== document || framed) && /\bstylesheet\b/i.test(el.getAttribute("rel") ?? "");
     const sheetCss = (link) => {
         try {
             const sheet = link.sheet;
@@ -1936,6 +1964,10 @@ export function pageInstallRecorder(pushName) {
             attributes["data-fauna-iframe"] = "inlined";
             return serializeNode(frame.doc.documentElement, into);
         }
+        if (remoteFrames) {
+            attributes["data-fauna-iframe"] = "remote";
+            return null;
+        }
         attributes["data-fauna-iframe"] = "blocked";
         attributes.style = PLACEHOLDER_STYLE;
         const textId = frame.placeholder ?? nextId++;
@@ -1971,8 +2003,8 @@ export function pageInstallRecorder(pushName) {
             attributes[attr.name] = absoluteAttr(el, attr.name, attr.value);
         }
         if (isFrame) {
-            const children = [serializeFrameContent(watchFrame(el), into, attributes)];
-            into[id] = { id, kind: "element", tag: "div", attributes, children };
+            const content = serializeFrameContent(watchFrame(el), into, attributes);
+            into[id] = { id, kind: "element", tag: "div", attributes, children: content === null ? [] : [content] };
             return id;
         }
         const children = [];
@@ -2010,7 +2042,7 @@ export function pageInstallRecorder(pushName) {
         push?.({ kind: "attribute", id: parent, name: "data-fauna-iframe", value: wrapper["data-fauna-iframe"] ?? null });
         const style = el.getAttribute("style");
         push?.({ kind: "attribute", id: parent, name: "style", value: wrapper.style ?? (style === null ? null : absoluteAttr(el, "style", style)) });
-        const node = map[childId];
+        const node = childId === null ? undefined : map[childId];
         if (node)
             push?.({ kind: "insert", parent, node, subtree: Object.values(map), before: null });
     };
@@ -2040,11 +2072,11 @@ export function pageInstallRecorder(pushName) {
                 if (view?.scrollX || view?.scrollY)
                     scrolledAtInstall.push(frame.doc.documentElement);
             }
-            else
+            else if (!remoteFrames)
                 frame.placeholder = nextId++;
             return;
         }
-        if (el !== document.documentElement && (el.scrollTop || el.scrollLeft))
+        if (el === document.documentElement ? framed && (window.scrollX || window.scrollY) : el.scrollTop || el.scrollLeft)
             scrolledAtInstall.push(el);
         for (const child of Array.from(el.childNodes))
             walkBind(child);
@@ -2063,10 +2095,17 @@ export function pageInstallRecorder(pushName) {
         id: (node) => ids.get(node),
         sheetText: (link) => sheetTexts.get(link),
         placeholder: (el) => frames.get(el)?.placeholder ?? undefined,
+        remote: (el) => remoteFrames && frames.has(el) && !frames.get(el).doc,
+        snapshot: () => {
+            const nodes = {};
+            return { root: serializeNode(document.documentElement, nodes), nodes };
+        },
     };
     const observer = new MutationObserver(handle);
     observer.observe(root, { subtree: true, childList: true, attributes: true, characterData: true });
-    const onResize = () => push?.({ kind: "viewport", width: window.innerWidth, height: window.innerHeight });
+    // A frame's size is its parent's business.
+    const onResize = () => { if (!framed)
+        push?.({ kind: "viewport", width: window.innerWidth, height: window.innerHeight }); };
     window.addEventListener("resize", onResize);
     document.addEventListener("mouseover", onOver, true);
     document.addEventListener("mouseout", onOut, true);

package/dist/src/parrot/room.d.ts

@@ -47,10 +47,11 @@ export type RoomToolState = {
     result?: string;
     /** What a running tool is waiting on, like the machine starting. */
     progress?: string;
-    /** The live room the tool opened, to watch it: a browser, or a machine's desktop, by access code. */
+    /** The live room the tool opened, to watch it: a browser, joined with its access code, or a machine's desktop, joined by reference by the people who may use the machine. */
     session?: {
         kind: "browser" | "desktop";
-        code: string;
+        reference: string;
+        code?: string;
         url?: string;
     };
 };
@@ -96,6 +97,7 @@ export declare class ChatRoom extends Room {
     private _human;
     private _repository;
     private _owner;
+    private _write;
     private _reference;
     private hooks;
     private target;
@@ -112,6 +114,8 @@ export declare class ChatRoom extends Room {
     getSystemPrompt(): string;
     /** True for a people only chat: no model ever replies, so sends never queue. */
     isHuman(): boolean;
+    /** False when you joined with a share link that only lets you read along. */
+    canWrite(): boolean;
     /** The chat's repository, by id. Kept current for everyone in the room. */
     get repository(): number | null;
     /** The saved chat this room is bound to, by id, or null for an unbound room. */

package/dist/src/parrot/room.js

@@ -74,6 +74,12 @@ export class ChatRoom extends Room {
             writable: true,
             value: ""
         });
+        Object.defineProperty(this, "_write", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "_reference", {
             enumerable: true,
             configurable: true,
@@ -134,6 +140,10 @@ export class ChatRoom extends Room {
     isHuman() {
         return this._human;
     }
+    /** False when you joined with a share link that only lets you read along. */
+    canWrite() {
+        return this._write;
+    }
     /** The chat's repository, by id. Kept current for everyone in the room. */
     get repository() {
         return this._repository;
@@ -291,6 +301,7 @@ export class ChatRoom extends Room {
         this._human = state?.chat?.human === true;
         this._repository = typeof state?.chat?.repository === "number" && state.chat.repository > 0 ? state.chat.repository : null;
         this._owner = typeof state?.chat?.owner === "string" ? state.chat.owner : "";
+        this._write = state?.chat?.write !== false;
         this._reference = typeof state?.room?.reference === "string" ? state.room.reference : "";
         this.messages = Array.isArray(state?.messages) ? [...state.messages] : [];
         this.queue = Array.isArray(state?.queue) ? [...state.queue] : [];

package/dist/src/parrot/share.d.ts

@@ -21,12 +21,15 @@ export declare function moveChatToGroup(credentials: Credentials, chatId: string
  * chat (reference becomes `parrot:chat:{chatId}`, billed to the chat's
  * balance-holder) and seed the newest window from durable; omit it for an
  * unbound ephemeral room. `messages` seeds only ephemeral rooms. `share: true`
- * also mints an access code. Returns the room's `reference` (+ `code` when shared).
+ * also mints an access code; people who join with it read along, and with
+ * `write: true` they can send too (replies to them run without the chat's
+ * repository and memories). Returns the room's `reference` (+ `code` when shared).
  */
 export declare function openRoom(authorization: Credentials | ApiKey, options?: {
     chatId?: string;
     messages?: Content[];
     share?: boolean;
+    write?: boolean;
 }): Promise<{
     reference: string;
     roomId: string;

package/dist/src/parrot/share.js

@@ -19,7 +19,9 @@ export async function moveChatToGroup(credentials, chatId, groupId) {
  * chat (reference becomes `parrot:chat:{chatId}`, billed to the chat's
  * balance-holder) and seed the newest window from durable; omit it for an
  * unbound ephemeral room. `messages` seeds only ephemeral rooms. `share: true`
- * also mints an access code. Returns the room's `reference` (+ `code` when shared).
+ * also mints an access code; people who join with it read along, and with
+ * `write: true` they can send too (replies to them run without the chat's
+ * repository and memories). Returns the room's `reference` (+ `code` when shared).
  */
 export async function openRoom(authorization, options = {}) {
     const messages = options.messages ? await serializeTranscript(options.messages) : undefined;
@@ -29,7 +31,7 @@ export async function openRoom(authorization, options = {}) {
             "Content-Type": "application/json",
             "Authorization": "email" in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`,
         },
-        body: JSON.stringify({ chatId: options.chatId, messages, share: options.share }),
+        body: JSON.stringify({ chatId: options.chatId, messages, share: options.share, write: options.write }),
     });
     if (!response.ok)
         throw new Error(await response.text());

package/dist/src/rooms.d.ts

@@ -1,8 +1,11 @@
+import { Fauna } from "../index.js";
 import { ApiKey, Credentials, Profile } from "./authentification.js";
 import { Presence, Room, Hooks as ServerHooks } from "./shared/server.js";
 /** What a member may do: `read` sees the state, `write` can also set it. */
 export type Role = 'read' | 'write';
-/** Who is in a room: every member of a group, or one person by email. */
+/** Who is in a room: everyone in a group, directly or through a nested group, or
+ *  one person by email. A person's room takes groups its owner is in; a group's
+ *  room takes groups nested inside it. */
 export type Member = ({
     group: string;
 } | {
@@ -10,10 +13,12 @@ export type Member = ({
 }) & {
     role: Role;
 };
-/** A live room an app (or a person) owns. Everyone in it sees `state` change live. */
+/** A live room a person or a group owns. Everyone in it sees `state` change live. */
 export type LiveRoom = {
     id: string;
     name: string;
+    /** The group that owns it; absent when a person does. */
+    group?: string;
     members: Member[];
     /** Any JSON, up to 256 KB, always set whole. Fauna never reads it. */
     state: unknown;
@@ -22,39 +27,60 @@ export type LiveRoom = {
     created: Date;
     updated: Date;
 };
+export declare const LiveRoom: {
+    fromJSON(json: any): LiveRoom;
+};
 /** What `create` takes. Every field is optional. */
 export type Draft = {
     name?: string;
+    /** A group you are a direct admin of, to own the room. Without it, you own it. */
+    group?: string;
     members?: Member[];
     state?: unknown;
 };
-/** Someone in a room: their profile, and which of the room's groups they're in. */
+/** One of a room's groups someone is in: `through` is the group's own id when
+ *  they are directly in it, else the nested group they come in through. */
+export type PersonGroup = {
+    id: string;
+    through: string;
+};
+export declare const PersonGroup: {
+    fromJSON(json: any): PersonGroup;
+};
+/** Someone in a room: their profile, and each of the room's groups they're in. */
 export type Person = {
     profile: Profile;
-    groups: string[];
+    groups: PersonGroup[];
+};
+export declare const Person: {
+    fromJSON(json: any): Person;
 };
 /** Room hooks, plus `onState` whenever someone changes the state. */
 export type Hooks = ServerHooks & Partial<{
     onState(room: StateRoom, state: unknown, version: number): void;
 }>;
 /**
- * Make a live room. Signed in with an API key, the key owns it; otherwise you do.
- * Only the owner changes who is in it or deletes it.
+ * Make a live room. You own it, also when you sign with an API key, or with
+ * `draft.group`, that group does: you must be its direct admin. Everyone in an
+ * owner group reads its room, and its admins manage it. Only the owner changes
+ * who is in it or deletes it.
  */
 export declare function create(authorization: Credentials | ApiKey, draft?: Draft): Promise<LiveRoom>;
 /** A room you own or are a member of, with its state. */
 export declare function get(authorization: Credentials | ApiKey, id: string): Promise<LiveRoom>;
-/** Everyone in a room, each group's members listed. Anyone who can read the room. */
+/** Everyone in a room: everyone in its groups (and its owner group), directly or
+ *  through a nested group, and its email members. Anyone who can read the room. */
 export declare function people(authorization: Credentials | ApiKey, id: string): Promise<Person[]>;
-/** Replace who is in a room. Owner only. */
+/** Replace who is in a room. Its owner only: the person, or for a group's room, that group's admins. */
 export declare function setMembers(authorization: Credentials | ApiKey, id: string, members: Member[]): Promise<LiveRoom>;
 /**
- * Replace a room's state; everyone in it sees the change. The owner and writers
- * only. With `ifVersion`, it writes only while the room is still at that version.
+ * Replace a room's state; everyone in it sees the change. The owner (for a
+ * group's room, that group's admins) and writers only. With `ifVersion`, it
+ * writes only while the room is still at that version.
  * Resolves to the new version.
  */
 export declare function setState(authorization: Credentials | ApiKey, id: string, state: unknown, ifVersion?: number): Promise<number>;
-/** Delete a room; everyone in it is disconnected. Owner only. */
+/** Delete a room; everyone in it is disconnected. Its owner only: the person, or for a group's room, that group's admins. */
 export declare function remove(authorization: Credentials | ApiKey, id: string): Promise<void>;
 /** A live room you are in: its state, kept current, and who else is here. */
 export declare class StateRoom extends Room {

package/dist/src/rooms.js

@@ -1,11 +1,41 @@
 import { Fauna } from "../index.js";
 import { Room, connect as connectServer } from "./shared/server.js";
-function hydrate(raw) {
-    return { ...raw, created: new Date(raw.created), updated: new Date(raw.updated) };
-}
+export const LiveRoom = {
+    fromJSON(json) {
+        return {
+            id: String(json.id),
+            name: String(json.name),
+            ...(json.group ? { group: String(json.group) } : {}),
+            members: json.members,
+            state: json.state,
+            version: Number(json.version),
+            created: new Date(json.created),
+            updated: new Date(json.updated),
+        };
+    },
+};
+export const PersonGroup = {
+    fromJSON(json) {
+        return { id: String(json.id), through: String(json.through) };
+    },
+};
+export const Person = {
+    fromJSON(json) {
+        return {
+            profile: {
+                email: String(json.profile.email),
+                ...(json.profile.displayName ? { displayName: String(json.profile.displayName) } : {}),
+                ...(json.profile.icon ? { icon: String(json.profile.icon) } : {}),
+            },
+            groups: json.groups.map(PersonGroup.fromJSON),
+        };
+    },
+};
 /**
- * Make a live room. Signed in with an API key, the key owns it; otherwise you do.
- * Only the owner changes who is in it or deletes it.
+ * Make a live room. You own it, also when you sign with an API key, or with
+ * `draft.group`, that group does: you must be its direct admin. Everyone in an
+ * owner group reads its room, and its admins manage it. Only the owner changes
+ * who is in it or deletes it.
  */
 export async function create(authorization, draft = {}) {
     const response = await fetch(`${Fauna.getURL()}/rooms`, {
@@ -19,7 +49,7 @@ export async function create(authorization, draft = {}) {
     if (!response.ok) {
         throw new Error(await response.text());
     }
-    return hydrate(await response.json());
+    return LiveRoom.fromJSON(await response.json());
 }
 /** A room you own or are a member of, with its state. */
 export async function get(authorization, id) {
@@ -32,9 +62,10 @@ export async function get(authorization, id) {
     if (!response.ok) {
         throw new Error(await response.text());
     }
-    return hydrate(await response.json());
+    return LiveRoom.fromJSON(await response.json());
 }
-/** Everyone in a room, each group's members listed. Anyone who can read the room. */
+/** Everyone in a room: everyone in its groups (and its owner group), directly or
+ *  through a nested group, and its email members. Anyone who can read the room. */
 export async function people(authorization, id) {
     const response = await fetch(`${Fauna.getURL()}/rooms/${encodeURIComponent(id)}/people`, {
         method: "GET",
@@ -45,9 +76,9 @@ export async function people(authorization, id) {
     if (!response.ok) {
         throw new Error(await response.text());
     }
-    return await response.json();
+    return (await response.json()).map(Person.fromJSON);
 }
-/** Replace who is in a room. Owner only. */
+/** Replace who is in a room. Its owner only: the person, or for a group's room, that group's admins. */
 export async function setMembers(authorization, id, members) {
     const response = await fetch(`${Fauna.getURL()}/rooms/${encodeURIComponent(id)}/members`, {
         method: "PUT",
@@ -60,11 +91,12 @@ export async function setMembers(authorization, id, members) {
     if (!response.ok) {
         throw new Error(await response.text());
     }
-    return hydrate(await response.json());
+    return LiveRoom.fromJSON(await response.json());
 }
 /**
- * Replace a room's state; everyone in it sees the change. The owner and writers
- * only. With `ifVersion`, it writes only while the room is still at that version.
+ * Replace a room's state; everyone in it sees the change. The owner (for a
+ * group's room, that group's admins) and writers only. With `ifVersion`, it
+ * writes only while the room is still at that version.
  * Resolves to the new version.
  */
 export async function setState(authorization, id, state, ifVersion) {
@@ -81,7 +113,7 @@ export async function setState(authorization, id, state, ifVersion) {
     }
     return (await response.json()).version;
 }
-/** Delete a room; everyone in it is disconnected. Owner only. */
+/** Delete a room; everyone in it is disconnected. Its owner only: the person, or for a group's room, that group's admins. */
 export async function remove(authorization, id) {
     const response = await fetch(`${Fauna.getURL()}/rooms/${encodeURIComponent(id)}`, {
         method: "DELETE",