fauna-api 1.0.759 → 1.0.771

package/dist/src/authentification.d.ts

@@ -75,5 +75,7 @@ export declare function allocateBalance(credentials: Credentials, target: ApiKey
 export declare function generateApiKey(credentials: Credentials): Promise<ApiKey>;
 export declare function removeApiKey(credentials: Credentials, apiKey: ApiKey): Promise<boolean>;
 export declare function profile(credentials: Credentials, email: string): Promise<Profile>;
+/** Profiles matching a partial email or name, best first, at most 20. An admin's
+ *  answer carries more; this keeps the profiles. */
 export declare function query(credentials: Credentials, profile: Partial<Profile>): Promise<Profile[]>;
 export declare function editApiKey(credentials: Credentials, apiKey: ApiKey, update: Partial<ApiKey>): Promise<boolean>;

package/dist/src/authentification.js

@@ -299,8 +299,10 @@ export async function profile(credentials, email) {
     }
     return await response.json();
 }
+/** Profiles matching a partial email or name, best first, at most 20. An admin's
+ *  answer carries more; this keeps the profiles. */
 export async function query(credentials, profile) {
-    const response = await fetch(`${Fauna.getURL()}/authentification/query`, {
+    const response = await fetch(`${Fauna.getURL()}/credentials/query`, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
@@ -311,7 +313,8 @@ export async function query(credentials, profile) {
     if (!response.ok) {
         throw new Error(await response.text());
     }
-    return await response.json();
+    const json = await response.json();
+    return Array.isArray(json) ? json : json.accounts;
 }
 export async function editApiKey(credentials, apiKey, update) {
     const response = await fetch(`${Fauna.getURL()}/authentification/api-keys/${encodeURIComponent(apiKey.id)}`, {

package/dist/src/calendar.d.ts

@@ -39,6 +39,10 @@ export type Event = {
     editable: boolean;
     /** Your answer, when you're invited. */
     response?: Answer;
+    /** Where `calendar.event.started` is POSTed as each occurrence starts. Only its calendar's owners see it. */
+    webhook: string | null;
+    /** Signs those deliveries (verify them with `Webhooks.verify`). Only on the `create` or `update` that set `webhook`. */
+    webhookSecret?: string;
     created: Date;
     updated: Date;
 };
@@ -57,6 +61,8 @@ export type Draft = {
     reminder?: number;
     /** Emails to invite. Each gets an invitation. */
     attendees?: string[];
+    /** A URL to POST `calendar.event.started` to as each occurrence starts. A new one gets a new secret; `update` with `''` removes it. */
+    webhook?: string;
 };
 /**
  * Events between `from` and `to` (at most 400 days apart), one per occurrence,

package/dist/src/calendar.js

@@ -9,6 +9,7 @@ const Event = {
             updated: new Date(json.updated),
             source: json.source ?? null,
             attendees: json.attendees ?? [],
+            webhook: json.webhook ?? null,
         };
     },
 };

package/dist/src/cicada/inboxes.d.ts

@@ -31,7 +31,9 @@ export declare function assign(authorization: Credentials | ApiKey, inboxId: str
 export declare function listAccounts(authorization: Credentials | ApiKey, inboxId: string): Promise<InboxAccount[]>;
 /** `dailyLimit` and `spentToday` are dollars per UTC day; at the limit the agent pauses until midnight UTC. */
 /** `reasoning` is one of the text model's catalog tiers, empty for its default; `voiceModel`
- *  is the realtime voice the agent talks with on calls, empty for the catalog's first. */
+ *  is the realtime voice the agent talks with on calls, empty for the catalog's first. With
+ *  `approveOutbound`, the agent's replies to anyone but the owners wait: Fauna texts the draft
+ *  to the owners, and an owner's SEND sends it while any other answer drops it. */
 export type AgentSettings = {
     model: Text;
     reasoning: string;
@@ -39,6 +41,7 @@ export type AgentSettings = {
     instructions: string;
     dailyLimit: number;
     spentToday: number;
+    approveOutbound: boolean;
     enabledAt: Date;
 };
 export declare const AgentSettings: {
@@ -52,6 +55,7 @@ export declare function setAgent(authorization: Credentials | ApiKey, inbox: str
     voiceModel?: Voice;
     instructions: string;
     dailyLimit: number;
+    approveOutbound: boolean;
 }): Promise<AgentSettings>;
 export declare function clearAgent(authorization: Credentials | ApiKey, inbox: string): Promise<void>;
 /**

package/dist/src/cicada/inboxes.js

@@ -66,6 +66,7 @@ export const AgentSettings = {
             instructions: String(json.instructions ?? ''),
             dailyLimit: Number(json.dailyLimit ?? 0),
             spentToday: Number(json.spentToday ?? 0),
+            approveOutbound: Boolean(json.approveOutbound),
             enabledAt: new Date(json.enabledAt),
         };
     },

package/dist/src/groups.d.ts

@@ -87,6 +87,34 @@ export type GroupMatch = {
 export declare const GroupMatch: {
     fromJSON(json: any): GroupMatch;
 };
+/** A group `query` found by its name. A signed in admin also sees its admins'
+ *  emails, how many people are directly in it, and its paid balance, credit and
+ *  debt in dollars; everyone else gets none of those. */
+export type NamedGroup = {
+    id: string;
+    name: string;
+    icon?: string;
+    /** Everyone in it, directly or through a nested group. */
+    memberCount: number;
+    admins?: string[];
+    directCount?: number;
+    balance?: number;
+    credit?: number;
+    debt?: number;
+};
+export declare const NamedGroup: {
+    fromJSON(json: any): NamedGroup;
+};
+/** What `query` found: people with every group they are in, and groups by name.
+ *  Only a signed in admin gets `total`, how many groups there are. */
+export type GroupQuery = {
+    people: GroupMatch[];
+    groups: NamedGroup[];
+    total?: number;
+};
+export declare const GroupQuery: {
+    fromJSON(json: any): GroupQuery;
+};
 /** Which side sent a nesting: `parent` invited the child, whose admins accept;
  *  `child` asked to go inside the parent, whose admins approve. */
 export type NestSide = 'parent' | 'child';
@@ -132,8 +160,11 @@ export declare function create(credentials: Credentials, name: string): Promise<
  *  Each says how you are in it (`through`). */
 export declare function list(authorization: Credentials | ApiKey): Promise<Group[]>;
 /** People matching a partial email or name, best first, each with every group
- *  they are in and how. Only people in at least one group come back. */
-export declare function query(authorization: Credentials | ApiKey, profile: Partial<Profile>): Promise<GroupMatch[]>;
+ *  they are in and how; only people in at least one group come back. And groups
+ *  whose name matches either text, best first: only groups you are in, unless a
+ *  signed in admin asks. An admin finds every group, with its admins and
+ *  balances, and an admin's empty search lists the first 20 groups by name. */
+export declare function query(authorization: Credentials | ApiKey, profile: Partial<Profile>): Promise<GroupQuery>;
 /** Name, icon and member count of groups by id, including groups you are not in.
  *  Unknown ids are left out. */
 export declare function summaries(authorization: Credentials | ApiKey, ids: string[]): Promise<GroupSummary[]>;

package/dist/src/groups.js

@@ -72,6 +72,27 @@ export const GroupMatch = {
         };
     },
 };
+export const NamedGroup = {
+    fromJSON(json) {
+        return {
+            ...GroupSummary.fromJSON(json),
+            ...(Array.isArray(json.admins) ? { admins: json.admins.map(String) } : {}),
+            ...(typeof json.directCount === 'number' ? { directCount: json.directCount } : {}),
+            ...(typeof json.balance === 'number' ? { balance: json.balance } : {}),
+            ...(typeof json.credit === 'number' ? { credit: json.credit } : {}),
+            ...(typeof json.debt === 'number' ? { debt: json.debt } : {}),
+        };
+    },
+};
+export const GroupQuery = {
+    fromJSON(json) {
+        return {
+            people: json.people.map(GroupMatch.fromJSON),
+            groups: json.groups.map(NamedGroup.fromJSON),
+            ...(typeof json.total === 'number' ? { total: json.total } : {}),
+        };
+    },
+};
 export const GroupNest = {
     fromJSON(json) {
         return {
@@ -130,7 +151,10 @@ export async function list(authorization) {
     return (await response.json()).map(Group.fromJSON);
 }
 /** People matching a partial email or name, best first, each with every group
- *  they are in and how. Only people in at least one group come back. */
+ *  they are in and how; only people in at least one group come back. And groups
+ *  whose name matches either text, best first: only groups you are in, unless a
+ *  signed in admin asks. An admin finds every group, with its admins and
+ *  balances, and an admin's empty search lists the first 20 groups by name. */
 export async function query(authorization, profile) {
     const response = await fetch(`${Fauna.getURL()}/groups/query`, {
         method: "POST",
@@ -143,7 +167,7 @@ export async function query(authorization, profile) {
     if (!response.ok) {
         throw new Error(await response.text());
     }
-    return (await response.json()).map(GroupMatch.fromJSON);
+    return GroupQuery.fromJSON(await response.json());
 }
 /** Name, icon and member count of groups by id, including groups you are not in.
  *  Unknown ids are left out. */

package/dist/src/marmot/web.d.ts

@@ -166,18 +166,29 @@ export declare class DomRecorder {
  * 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.
+ *
+ * Every frame the page holds replays as a nested iframe of that frame, which inherits the
+ * sandbox, so a framed page lays out against its own viewport: fixed positions, viewport
+ * units and media queries resolve against the frame, as they did on the host. Nothing
+ * inside the copy can run, so no event there ever reaches this page; the replayer places
+ * each frame's document right after the frame joins the copy.
  */
 export declare class DomReplayer {
     private readonly mount;
     private nodes;
+    private ids;
     private _viewport;
     private iframe;
     private queued;
     private loads;
-    private frameScopes;
-    private scopedSheets;
-    private boxSheet;
     private boxes;
+    /** The box each framed document's node sits in. */
+    private boxOf;
+    /** Boxes built before they joined the copy, so without a document yet. */
+    private unplaced;
+    /** Where the host has each scrolled element, and since when. */
+    private scrolls;
+    private scrollFrame;
     constructor(mount: Element);
     /** Host viewport from the last snapshot / viewport mutation (advisory). */
     getViewport(): {
@@ -207,36 +218,59 @@ export declare class DomReplayer {
      *  `data-fauna-text`, and every other text node follows a `fauna:N` comment. A marker
      *  with no text after it was an empty text node on the host, so one is made here. */
     private bindMarked;
-    /** The document the replay renders into: its iframe's for full documents, else the mount's. */
-    getDocument(): Document;
-    /** Scope inlined frames' styles, mirror hover and focus, and size frame boxes, for a full document's frame. */
-    private restyle;
+    private bind;
+    /** `next` takes over the id `old` was bound to. */
+    private rebind;
+    private reset;
     /**
-     * Inlined frames are divs, so they get an iframe's box: inline block, 300 by 150 and
-     * clipped unless the page says otherwise, their `width`, `height` and `frameborder`
-     * attributes as sizes and border, and the framed document filling them. All at zero
-     * specificity in a sheet of its own, so page CSS wins, like a real iframe's
-     * presentational hints. No nodes join the replay, so ids stay aligned.
+     * A replay's HTML can't hold one document inside another, so an inlined frame's html,
+     * head and body arrive as divs marked `data-fauna-frame`. Every wrapper becomes a frame
+     * box, holding them as the html, head and body they stand for, under the ids they were
+     * bound to. Wrappers come in document order, so a frame's box is in the copy, with its
+     * document, before the frames inside it are unfolded.
      */
-    private frameBoxes;
-    /** Scroll a replayed element, or a framed document's html, to the host's `data-fauna-scroll`. */
-    private applyScroll;
+    private unfold;
+    /** An iframe standing for a frame's wrapper, which never loads anything of its own. */
+    private createBox;
+    /** Insert into `parent`, or, for a frame box, into the framed document it shows. */
+    private insertInto;
     /**
-     * A framed document is inlined into the replay, so its stylesheets would style the
-     * whole copy: a site's `body { background }` repaints the page around its frame. Each
-     * of its sheets goes inside `@scope` at the frame's html div instead. Sheets from other
-     * origins can't be read, so they stay as they are.
+     * Put a box's framed document into the box's own document: its html as the document's
+     * root, and anything else (a placeholder) into a body of its own. A box gets its
+     * document the moment it joins the copy; until then what it shows waits in `content`,
+     * where changes apply all the same.
      */
-    private scopeFrames;
+    private place;
+    /** Give every box that has joined the copy its document, the boxes inside them included. */
+    private settle;
+    /** The copy's document and every framed document in it. */
+    private documents;
+    /** Take a removed node out of the copy, and every id under it, framed documents included. */
+    private drop;
+    /** Keep `el` (a framed document's html for the frame's own scroll) where the host has it. */
+    private scrollTo;
+    /** Whether `el` is where the host has it, after moving it there. */
+    private scrollOnce;
+    /**
+     * A scroll lands only once its document is long enough, which can be after the changes
+     * that grow it, or after its images and fonts load. Once a frame after any change, and
+     * every frame while a recent scroll hasn't landed, scrolls go back where the host has them.
+     */
+    private rescroll;
+    /** The document the replay renders into: its iframe's for full documents, else the mount's. */
+    getDocument(): Document;
     /**
      * `:hover` and `:focus` never apply in a replay. The host marks what they would match
      * with `data-fauna-hover` and the focus attributes, so point those selectors at the
-     * attributes instead; both weigh the same in the cascade. Only a full document's own
-     * frame is rewritten.
+     * attributes instead; both weigh the same in the cascade. Only the copy's own documents
+     * are rewritten: its frame's, and each framed document's.
      */
     private mirrorStates;
     private ownerDoc;
-    /** `seen` keeps a subtree that names a node twice (or itself) from building forever. */
+    /**
+     * `seen` keeps a subtree that names a node twice (or itself) from building forever. SVG
+     * and MathML take their namespace from where they sit, as the HTML parser gives it.
+     */
     private build;
     private buildFromList;
     /** Render a fresh snapshot, replacing whatever the mount currently holds. */
@@ -259,8 +293,8 @@ export declare function pageToHtml(root?: Node): {
 };
 /** 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.
+ *  Framed documents are walked, observed, and re-inlined on navigation, each
+ *  as its own html, head, and body, which viewers replay as a nested frame.
  *  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
@@ -344,7 +378,7 @@ export declare function weightedProgress(stages: {
 export type WebRoomHooks = Partial<{
     /** Host published bootstrap meta — guests should HTTP GET the HTML. */
     onBootstrap(room: WebRoom, bootstrap: BootstrapMeta): void;
-    /** The host published a fresh full-page snapshot (legacy / fallback). */
+    /** The host published a fresh full-page snapshot (fallback). */
     onSnapshot(room: WebRoom, snapshot: WebSnapshot): void;
     /** The host emitted one incremental DOM mutation. */
     onMutation(room: WebRoom, mutation: WebMutation): void;