@agentshouse/mdruntime 0.1.0-alpha.8 → 0.1.0-c3903a68dcbbf

package/dist/store.js

@@ -1,134 +1,417 @@
-import { requestPersistentStorage } from './durability.js';
+import { sameChange } from './overlay.js';
 const DATABASE = 'mdruntime';
-const REPLICAS = 'replicas';
-const SYNCHRONIZATION = 'synchronization';
-const DISCOVERY = 'discovery';
-const QUEUES = 'queues';
-const DRAFTS = 'drafts';
-const LAST_COMPLETED = 'lastCompleted';
-const GENERATION = 'generation';
-const PROVIDER_LIMITS = 'providerLimits';
-const SCHEMA = 6;
+const ROOMS = 'rooms';
+const DOCUMENTS = 'documents';
+const BINARY_TARGETS = 'binaryTargets';
+const ATTACHMENTS = 'attachments';
+const PENDING_CHANGES = 'pendingChanges';
+const OUTCOMES = 'outcomes';
+const DECLARATIONS = 'declarations';
+const ROOM_DRAFTS = 'roomDrafts';
+const PRESENTATION = 'presentation';
+const CONVERSATIONS = 'conversations';
+const MESSAGES = 'messages';
+const CHAT_DRAFTS = 'chatDrafts';
+const CURRENT = 'current';
+const SCHEMA = 19;
 function settled(request) {
-    return new Promise((resolve, reject)=>{
-        request.onsuccess = ()=>resolve(request.result);
-        request.onerror = ()=>reject(request.error);
+    return new Promise((resolve, reject) => {
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
     });
 }
 function completed(transaction) {
-    return new Promise((resolve, reject)=>{
-        transaction.oncomplete = ()=>resolve();
-        transaction.onerror = ()=>reject(transaction.error);
-        transaction.onabort = ()=>reject(transaction.error);
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error);
+        transaction.onabort = () => reject(transaction.error);
     });
 }
-export async function openReplicaStore() {
-    await requestPersistentStorage();
+const EMPTY_DECLARATIONS = {
+    lastCompleted: null,
+    generation: null,
+    providerLimits: [],
+    capabilities: [],
+    slots: [],
+};
+function declaration(database) {
+    const transaction = database.transaction(DECLARATIONS, 'readonly');
+    return settled(transaction.objectStore(DECLARATIONS).get(CURRENT)).then((record) => record ?? EMPTY_DECLARATIONS);
+}
+function updateDeclaration(database, update) {
+    const transaction = database.transaction(DECLARATIONS, 'readwrite');
+    const store = transaction.objectStore(DECLARATIONS);
+    const prior = store.get(CURRENT);
+    prior.onsuccess = () => {
+        store.put(update(prior.result ?? EMPTY_DECLARATIONS), CURRENT);
+    };
+    return completed(transaction);
+}
+function amendPending(database, locator, id, amendment) {
+    const transaction = database.transaction(PENDING_CHANGES, 'readwrite');
+    const pending = transaction.objectStore(PENDING_CHANGES);
+    const request = pending.get([locator, id]);
+    request.onsuccess = () => {
+        const record = request.result;
+        if (record !== undefined)
+            pending.put({ ...record, ...amendment });
+    };
+    return completed(transaction);
+}
+function roomRecord(record, queue) {
+    const { documents, binaryTargets, revisions, changes, written, attachments, ...room } = record;
+    return { ...room, order: queue.map((batch) => batch.id) };
+}
+function removeRoomEntries(store, locator) {
+    const keys = store.getAllKeys();
+    keys.onsuccess = () => {
+        for (const key of keys.result) {
+            if (Array.isArray(key) && key[0] === locator)
+                store.delete(key);
+        }
+    };
+}
+export function removeRuntimeStore() {
+    return new Promise((resolve, reject) => {
+        const removal = indexedDB.deleteDatabase(DATABASE);
+        removal.onsuccess = () => resolve();
+        removal.onerror = () => reject(removal.error);
+    });
+}
+export async function openRuntimeStore() {
     const opening = indexedDB.open(DATABASE, SCHEMA);
-    opening.onupgradeneeded = ()=>{
+    opening.onupgradeneeded = () => {
         const database = opening.result;
-        for (const name of [
-            ...database.objectStoreNames
-        ])database.deleteObjectStore(name);
-        database.createObjectStore(REPLICAS, {
-            keyPath: 'locator'
-        });
-        database.createObjectStore(SYNCHRONIZATION);
-        database.createObjectStore(DISCOVERY);
-        database.createObjectStore(QUEUES, {
-            keyPath: 'locator'
-        });
-        database.createObjectStore(DRAFTS, {
-            keyPath: [
-                'locator',
-                'path'
-            ]
+        for (const name of [...database.objectStoreNames])
+            database.deleteObjectStore(name);
+        database.createObjectStore(ROOMS, { keyPath: 'locator' });
+        database.createObjectStore(DOCUMENTS, { keyPath: ['locator', 'path'] });
+        database.createObjectStore(BINARY_TARGETS, { keyPath: ['locator', 'path'] });
+        database.createObjectStore(ATTACHMENTS, { keyPath: ['locator', 'reference'] });
+        database.createObjectStore(PENDING_CHANGES, { keyPath: ['locator', 'id'] });
+        const outcomes = database.createObjectStore(OUTCOMES, { keyPath: 'id' });
+        outcomes.createIndex('locator', 'locator');
+        database.createObjectStore(DECLARATIONS);
+        database.createObjectStore(ROOM_DRAFTS, { keyPath: ['locator', 'path'] });
+        database.createObjectStore(PRESENTATION, { keyPath: 'app' });
+        database.createObjectStore(CONVERSATIONS, { keyPath: 'conversation' });
+        const messages = database.createObjectStore(MESSAGES, {
+            keyPath: ['conversation', 'identity'],
         });
+        messages.createIndex('conversation', 'conversation');
+        database.createObjectStore(CHAT_DRAFTS, { keyPath: 'conversation' });
     };
     const database = await settled(opening);
     return {
-        async all () {
-            const transaction = database.transaction(REPLICAS, 'readonly');
-            return settled(transaction.objectStore(REPLICAS).getAll());
+        async all() {
+            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS], 'readonly');
+            const [rooms, documents, targets, attachments] = await Promise.all([
+                settled(transaction.objectStore(ROOMS).getAll()),
+                settled(transaction.objectStore(DOCUMENTS).getAll()),
+                settled(transaction.objectStore(BINARY_TARGETS).getAll()),
+                settled(transaction.objectStore(ATTACHMENTS).getAll()),
+            ]);
+            const byRoom = new Map();
+            for (const { order, ...room } of rooms) {
+                byRoom.set(room.locator, {
+                    ...room,
+                    documents: {},
+                    revisions: {},
+                    changes: {},
+                    written: {},
+                    binaryTargets: [],
+                    attachments: [],
+                });
+            }
+            const head = (room, held) => {
+                if (held.revision !== null) {
+                    room.revisions[held.path] = held.revision;
+                }
+                if (held.change !== null) {
+                    room.changes[held.path] = held.change;
+                }
+            };
+            for (const document of documents) {
+                const room = byRoom.get(document.locator);
+                if (room === undefined)
+                    continue;
+                room.documents[document.path] = document.content;
+                if (document.written !== null) {
+                    room.written[document.path] = document.written;
+                }
+                head(room, document);
+            }
+            for (const target of targets) {
+                const room = byRoom.get(target.locator);
+                if (room === undefined)
+                    continue;
+                room.binaryTargets.push(target.path);
+                head(room, target);
+            }
+            for (const { locator, ...attachment } of attachments) {
+                const room = byRoom.get(locator);
+                if (room === undefined)
+                    continue;
+                room.attachments.push(attachment);
+            }
+            return [...byRoom.values()];
         },
-        async publish (record) {
-            const transaction = database.transaction(REPLICAS, 'readwrite');
-            transaction.objectStore(REPLICAS).put(record);
+        async write({ next, previous, queue, previousQueue, saved, outcomes, roomDrafts, consumedRoomDrafts, }) {
+            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, PENDING_CHANGES, OUTCOMES, ROOM_DRAFTS], 'readwrite');
+            transaction.objectStore(ROOMS).put(roomRecord(next, queue));
+            const documents = transaction.objectStore(DOCUMENTS);
+            for (const path of Object.keys(previous?.documents ?? {})) {
+                if (next.documents[path] === undefined)
+                    documents.delete([next.locator, path]);
+            }
+            for (const [path, content] of Object.entries(next.documents)) {
+                if (previous?.documents[path] === content &&
+                    previous.revisions[path] === next.revisions[path] &&
+                    previous.written[path] === next.written[path] &&
+                    sameChange(previous.changes[path], next.changes[path]))
+                    continue;
+                documents.put({
+                    locator: next.locator,
+                    path,
+                    content,
+                    revision: next.revisions[path] ?? null,
+                    change: next.changes[path] ?? null,
+                    written: next.written[path] ?? null,
+                });
+            }
+            const targets = transaction.objectStore(BINARY_TARGETS);
+            const beforeTargets = new Set(previous?.binaryTargets ?? []);
+            const afterTargets = new Set(next.binaryTargets);
+            for (const path of beforeTargets) {
+                if (!afterTargets.has(path))
+                    targets.delete([next.locator, path]);
+            }
+            for (const path of afterTargets) {
+                if (!beforeTargets.has(path) ||
+                    previous?.revisions[path] !== next.revisions[path] ||
+                    !sameChange(previous?.changes[path], next.changes[path])) {
+                    targets.put({
+                        locator: next.locator,
+                        path,
+                        revision: next.revisions[path] ?? null,
+                        change: next.changes[path] ?? null,
+                    });
+                }
+            }
+            const attachments = transaction.objectStore(ATTACHMENTS);
+            const held = new Map((previous?.attachments ?? []).map((attachment) => [attachment.reference, attachment]));
+            const declared = new Set(next.attachments.map((attachment) => attachment.reference));
+            for (const reference of held.keys()) {
+                if (!declared.has(reference))
+                    attachments.delete([next.locator, reference]);
+            }
+            for (const attachment of next.attachments) {
+                if (held.get(attachment.reference) === attachment)
+                    continue;
+                attachments.put({ ...attachment, locator: next.locator });
+            }
+            if (previousQueue !== undefined) {
+                const pending = transaction.objectStore(PENDING_CHANGES);
+                const before = new Set(previousQueue.map((batch) => batch.id));
+                const after = new Set(queue.map((batch) => batch.id));
+                for (const id of before) {
+                    if (!after.has(id))
+                        pending.delete([next.locator, id]);
+                }
+                for (const batch of queue) {
+                    if (!before.has(batch.id)) {
+                        pending.put({
+                            locator: next.locator,
+                            id: batch.id,
+                            batch,
+                            drafts: saved ?? [],
+                            submission: { state: 'waiting' },
+                            lost: false,
+                        });
+                    }
+                }
+            }
+            const outcomeStore = transaction.objectStore(OUTCOMES);
+            for (const entry of outcomes ?? []) {
+                if (entry.outcome === null)
+                    outcomeStore.delete(entry.id);
+                else
+                    outcomeStore.put({ locator: next.locator, id: entry.id, outcome: entry.outcome });
+            }
+            const draftStore = transaction.objectStore(ROOM_DRAFTS);
+            for (const path of consumedRoomDrafts ?? [])
+                draftStore.delete([next.locator, path]);
+            for (const record of roomDrafts ?? [])
+                draftStore.put(record);
             await completed(transaction);
         },
-        async lastCompleted () {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readonly');
-            const value = await settled(transaction.objectStore(SYNCHRONIZATION).get(LAST_COMPLETED));
-            return value ?? null;
-        },
-        async complete (at) {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readwrite');
-            transaction.objectStore(SYNCHRONIZATION).put(at, LAST_COMPLETED);
+        async revokeModels(records) {
+            const transaction = database.transaction(ROOMS, 'readwrite');
+            const rooms = transaction.objectStore(ROOMS);
+            const revoked = { status: 'unavailable', reason: 'revoked' };
+            for (const { record, queue } of records) {
+                rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }, queue));
+            }
             await completed(transaction);
         },
-        async providerLimits () {
-            const transaction = database.transaction(DISCOVERY, 'readonly');
-            const value = await settled(transaction.objectStore(DISCOVERY).get(PROVIDER_LIMITS));
-            return value ?? [];
+        async lastCompleted() {
+            return (await declaration(database)).lastCompleted;
         },
-        async declare (limits) {
-            const transaction = database.transaction(DISCOVERY, 'readwrite');
-            transaction.objectStore(DISCOVERY).put(limits, PROVIDER_LIMITS);
-            await completed(transaction);
+        complete(at) {
+            return updateDeclaration(database, (record) => ({ ...record, lastCompleted: at }));
         },
-        async queues () {
-            const transaction = database.transaction(QUEUES, 'readonly');
-            return settled(transaction.objectStore(QUEUES).getAll());
+        async providerLimits() {
+            return (await declaration(database)).providerLimits;
         },
-        async drafts () {
-            const transaction = database.transaction(DRAFTS, 'readonly');
-            return settled(transaction.objectStore(DRAFTS).getAll());
+        async capabilities() {
+            return (await declaration(database)).capabilities;
         },
-        async keep (draft) {
-            const transaction = database.transaction(DRAFTS, 'readwrite');
-            transaction.objectStore(DRAFTS).put(draft);
-            await completed(transaction);
+        async slots() {
+            return (await declaration(database)).slots;
         },
-        async discard (locator, path) {
-            const transaction = database.transaction(DRAFTS, 'readwrite');
-            transaction.objectStore(DRAFTS).delete([
-                locator,
-                path
+        declare(limits, capabilities, slots) {
+            return updateDeclaration(database, (record) => ({
+                ...record,
+                providerLimits: limits,
+                capabilities,
+                slots,
+            }));
+        },
+        async queues() {
+            const transaction = database.transaction([ROOMS, PENDING_CHANGES], 'readonly');
+            const [rooms, pending] = await Promise.all([
+                settled(transaction.objectStore(ROOMS).getAll()),
+                settled(transaction.objectStore(PENDING_CHANGES).getAll()),
             ]);
+            const byId = new Map(pending.map((record) => [`${record.locator}\0${record.id}`, record]));
+            return rooms.map((room) => ({
+                locator: room.locator,
+                pending: room.order.map((id) => {
+                    const record = byId.get(`${room.locator}\0${id}`);
+                    if (record === undefined)
+                        throw new Error(`Missing Pending Change ${room.locator}/${id}`);
+                    const { batch, drafts, submission, lost, upload } = record;
+                    return { batch, state: { drafts, submission, lost, upload } };
+                }),
+            }));
+        },
+        async outcomes() {
+            const transaction = database.transaction(OUTCOMES, 'readonly');
+            return settled(transaction.objectStore(OUTCOMES).getAll());
+        },
+        submit(locator, id, submission, lost) {
+            return amendPending(database, locator, id, { submission, lost });
+        },
+        keepUpload(locator, id, upload) {
+            return amendPending(database, locator, id, { upload });
+        },
+        async roomDrafts() {
+            const transaction = database.transaction(ROOM_DRAFTS, 'readonly');
+            return settled(transaction.objectStore(ROOM_DRAFTS).getAll());
+        },
+        async presentation() {
+            const transaction = database.transaction(PRESENTATION, 'readonly');
+            return settled(transaction.objectStore(PRESENTATION).getAll());
+        },
+        async present(record) {
+            const transaction = database.transaction(PRESENTATION, 'readwrite');
+            transaction.objectStore(PRESENTATION).put(record);
             await completed(transaction);
         },
-        async append (queue, consumed) {
-            const transaction = database.transaction([
-                QUEUES,
-                DRAFTS
-            ], 'readwrite');
-            transaction.objectStore(QUEUES).put(queue);
-            const drafts = transaction.objectStore(DRAFTS);
-            for (const path of consumed)drafts.delete([
-                queue.locator,
-                path
+        async conversations() {
+            const transaction = database.transaction([CONVERSATIONS, MESSAGES], 'readonly');
+            const [reads, messages] = await Promise.all([
+                settled(transaction.objectStore(CONVERSATIONS).getAll()),
+                settled(transaction.objectStore(MESSAGES).getAll()),
             ]);
+            const held = new Map();
+            for (const { conversation, read } of reads) {
+                held.set(conversation, { conversation, read, messages: [] });
+            }
+            for (const { conversation, ...message } of messages) {
+                const entry = held.get(conversation) ?? { conversation, read: undefined, messages: [] };
+                entry.messages.push(message);
+                held.set(conversation, entry);
+            }
+            return [...held.values()];
+        },
+        async keepMessages({ conversation, messages, read, sealed }) {
+            const transaction = database.transaction([CONVERSATIONS, MESSAGES, CHAT_DRAFTS], 'readwrite');
+            const stored = transaction.objectStore(MESSAGES);
+            for (const message of messages) {
+                stored.put({ ...message, conversation });
+            }
+            if (read !== undefined) {
+                transaction
+                    .objectStore(CONVERSATIONS)
+                    .put({ conversation, read });
+            }
+            if (sealed === true)
+                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
+            await completed(transaction);
+        },
+        async dropConversations(conversations) {
+            const transaction = database.transaction([CONVERSATIONS, MESSAGES, CHAT_DRAFTS], 'readwrite');
+            const messages = transaction.objectStore(MESSAGES);
+            for (const conversation of conversations) {
+                transaction.objectStore(CONVERSATIONS).delete(conversation);
+                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
+                const keys = messages.index('conversation').getAllKeys(conversation);
+                keys.onsuccess = () => {
+                    for (const key of keys.result)
+                        messages.delete(key);
+                };
+            }
+            await completed(transaction);
+        },
+        async chatDrafts() {
+            const transaction = database.transaction(CHAT_DRAFTS, 'readonly');
+            return settled(transaction.objectStore(CHAT_DRAFTS).getAll());
+        },
+        async keepChatDraft(record) {
+            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
+            transaction.objectStore(CHAT_DRAFTS).put(record);
             await completed(transaction);
         },
-        async writeQueue (queue) {
-            const transaction = database.transaction(QUEUES, 'readwrite');
-            transaction.objectStore(QUEUES).put(queue);
+        async dropChatDraft(conversation) {
+            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
+            transaction.objectStore(CHAT_DRAFTS).delete(conversation);
             await completed(transaction);
         },
-        async generation () {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readonly');
-            const value = await settled(transaction.objectStore(SYNCHRONIZATION).get(GENERATION));
-            return value ?? null;
+        async keepRoomDraft(record) {
+            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
+            transaction.objectStore(ROOM_DRAFTS).put(record);
+            await completed(transaction);
+        },
+        async discardRoomDraft(locator, path) {
+            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
+            transaction.objectStore(ROOM_DRAFTS).delete([locator, path]);
+            await completed(transaction);
         },
-        async rememberGeneration (value) {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readwrite');
-            transaction.objectStore(SYNCHRONIZATION).put(value, GENERATION);
+        async dropRooms(locators) {
+            const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, PENDING_CHANGES, OUTCOMES, ROOM_DRAFTS], 'readwrite');
+            for (const locator of locators) {
+                transaction.objectStore(ROOMS).delete(locator);
+                for (const name of [DOCUMENTS, BINARY_TARGETS, ATTACHMENTS, PENDING_CHANGES, ROOM_DRAFTS]) {
+                    removeRoomEntries(transaction.objectStore(name), locator);
+                }
+                const outcomes = transaction.objectStore(OUTCOMES);
+                const ids = outcomes.index('locator').getAllKeys(locator);
+                ids.onsuccess = () => {
+                    for (const id of ids.result)
+                        outcomes.delete(id);
+                };
+            }
             await completed(transaction);
         },
-        close () {
+        async generation() {
+            return (await declaration(database)).generation;
+        },
+        rememberGeneration(value) {
+            return updateDeclaration(database, (record) => ({ ...record, generation: value }));
+        },
+        close() {
             database.close();
-        }
+        },
     };
 }
-
-//# sourceMappingURL=store.js.map

package/dist/transfer.d.ts

@@ -1,5 +1,10 @@
+import type { Refusal } from '@agentshouse/mdmodel';
 export type Unconfirmed = {
     kind: 'unconfirmed';
 };
+export type Refused = {
+    kind: 'refused';
+    refusal: Refusal;
+};
 export declare const unconfirmed: Unconfirmed;
 //# sourceMappingURL=transfer.d.ts.map

package/dist/transfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../src/transfer.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC;AAElD,eAAO,MAAM,WAAW,EAAE,WAAqC,CAAC"}
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../src/transfer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC;AAElD,MAAM,MAAM,OAAO,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAE5D,eAAO,MAAM,WAAW,EAAE,WAAqC,CAAC"}

package/dist/transfer.js

@@ -1,5 +1 @@
-export const unconfirmed = {
-    kind: 'unconfirmed'
-};
-
-//# sourceMappingURL=transfer.js.map
+export const unconfirmed = { kind: 'unconfirmed' };

package/dist/wire.d.ts

@@ -0,0 +1,64 @@
+import type { ConnectionRefusal } from './connection.js';
+export declare const RUNTIME_WIRE_PROTOCOL = 8;
+export declare const PROTOCOL_MISMATCH: ConnectionRefusal;
+export type RuntimePort = {
+    postMessage(message: unknown): void;
+    addEventListener(type: 'message' | 'close', listener: (event: {
+        data?: unknown;
+    }) => void): void;
+    start(): void;
+};
+declare const MEMBERS: readonly ['rooms', 'slots', 'query', 'search', 'types', 'syncStatus', 'serviceMode', 'save', 'outcome', 'history', 'call', 'reached', 'log', 'storageLoss', 'persistence', 'deploymentFacts', 'reauthorize', 'roomDraft.list', 'roomDraft.read', 'roomDraft.write', 'roomDraft.discard', 'presentation.read', 'presentation.write', 'conversation.list', 'conversation.read', 'conversation.create', 'conversation.send', 'conversation.answer', 'conversation.interrupt', 'conversation.kill', 'conversation.cancel', 'conversation.delete', 'chatDraft.write', 'chatDraft.discard'];
+declare const TOPICS: readonly ['rooms', 'connection-refusal', 'storage-loss', 'deployment-facts', 'sync-status', 'service-mode', 'query', 'queue', 'room-drafts', 'presentation', 'conversation'];
+export type WireMember = (typeof MEMBERS)[number];
+export type WireTopic = (typeof TOPICS)[number];
+export type WireRequest = {
+    kind: 'hello';
+} | {
+    kind: 'call';
+    id: number;
+    member: WireMember;
+    input: readonly unknown[];
+} | {
+    kind: 'observe';
+    id: number;
+    topic: WireTopic;
+    input: readonly unknown[];
+} | {
+    kind: 'stop';
+    id: number;
+};
+export type WireAnswer = {
+    kind: 'result';
+    id: number;
+    value: unknown;
+} | {
+    kind: 'failure';
+    id: number;
+    message: string;
+} | {
+    kind: 'event';
+    id: number;
+    value: unknown;
+} | {
+    kind: 'refusal';
+    refusal: ConnectionRefusal;
+} | {
+    kind: 'ended';
+};
+export declare const AUTHORIZATION_ENDED = "the host authorization ended";
+export declare const PORT_CLOSED = "the port closed";
+export type WireEnvelope = {
+    mdRuntime: number;
+    message: WireRequest | WireAnswer;
+};
+export type Carried = {
+    matching: boolean;
+    message: unknown;
+};
+export declare function envelope(message: WireRequest | WireAnswer): WireEnvelope;
+export declare function carried(data: unknown): Carried | null;
+export declare function request(message: unknown): WireRequest | null;
+export declare function answer(message: unknown): WireAnswer | null;
+export {};
+//# sourceMappingURL=wire.d.ts.map

package/dist/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../src/wire.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,eAAO,MAAM,iBAAiB,EAAE,iBAI/B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACpC,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IACjG,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAEF,QAAA,MAAM,OAAO,YACX,OAAO,EACP,OAAO,EACP,OAAO,EACP,QAAQ,EACR,OAAO,EACP,YAAY,EACZ,aAAa,EACb,MAAM,EACN,SAAS,EACT,SAAS,EACT,MAAM,EACN,SAAS,EACT,KAAK,EACL,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,EACrB,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,CACX,CAAC;AAEX,QAAA,MAAM,MAAM,YACV,OAAO,EACP,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,cAAc,EACd,OAAO,EACP,OAAO,EACP,aAAa,EACb,cAAc,EACd,cAAc,CACN,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAClD,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhD,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,SAAS,OAAO,EAAE,CAAA;CAAE,GAC3E;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,SAAS,OAAO,EAAE,CAAA;CAAE,GAC5E;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjC,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,iBAAiB,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAEtB,eAAO,MAAM,mBAAmB,iCAAiC,CAAC;AAElE,eAAO,MAAM,WAAW,oBAAoB,CAAC;AAE7C,MAAM,MAAM,YAAY,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,WAAW,GAAG,UAAU,CAAA;CAAE,CAAC;AAEpF,MAAM,MAAM,OAAO,GAAG;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AAE9D,wBAAgB,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,GAAG,YAAY,CAExE;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAIrD;AAQD,wBAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAyB5D;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CAe1D"}