@agentshouse/mdruntime-adapter 0.1.0-ccda1a2da11c3 → 0.1.0-ccdfb41af2abb

package/AGENTS.md

@@ -1,309 +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, Resolve, 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 an accepted one's or a History revision's, a
-removed file's last included: the first read asks the Provider and the browser keeps the
-bytes, and every later read of that revision, offline too, answers them from the browser.
-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, kept the same way. Both
-answer `{ kind: 'binary', stream, byteLength, mediaType }`, the bytes a `ReadableStream`
-of parts of at most a mebibyte, or a refusal or failure; read the stream to its end, or
-take it whole with `new Response(stream).blob()` where a screen needs one `Blob`.
-
-Rooms, Query, Search, Observe, Types, Room Draft, Save, and Reached never touch the
-network; History, a binary file read the browser does not keep yet 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' | 'inbox', 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. A Room `rooms` names `locked` shows only online.
-
-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, prepared or unlocked, `[{ 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.** Within one Room, `hop: { field, types, where, pathPrefix }` keeps Documents
-  whose reference at pointer `field`, at any depth, points to a matching Document, and
-  `backlinks` with the same keys those a matching Document references, each once. A body
-  link, or a reference declaring `cross_room`, may name another Room's
-  `/rooms/<handle>/<path>`: `resolve(room, path, destination)` answers its `document`, the
-  `deleted` one's last `revision`, or `unreadable` where the App does not bind it or it is
-  locked.
-- **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' | 'inbox', 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 }`: missing
-  and null first, last with `nulls: 'last'`, then numbers and booleans, then text by `locale` or
-  code point with `stringSort: 'lexical'`, then lists item by item; 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, into another Room when it names `room`, 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; moves into another Room, saved alone, are one Change Batch in
-both Rooms' queues. `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/gather.d.ts

@@ -1,4 +0,0 @@
-export declare function gatheredEach<A, R>(send: (asks: readonly A[], answer: (ask: number, result: R) => void) => Promise<void>): (ask: A) => Promise<R>;
-export declare function gathered<A, R>(send: (asks: readonly A[]) => Promise<readonly R[]>): (ask: A) => Promise<R>;
-export declare function selections<T>(items: readonly T[], limit: number): readonly (readonly T[])[];
-//# sourceMappingURL=gather.d.ts.map

package/dist/gather.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gather.d.ts","sourceRoot":"","sources":["../src/gather.ts"],"names":[],"mappings":"AAMA,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,KAAK,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,GACpF,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAwBxB;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,GAClD,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAMxB;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAO3F"}

package/dist/gather.js

@@ -1,35 +0,0 @@
-export function gatheredEach(send) {
-    let held = [];
-    function flush() {
-        const taken = held;
-        held = [];
-        send(taken.map((entry) => entry.ask), (ask, result) => {
-            taken[ask]?.resolve(result);
-        }).catch((reason) => {
-            for (const entry of taken)
-                entry.reject(reason);
-        });
-    }
-    return (ask) => new Promise((resolve, reject) => {
-        if (held.length === 0) {
-            // Asks made in one task wait a single event-loop turn so they leave as one batch.
-            setTimeout(flush, 0);
-        }
-        held.push({ ask, resolve, reject });
-    });
-}
-export function gathered(send) {
-    return gatheredEach(async (asks, answer) => {
-        (await send(asks)).forEach((result, ask) => {
-            answer(ask, result);
-        });
-    });
-}
-export function selections(items, limit) {
-    const size = Math.max(1, limit);
-    const parts = [];
-    for (let start = 0; start < items.length; start += size) {
-        parts.push(items.slice(start, start + size));
-    }
-    return parts;
-}

package/dist/referrer.d.ts

@@ -1,9 +0,0 @@
-import type { ReferrerScope } from '@agentshouse/mdruntime';
-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;
-export declare function houseReferrerScope(referrer: unknown, tracked: ReadonlyMap<string, TrackedAuthority>): ReferrerScope | 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,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,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,CAoBtB;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAC7C,aAAa,GAAG,IAAI,CAOtB"}

package/dist/referrer.js

@@ -1,41 +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 },
-        };
-    }
-    return null;
-}
-export function houseReferrerScope(referrer, tracked) {
-    const held = fields(referrer);
-    if (held !== null && named(held, 'room', 'path')) {
-        return { locator: held.room, path: held.path };
-    }
-    const found = houseReferrer(referrer, tracked);
-    return found === null ? null : { locator: found.locator };
-}