@agentshouse/mdruntime-adapter 0.1.0-cd61dfca5d699 → 0.1.0-cd673d02b6e50

package/AGENTS.md

@@ -1,299 +0,0 @@
-# Instructions for the App Creator's agent
-
-These instructions address an agent in an environment with Git: obtain the App Repository,
-change it, build, and push. They are documentation, not enforcement.
-
-## The MD Runtime API
-
-App code reaches the MD Runtime through the remote client. The surfaces are Rooms,
-Query, Search, Observe, Types, Room Draft, Save, History, the binary file reads, Call,
-Reached, Log, the reported persistence answer, reauthorization, conversation, the chat
-draft, and Presentation State. Sync Status, readiness, the Service Mode, the storage-loss
-statement, the deployment facts and the signed-in member are observations only.
-
-The host attaches each port with its reach, and every member and observation answers
-within it: a Room outside it answers as one the replica does not hold, Rooms lists only
-the Rooms reached whole, a Room reached for single Documents shows only them and their
-models' Types, and without conversations the conversation members, chat draft and
-observation hold none. A changed reach reaches every open observation as its new value.
-
-Every `observe` resolves, once its first value arrived, to a handle: `current()` is the
-latest complete value, `subscribe(listener)` hears each later value whole and returns its
-unsubscribe, and `close()` ends it. Closing the port ends every handle and rejects every
-pending call and observation; a reconnected client observes again.
-
-`observe('agents')` answers every Agent a new conversation can go to, each `{ identity,
-name }`, with a conversation yet or not. Each conversation the Provider lists is held
-complete in the browser. `conversation.list()` and `observe('conversations')` answer each
-with its Agent's identity and name, its name, created and finished times, last outcome,
-live `state` (`asking` while a question waits, `working` while a turn runs, else `idle`)
-and `started`, when the running turn began, or `null`. `observe('conversation', id, {
-limit, total: true })` holds its latest `limit` messages, at most 1,000, oldest first,
-`total` their count, and `next` while older ones exist, which `after` takes, there or in
-`conversation.read(id, { limit, after })`, for the window before; its chat draft; and,
-only in memory, what the Provider streams whether or not anything views it: the running
-`turn` with its parts and its context in use and window, which the message accepted under
-the turn's id replaces, the open questions, the process state, and the CLI's commands and
-options, none stored or searchable. `chatDraft.write` and `chatDraft.discard` keep what
-the App Creator composes, and `chatDraft.prepend(conversation, draft)` puts a returned
-message ahead of it as it stands. Sending it is a Provider Action that needs the Provider
-reachable and is never queued. A new conversation's chat draft is keyed `new:<Agent
-identity>`: no conversation list removes it, a retired Agent's goes, and the first answer
-to `conversation.create({ agent_id, operation_id })` moves it to the created conversation,
-where `conversation.send(conversation)` sends it; a replay of that create moves nothing.
-
-Presentation State is one value per App, kept in the browser and shared by its tabs:
-`presentation.read()` answers it, `null` before anything is kept,
-`observe('presentation')` hears it whole, `presentation.write(value)` replaces it whole,
-and `presentation.edit(members)` sets each member named, or removes one named `null`, in
-the state as it stands, so tabs changing different members never lose each other's change:
-never write back a value read before. Each rejects when the browser does not keep the
-change, and no tab sees it then.
-
-A binary file at a Path is a binary Path entry. Query lists it by `path`, and History each
-of its revisions, with its `binaryFile` record and never its bytes: `{ state: 'accepted',
-revision, path, fileRef, byteLength, mediaType, sha256 }`, or, from a Save until the
-Provider accepts it, `{ state: 'pending', localId, path, byteLength, mediaType, sha256 }`.
-Write one with a Room Draft whose only part is `file: { blob }`, the `Blob`'s `type` its
-media type: Save keeps the bytes in its Pending Change, offline too, and acceptance gives
-the record the Provider's revision. Move or remove one as a Document, a pending one too,
-its bytes following; once its Pending Change has gone to the Provider, Save refuses that
-as `unknown-revision` until it is accepted. `binaryFile.read(room, path, revision?)`
-answers a pending record's saved bytes, or asks the Provider on every read of an accepted
-one or a History revision, a removed file's last included, keeping nothing. Text, a Record
-attachment or a conversation message may name a file by its `fileRef`; read it with
-`binaryFile.readReference({ fileRef, referrer })`, the `referrer` the Provider gave beside
-it, or `{ room, path }` of the document whose text names it. Both answer
-`{ kind: 'binary', blob }` or a refusal or failure.
-
-Rooms, Query, Search, Observe, Types, Room Draft, Save, and Reached never touch the
-network; History, the binary file reads and Call go to the Provider through the Adapter.
-Call takes the Action names the Adapter declares, any other answering `undeclared`. A Call
-result whose effect the Provider places in a Room carries `at`, that Room and Room
-Version: `reached(room, roomVersion)` answers whether the Room's confirmed state has
-reached it, refreshing the Room until it has, and `reached(room, roomVersion, path)`
-whether the held copy of that document was written later. A History revision names its
-author, `{ kind: 'user', id }` or `{ kind: 'site', id, name }`; History of a Path no
-document holds answers the removed document's revisions, newest first, with `deleted:
-true`, which a link to the Path opens. Every member is asynchronous and every result a
-detached snapshot; nothing returns the authorization, performs a request the App's code
-composes, or exposes the browser store.
-
-Every refusal and failure carries `code` and `retryable`: each Call and History answer
-other than its result, a refused Save or Room Draft write, a returned Room Draft's reason,
-a Room's refusal, the Connection Refusal and every error a member rejects with, beside its
-message, a Provider refusal with the Provider's own `retryable`. Every code and value is
-open: handle one you do not know by its `code` and `retryable`. Only a tag telling which
-fields a value carries, such as `kind`, is closed: keep a branch for one you do not know.
-A model with no usable types answers `types: null`.
-
-Read the deployment facts with `observe('deployment-facts')`, an opaque value the host's
-contract interprets. `observe('member')` answers who uses the App, the only way App code
-learns it: the User the Provider signed in, `{ kind: 'user', id, name }` like a change's
-`author`, so a Document whose `change.author.id` is its `id` is that User's own; `null`
-until the Provider first names one, and where it names none, such as a Site. It is kept
-with the Local Replicas, answers offline once known, and every port hears the next member
-named; signing out answers `null`, then ends the observation with the authorization.
-
-## Local Query rules
-
-`query(q)` answers once from local state; `observe('query', q)` holds the whole result and
-hears it again only when it changes, keeping every unchanged Document the same object, so
-a component can tell what changed by identity. `{ documents, coverage }` or `{ groups,
-coverage }` is complete for the Rooms its `coverage` names, and `{ pending }` names each
-Room not yet acquired or prepared, `[{ room, awaits }]`: never read it as empty, draw it
-as loading and observe the query to hear the complete answer. A query is data:
-
-- **Filter.** `rooms` names Room locators and defaults to every Room. `types` names MD
-  Types, and `any` names untyped Markdown Documents. `pathPrefix` is a directory: `notes`
-  keeps `notes/a.md` and not `notes2/a.md`; `folder` keeps only what lies directly in it.
-  `paths` keeps only the Paths it names: read named Documents so, never from a list.
-- **Fields.** Every frontmatter value is named by JSON Pointer: `/status`,
-  `/shipping/city`, `~1` for a `/` and `~0` for a `~` in a key. A segment that meets a
-  list applies to every item and a number names one item. `where` names pointers, ANDs
-  them, and nests `$and` and `$or`; a pointer through a list holds if any item satisfies
-  it. A bare value is equality; the operators are `$eq`, `$ne`, `$in`, `$nin`, `$gt`,
-  `$gte`, `$lt`, `$lte`, `$all`, `$size` and `$exists`. Equality on a list asks if it
-  contains the value. Missing, null and empty differ: `$exists: false` keeps a missing
-  field, `null` an explicit null, `''` empty text and `$size: 0` an empty list. A date
-  compares in calendar order and never with a date-time. A reference compares by the
-  Room Path it resolves to. Untyped frontmatter, and a value under `oneOf` or a
-  conditional, is plain values. There is no text containment or regular expression.
-- **Relations.** `hop: { field, types, where, pathPrefix }` keeps Documents whose
-  reference at pointer `field`, at any depth, points to a matching Document of the same
-  Room. `backlinks: { field, types, where, pathPrefix }` keeps Documents that a matching
-  Document of the same Room references. Each keeps a Document once.
-- **Parts.** A Document query must `select`: `'all'`, or `fields`, `sections`,
-  `preamble`, `markdown`, `backlinks`, `change` and `fileId`, where `fields` is `'all'`
-  or a list of pointers and `sections` `'all'` or a list of names. Selected pointers
-  return the frontmatter holding only them, nested as written. A backlink names the
-  referring Path, MD Type and the pointer it came from as `field`. Room and Path always
-  return; a Markdown Document also returns its MD Type, and at most its first 1,000
-  backlinks: a query on the referring field reads the rest. A non-Markdown Document
-  returns only Room, Path and a selected `fileId`, and a binary Path entry its
-  `binaryFile` record too. An unselected part is absent. Select only what a screen shows:
-  a list that selects the Markdown hears every edit of it.
-- **Change and file ID.** `change` is `{ author, time }` of the Document's head revision
-  as the Provider last delivered it: `author` is `{ kind: 'user' | 'site', id, name }`, or
-  `null` for a write the Provider made itself, and `time` its ISO 8601 change time, or the
-  whole change `null` where it delivered no time, as at a Site. `fileId` is the Provider's
-  Stable File ID of the file at the Path, or `null`. An unsent edit keeps both, an unsent
-  move keeps the change and carries the file ID to the new Path, so a file ID that leaves
-  one Path for another is the same file moved, and an unsent creation has neither until it
-  is Accepted. A Room's last change is its Document with the latest `time`.
-- **Order and groups.** `orderBy` sorts by `room`, `path`, `type`, `folder` or `{ field }`
-  with TanStack DB's own options; ties end with Room, then Path. `groupBy` by `room`,
-  `type`, `folder` or `{ field }` answers `{ groups: [{ key, count }] }`, counted over every
-  match and ordered by `count` or a key. A sort or group takes only a single-value pointer.
-  `limit`, at most 1,000 whatever a query names, bounds the Documents or the groups, and a
-  result it cuts short names `next`: the same query with it as `after` reads the next
-  window, in the same order, ties included. `total: true` adds `total`, every match's
-  count. An observed window hears rows entering, leaving or changing, and `next`, `total`.
-- **Results and errors.** A result carries no Room Version: read freshness from Rooms and
-  Sync Status. `coverage` names each Room read as `{ room, generation, current }`,
-  `current` false while a newer copy of that Room is being fetched, and the queued changes
-  it includes as `overlay`, which a Save in the Room changes. An invalid query fails with
-  `invalid-query`, `unknown-type`, `unknown-field` or `wrong-kind`, never an empty answer.
-
-## Local Search rules
-
-`search({ text, documents, collection, conversations, limit, after, total })` answers
-once, by words, from local state, with MiniSearch's defaults. There is no observed search.
-
-- **Declaration.** Only an App whose release declares Local Search searches, its first
-  readiness waiting for its index; any other App's `search` answers the never retryable
-  `undeclared` refusal `search-undeclared`, its `fields` naming `local_search`.
-- **What is found.** A Document by its field values, its sections' headings and text, its
-  preamble and its Path, and a message by its text, never a frontmatter key, a Room Draft,
-  a chat draft or a running turn's parts, with no phrases, word forms, typo tolerance or
-  prefix matching.
-- **Narrowing.** `documents` is a Local Query filter, and `collection: true` leaves out
-  what each Room's `typedSelection` roots hold; `conversations` names conversations. All
-  apply before `limit`, which bounds each list, at most 1,000 whatever a search names. A
-  complete answer it cuts short names `next`, which `after` takes for the next window of
-  both lists. `total: true` adds `total`, each list's count.
-- **Results.** `{ documents, messages, coverage }`, or the same with `pending` naming each
-  Room or conversation the search still waits for: show its hits, ask again, and never
-  read pending as no hits. `coverage` names the Rooms and conversations searched. Each
-  list is ranked by `score`, comparable only within it; ties come by `room`, then `path`,
-  or by `conversation`, then `identity`. A Document hit names its `room`, `path` and
-  `type`, a message hit its `conversation` and `identity`; `matches` maps each matched
-  word to the parts it matched in: `fields`, `sections`, `preamble`, `path` or `text`. A
-  hit carries no position: mark the words you show. A bad filter fails as a query does.
-
-## Room Draft, Save, and outcome rules
-
-The MD Runtime owns one durable Room Draft per Room and Path, shared by every App and tab
-across reloads; a Room the Provider reports lost takes its Room Drafts and queue with it.
-Write one with `roomDraft.write(room, path, revision, parts)`, naming the revision you
-read or `null`, and every part it now changes: fields, sections and the preamble, or the
-whole Markdown, a creation, a move or a removal. A new part names its base, the value you
-showed when it was opened, a field's as `{ value }` or `null` for no such field, and keeps
-its first base; a binary Path entry's move or removal takes `null`. A write or discard
-from an older revision is refused as `stale` with the current Room Draft.
-
-Save takes one Room and the Room Drafts of it to save, each with its revision, validates
-locally, and on success appends one Change Batch to that Room's queue and removes those
-Room Drafts. Refused as `stale`, `changed-underneath` naming each part whose base no
-longer matches the visible state, or a local validation rule, it creates nothing and
-leaves every Room Draft. A directory move or removal is that part on each Document and
-binary Path entry beneath it, saved together. `saveParts(room, [{ path, parts }])` saves
-parts, each Path once and each new part with its base, the same way but writes no Room
-Draft: one held at a saved Path stays, one at a moved Path moves with it to a destination
-that holds none. Never save by writing back a Room Draft read before.
-
-Outcomes follow the Provider's answer. An Accepted Change Batch stays in the queue, drawn
-over the confirmed layer, until that layer reaches the Room Version it was accepted at.
-Conflicted and Rejected, an expired operation, and a change that no longer applies each
-leave the queue and return as Room Drafts on their Documents, marked with why: the
-Provider's structured refusal code and fields as returned, not known to have applied, or
-withdrawn locally. The rest of the queue keeps synchronizing, and Sync Status requires
-attention until each returned Room Draft is saved or discarded. `observe('queue', room)`
-shows each Pending Change Batch, which keeps no outcome once it leaves. Transport failure,
-Provider unavailability and a refusal marked retryable, until the reset it names, keep
-work Pending; the MD Runtime retries the same Change Batch identity and payload, never
-infers an outcome from transport uncertainty, and never combines, reorders, or rebases.
-
-On a Site, every Save stays in the visitor's browser: write grants and revisions do not
-refuse it, and its Pending Change shows in every query and across reloads until the
-browser's storage is cleared. It is never sent: `observe('queue', room)` shows it `local`,
-Sync Status never waits on it, and once the Room no longer lets it apply it leaves the
-queue and returns no Room Draft.
-
-`observe('service-mode')` answers the Provider's Service Mode, `open` or `write-halted`.
-While writes are halted, Save succeeds, its Change Batch waits unsent and the queue is
-submitted in order once writes reopen; an Action is never held, and one the halt refuses
-returns that refusal: show the Provider as read-only instead of retrying.
-`observe('readiness')` tells whether the App's code and bound Rooms are held locally
-(`ready`), each Room's state, each refused Room's file and rule, the persistence answer
-and a paused preparation's `capacity` cause; `retry()` resumes a paused preparation.
-
-## Content safety and launch promises
-
-The Provider authorization belongs to the Runtime host and is never readable by the App's
-code. The App's code reaches the network only at the external origins its manifest
-declares, empty by default, and the Provider enforces that set. Rendered Markdown never
-executes scripts, renders raw HTML only for the details and summary elements, and loads
-images and other resources only from origins the Provider's policy allows. An agent must
-never read the authorization, load code from a Room, call the Provider directly, or rebase
-a refused Change Batch.
-
-MD UI uses semantic HTML, is fully operable from a keyboard with visible focus and
-labelled controls, and lays out from a 360 pixel wide viewport to a desktop. Its strings
-are English only, dates and numbers follow the browser locale, and content is never
-translated. Light and dark themes come from CSS custom properties, defaulting to the
-browser's preference and respecting an App's override. What an agent adds carries none of
-these promises by itself. Data lives only in the App Creator's browser and the Provider.
-
-## App code takes the client its host hands it and never constructs a Runtime
-
-No module outside an Adapter package imports, names, or special-cases a Provider, and
-every App and MD UI reach data only through the client entry. In House,
-`houseBridge().runtime` from `@agentshouse/app-bridge` resolves to the client House built
-into the page. App code imports only types from `@agentshouse/mdruntime/client`, never
-calls `connectMdRuntime` or `serveMdRuntime`, and never imports the package main, the host
-entry or the Adapter package; the in-memory Adapter at `@agentshouse/mdruntime/memory` is
-for tests and ships in no bundle. A Site's page fills its Entry Data Contract's
-`{"$param": name}` arguments with `boundQuery` from `@agentshouse/mdruntime/entry`, as
-House did for its HTML. While the Site prepares, a query a route's `interaction` names
-answers from the entry's result when the page observes that descriptor, and every other
-stays pending. House replaces its HTML with the page once its document changed after those
-answers, or readiness is `ready`, and then held still for two animation frames, unless the
-visitor uses the HTML: draw the route at once, never behind a placeholder. Before
-readiness is `ready`, `push` loads a new page.
-
-A React App may observe and save through `@agentshouse/mdruntime/react`, with React as a
-peer dependency. `useObserve(client, topic, ...input)` takes the arguments of `observe`
-and returns `{ state: 'loading' }` until the topic's first value arrives, then `{ state:
-'ready', value }`, re-rendering on each change; a `null` client stays loading.
-`useSave(client)` returns `busy`, the last `outcome` or `failure`, and `save(room,
-parts)`, which saves through `saveParts` and rejects with a recorded failure.
-`saveWritten(room, roomDrafts)` saves Room Drafts the App wrote, each named with the
-revision its last write returned: one another tab wrote since is refused as `stale`, and
-nothing is saved. React-admin and Refine Apps use `@agentshouse/mdruntime-families`.
-
-## The Chat
-
-`@agentshouse/mdruntime/chat` holds the Chat, one data layer for every App; add React as a
-dependency in any App, with React DOM and `@assistant-ui/react`. Place the ready chat with
-`<Chat client={runtime} conversation={id} agent={agent} width="1/3" showChats />`:
-`conversation` opens one, `null` for a new chat, `agent` is the Agent a new chat goes to,
-`onOpen` hears each one it opens, and `width` is `full` (the place you give it), or `3/4`,
-`1/2` or `1/3` of the window docked at its right edge, whole on a narrow window.
-`showChats` adds its conversation list; or draw your own inside a `ChatProvider` around a
-`<Chat />` with no `client`. Theme its own styles with CSS custom properties on it or an
-ancestor: `--chat-background`, `--chat-surface`, `--chat-text`, `--chat-text-muted`,
-`--chat-accent`, `--chat-line`, `--chat-attention`, `--chat-danger`, `--chat-font`,
-`--chat-font-mono`, `--chat-font-size`, `--chat-radius` and `--chat-density` (a factor for
-spacing); an unset one keeps House's light or dark look. `mountChat(element, { client })`
-places it outside React, with `update(props)` and `unmount()`.
-
-Mix `ChatMessageList` (`components` takes your `UserMessage` and `AssistantMessage`),
-`ChatInput` and `ChatQuestionCard` with your own design inside a `ChatProvider`, or
-compose assistant-ui's primitives there; `useChat()` gives `send`, the conversations, the
-Agents, questions to `answer`, `options` to `choose`, `commands`, the queue to `edit` or
-`unqueue`, `stop`, `kill` and outcomes; never replace its messages, sending or store. It
-shows a conversation's latest 50 messages, and assistant-ui's `loadEarlier()` the 50
-before, which `ChatMessageList` calls as the reader scrolls back. A secret question is
-never answered here; typed answers live in the Presentation State members named `typed:…`:
-leave them. `Markdown` draws Markdown safely.

package/dist/handed.d.ts

@@ -1,15 +0,0 @@
-import type { HeldRoom, MutationResult } from '@agentshouse/mdruntime';
-import type { HouseScope, HouseView } from './read.js';
-import type { StreamedAdvancement } from './stream.js';
-export type HandedRoom = {
-    roomVersion: string;
-    revisions: ReadonlyMap<string, string>;
-};
-export declare function scopeHanded(scope: HouseScope): HandedRoom;
-export declare function heldHanded(held: HeldRoom): HandedRoom;
-export declare function acceptedHanded(held: HandedRoom, accepted: Extract<MutationResult, {
-    kind: 'accepted';
-}>, roomVersion: string): HandedRoom;
-export declare function enumeratedHanded(view: HouseView, earlier: HandedRoom | undefined): HandedRoom;
-export declare function streamedHanded(held: HandedRoom, advanced: StreamedAdvancement): HandedRoom;
-//# sourceMappingURL=handed.d.ts.map

package/dist/handed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handed.d.ts","sourceRoot":"","sources":["../src/handed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CASzD;AAOD,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAErD;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,OAAO,CAAC,cAAc,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,EACvD,WAAW,EAAE,MAAM,GAClB,UAAU,CAKZ;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,GAAG,SAAS,GAAG,UAAU,CAM7F;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,mBAAmB,GAAG,UAAU,CAM1F"}

package/dist/handed.js

@@ -1,38 +0,0 @@
-import { roomVersion } from './version.js';
-export function scopeHanded(scope) {
-    return {
-        roomVersion: roomVersion(scope),
-        revisions: new Map(scope.files.flatMap(({ path, revision }) => revision === undefined ? [] : [[path, revision]])),
-    };
-}
-function revised(revisions, path, revision) {
-    if (revision === undefined)
-        revisions.delete(path);
-    else
-        revisions.set(path, revision);
-}
-export function heldHanded(held) {
-    return { roomVersion: held.roomVersion, revisions: new Map(Object.entries(held.revisions)) };
-}
-export function acceptedHanded(held, accepted, roomVersion) {
-    const revisions = new Map(held.revisions);
-    for (const [path, revision] of Object.entries(accepted.revisions))
-        revisions.set(path, revision);
-    for (const path of accepted.removals)
-        revisions.delete(path);
-    return { roomVersion, revisions };
-}
-export function enumeratedHanded(view, earlier) {
-    const revisions = new Map(earlier?.revisions);
-    for (const change of view.changes) {
-        revised(revisions, change.path, 'removed' in change ? undefined : change.revision);
-    }
-    return { roomVersion: roomVersion(view), revisions };
-}
-export function streamedHanded(held, advanced) {
-    const revisions = new Map(held.revisions);
-    for (const entry of advanced.entries) {
-        revised(revisions, entry.path, entry.kind === 'removed' ? undefined : entry.revision);
-    }
-    return { roomVersion: advanced.page.roomVersion, revisions };
-}

package/dist/referrer.d.ts

@@ -1,7 +0,0 @@
-import type { TrackedAuthority } from './discovery.js';
-export type HouseReferrer = {
-    locator: string;
-    referrer: Readonly<Record<string, string>>;
-};
-export declare function houseReferrer(referrer: unknown, tracked: ReadonlyMap<string, TrackedAuthority>): HouseReferrer | null;
-//# sourceMappingURL=referrer.d.ts.map

package/dist/referrer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"referrer.d.ts","sourceRoot":"","sources":["../src/referrer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,MAAM,MAAM,aAAa,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAAC;AAgB5F,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAC7C,aAAa,GAAG,IAAI,CAqBtB"}

package/dist/referrer.js

@@ -1,35 +0,0 @@
-function fields(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value)
-        ? value
-        : null;
-}
-function named(held, ...keys) {
-    const present = Object.keys(held);
-    return (present.length === keys.length &&
-        keys.every((key) => typeof held[key] === 'string' && held[key] !== ''));
-}
-export function houseReferrer(referrer, tracked) {
-    const held = fields(referrer);
-    if (held === null)
-        return null;
-    if (named(held, 'room', 'path')) {
-        const entry = tracked.get(held.room);
-        if (entry === undefined)
-            return null;
-        return {
-            locator: entry.locator,
-            referrer: { room_ref: entry.authority, path: held.path },
-        };
-    }
-    if (named(held, 'room_ref', 'record')) {
-        const roomRef = held.room_ref;
-        const entry = [...tracked.values()].find((candidate) => candidate.authority === roomRef);
-        return {
-            locator: entry?.locator ?? roomRef,
-            referrer: { room_ref: roomRef, record: held.record },
-        };
-    }
-    if (named(held, 'message'))
-        return { locator: '', referrer: { message: held.message } };
-    return null;
-}