@agentshouse/app-bridge 0.1.0-cfbb4f5408379 → 0.1.0-cff4298f6ded6

package/README.md

@@ -42,9 +42,8 @@ async function manageSecurity(securityPath) {
 
 `bridge.runtime` resolves to the `MdRuntimeClient` of `@agentshouse/mdruntime/client`,
 whose README describes its members. Its `call(method, params)` is a remote procedure call
-to House, such as `call('member.list', { room_ref })`: `HouseMethods` names each method,
-the House act's name, with the `params` the App sends and the `result` House returns.
-`HouseParams<Name>` is a method's params and `HouseResult<Name>` what its call resolves with.
+to a House act, such as `call('member.list', { room_ref })`: `HouseMethods` names each
+with its `params`, `HouseParams<Name>`, and its `result`, `HouseResult<Name>`.
 
 ## Test without a House
 

package/dist/calls.d.ts

@@ -170,6 +170,22 @@ export interface HouseMethods {
             readonly url: string;
         };
     };
+    readonly 'conversation.retry': {
+        readonly params: {
+            readonly conversation_id: string;
+            readonly operation_id: string;
+            readonly message_id: string;
+        };
+        readonly result: {
+            readonly conversation_id: string;
+            readonly agent_id: string;
+            readonly message_id: string;
+            readonly authority: string;
+            readonly position: string;
+            readonly log_epoch: string;
+            readonly url: string;
+        };
+    };
     readonly 'conversation.send': {
         readonly params: {
             readonly conversation: string;

package/dist/mdmodel/document.d.ts

@@ -9,7 +9,7 @@ export declare function relinkBody(body: string, file: string, moves: ReadonlyMa
 export declare function links(document: Document, file: string): readonly Link[];
 export declare function linkOccurrences(document: Document, file: string): readonly LinkOccurrence[];
 export declare function bodyLinks(body: string, file: string): readonly Link[];
-export declare function apply(document: Document, change: Change): ApplyResult;
+export declare function apply(document: Document, changes: readonly Change[]): ApplyResult;
 export declare function serialize(document: Document): string;
 export declare function fieldStart(document: Document, pointer: string): number | undefined;
 export declare function frontmatter(document: Document): YamlMap | null;

package/dist/mdmodel/index.d.ts

@@ -12,7 +12,7 @@ export { references } from './references.js';
 export { ARRAY_INDEX, ATTACHMENT, crossedFacts, escapePointer, itemFacts, memberFacts, pointerFacts, pointerSegments, } from './definition.js';
 export type { Definition, FieldRules, JsonType, PatternFacts, PointerFacts, RuleValue, SectionSpec, Shape, Transition, ValueFacts, } from './definition.js';
 export type { ApplyResult, BodyResult, Change, Division, DivisionContext, Document, DocumentCheck, Frontmatter, FrontmatterResult, Library, ModelVerification, Link, LinkOccurrence, ParseResult, Projection, ProjectionContext, Reached, Reference, Refusal, Span, Validation, ValidationContext, VerifiedModel, } from './types.js';
-export { checkDocument, resolves, sectionReferences, validate, verify } from './validate.js';
+export { checkDocument, resolves, sectionReferences, validate, validating, verify, } from './validate.js';
 export { VERSION } from './version.js';
 export { bodyAfterFrontmatter, equalValue, frontmatterValue } from './yaml.js';
 export type { FrontmatterValue } from './yaml.js';

package/dist/mdmodel/project.d.ts

@@ -15,6 +15,7 @@ export type InputResult = {
     readonly ok: false;
     readonly refusal: Refusal;
 };
+export declare function firstEditFrom(edits: readonly Edit[], start: number): number;
 export declare function rangeText(content: string, range: Extent, edits: readonly Edit[]): string;
 export declare function projectionInput(document: Document, file: string, context: ProjectionContext): InputResult;
 export declare function project(document: Document, file: string, context?: ProjectionContext): Projection;

package/dist/mdmodel/types.d.ts

@@ -130,6 +130,7 @@ export type ApplyResult = {
 } | {
     readonly outcome: 'stale';
     readonly document: Document;
+    readonly stale: readonly number[];
 } | {
     readonly outcome: 'refuse';
     readonly refusal: Refusal;

package/dist/mdmodel/validate.d.ts

@@ -4,4 +4,5 @@ export declare function resolves(reference: Reached, typeOf: (path: string) => s
 export declare function verify(schema: string): ModelVerification;
 export declare function checkDocument(file: string, content: string, model: VerifiedModel): DocumentCheck;
 export declare function sectionReferences(file: string, content: string, definition: Definition): readonly Reached[];
+export declare function validating(library: Library, context?: ValidationContext, model?: VerifiedModel): Generator<string, Validation, void>;
 export declare function validate(library: Library, context?: ValidationContext, model?: VerifiedModel): Validation;

package/dist/mdruntime/adapter.d.ts

@@ -162,6 +162,18 @@ export type ConversationEvent = {
     kind: 'options';
     conversation: string;
     options: readonly SessionOption[];
+} | {
+    kind: 'starting';
+    conversation: string;
+    step: string | null;
+} | {
+    kind: 'link';
+    conversation: string;
+    connected: boolean;
+} | {
+    kind: 'deliveries';
+    conversation: string;
+    unknown: readonly string[];
 } | {
     kind: 'accepted-message';
     conversation: string;

package/dist/mdruntime/change-set.d.ts

@@ -23,12 +23,15 @@ export type ChangeSet = {
     messages: readonly MessageChange[];
     conversations: readonly string[];
 };
-export declare function changeSet(locator: string, before: Replica | null, after: Replica | null, changed?: {
+type Changed = {
     drafts?: readonly string[];
     room?: boolean;
     queue?: boolean;
     presentation?: string;
-}): ChangeSet;
+};
+export declare function changeSet(locator: string, before: Replica | null, after: Replica | null, changed?: Changed): ChangeSet;
+export declare function changing(locator: string, before: Replica | null, after: Replica | null, changed?: Changed): Generator<number, ChangeSet, void>;
 export declare function entering(locator: string, replica: Replica, paths: readonly string[]): ChangeSet;
 export declare function conversationChangeSet(messages: readonly MessageChange[], conversations: readonly string[]): ChangeSet;
 export declare function mergeChangeSets(sets: readonly ChangeSet[]): ChangeSet;
+export {};

package/dist/mdruntime/collection.d.ts

@@ -19,11 +19,12 @@ export type Composition = {
 };
 export declare function governing(composition: Composition, path: string): ModelState;
 export declare function collectionOf(text: Readonly<Record<string, string>>, composition: Composition, previous?: Collection): Collection;
+export declare function collecting(text: Readonly<Record<string, string>>, composition: Composition, previous?: Collection): Generator<number, Collection, void>;
 export declare function passingFrontmatter(collection: Collection, path: string): Frontmatter | undefined;
 export declare function documentsOf(collection: Collection): Generator<readonly [string, Document]>;
-export declare function unreadable(text: Readonly<Record<string, string>>, previous?: Readonly<Record<string, string>>): Refused | null;
+export declare function unreadable(text: Readonly<Record<string, string>>, previous?: Readonly<Record<string, string>>): Generator<number, Refused | null, void>;
 export declare function validRoot(root: unknown): root is string;
-export declare function validateCollection(text: Readonly<Record<string, string>>, binaryTargets: readonly string[], composition: Composition): Validation;
+export declare function validateCollection(text: Readonly<Record<string, string>>, binaryTargets: readonly string[], composition: Composition): Generator<number, Validation, void>;
 type Held = {
     text: Paths<string>;
     binaries: Paths<unknown>;
@@ -34,5 +35,5 @@ export declare function referring(held: Held, composition: Composition, targets:
 export declare function available(composition: Composition): boolean;
 export declare function changedCleanly(next: Held, previous: Held & {
     composition: Composition;
-}, composition: Composition): boolean;
+}, composition: Composition): Generator<number, boolean, void>;
 export {};

package/dist/mdruntime/conversation.d.ts

@@ -51,6 +51,11 @@ export type ConversationView = {
     } | null;
     commands: readonly ProcessCommand[];
     options: readonly SessionOption[];
+    starting: string | null;
+    link: {
+        connected: boolean;
+    } | null;
+    deliveryUnknown: readonly string[];
     chatDraft: (ChatDraft & {
         readonly revision: string;
     }) | null;

package/dist/mdruntime/overlay.d.ts

@@ -21,7 +21,7 @@ export type Layer = Heads & {
 export declare function acceptedBinaries(files: Readonly<Record<string, BinaryFile>>): Record<string, HeldBinary>;
 export declare function sameBinary(left: HeldBinary | undefined, right: HeldBinary | undefined): boolean;
 export declare function sameChange(left: HeadChange | undefined, right: HeadChange | undefined): boolean;
-export declare function overlay(base: Layer, queue: readonly ChangeBatch[], unapplied?: () => void): Layer;
-export declare function sameLayerText(left: Layer, right: Layer): boolean;
-export declare function changedPaths(left: Layer, right: Layer): ReadonlySet<string>;
-export declare function overlayChanged(base: Layer, queue: readonly ChangeBatch[], previousBase: Layer, previousQueue: readonly ChangeBatch[], previousVisible: Layer): Layer;
+export declare function overlaying(base: Layer, queue: readonly ChangeBatch[], unapplied?: () => void): Generator<number, Layer, void>;
+export declare function sameText(left: Layer, right: Layer): Generator<number, boolean, void>;
+export declare function changedPaths(left: Layer, right: Layer): Generator<number, ReadonlySet<string>, void>;
+export declare function overlayChanged(base: Layer, batch: ChangeBatch, previousBase: Layer, previousBatch: ChangeBatch, previousVisible: Layer): Generator<number, Layer, void>;

package/dist/mdruntime/replica.d.ts

@@ -4,6 +4,7 @@ import { type Layer } from './overlay.js';
 import type { MutationResult } from './adapter.js';
 import type { ReplicaRecord } from './store.js';
 import type { Refused } from './transfer.js';
+import { type Later } from './turn.js';
 export type ConfirmedLayer = {
     record: ReplicaRecord;
     collection: Collection;
@@ -31,19 +32,20 @@ type ReplayStep = {
 export declare function compositionOf(record: ReplicaRecord): Composition;
 export declare function confirmedOf(record: ReplicaRecord, previous?: ConfirmedLayer): ConfirmedLayer;
 export declare function sameMembership(record: ReplicaRecord, other: ReplicaRecord): boolean;
-export declare function readStaged(staged: ReplicaRecord, previous?: ConfirmedLayer): Staged;
-export declare function readReclassified(record: ReplicaRecord, previous: ConfirmedLayer): Staged | {
+export declare function readStaged(staged: ReplicaRecord, previous?: ConfirmedLayer): Later<Staged>;
+export declare function readReclassified(record: ReplicaRecord, previous: ConfirmedLayer): Later<Staged | {
     kind: 'deferred';
-};
+}>;
 type Accepted = Extract<MutationResult, {
     kind: 'accepted';
 }>;
-export declare function applyReturned(confirmed: ConfirmedLayer, submitted: ChangeBatch, accepted: Accepted, roomVersion: string, writtenAt: string): Staged;
+export declare function applyReturned(confirmed: ConfirmedLayer, submitted: ChangeBatch, accepted: Accepted, roomVersion: string, writtenAt: string): Later<Staged>;
+export declare function replicating(confirmed: ConfirmedLayer, queue: readonly ChangeBatch[], previous?: Replica): Generator<number, Replica, void>;
 export declare function replicaOf(confirmed: ConfirmedLayer, queue: readonly ChangeBatch[], previous?: Replica): Replica;
 export declare function landed(batch: ChangeBatch, confirmed: ConfirmedLayer, current?: Readonly<Record<string, string>>): boolean;
 export type Standing = {
     readonly withdrawn: readonly ChangeBatch[];
     readonly kept: readonly ChangeBatch[];
 };
-export declare function standing(confirmed: ConfirmedLayer, queue: readonly ChangeBatch[], withdrawable: (batch: ChangeBatch) => boolean, local: boolean): Standing;
+export declare function standing(confirmed: ConfirmedLayer, queue: readonly ChangeBatch[], withdrawable: (batch: ChangeBatch) => boolean, local: boolean): Generator<number, Standing, void>;
 export {};

package/dist/mdruntime/save.d.ts

@@ -3,6 +3,7 @@ import { type Change, type ChangeBatch, type Precondition, type WrittenBy } from
 import { type Composition } from './collection.js';
 import type { VisibleLayer } from './replica.js';
 import type { ChangedPart } from './room-draft.js';
+import { type Later } from './turn.js';
 export type SaveRefusal = {
     code: string;
     retryable: boolean;
@@ -37,7 +38,7 @@ export type BatchResult = {
     kind: 'refused';
     refusal: SaveRefusal;
 };
-export declare function providerRewritten(batch: ChangeBatch, visible: VisibleLayer): ChangeBatch;
+export declare function providerRewritten(batch: ChangeBatch, visible: VisibleLayer): Generator<number, ChangeBatch, void>;
 export declare function queuedDocuments(queue: readonly ChangeBatch[]): ReadonlySet<string>;
 export type Requeued = {
     kind: 'requeued';
@@ -61,4 +62,4 @@ export type Joining = {
 export declare function requeued(queue: readonly ChangeBatch[], changes: readonly Change[], visible: VisibleLayer, changeable: (batch: ChangeBatch) => boolean, state: (queue: readonly ChangeBatch[]) => VisibleLayer): Requeued;
 export declare function joined(queue: readonly ChangeBatch[], owner: ChangeBatch, extra: ChangeBatch): Joining;
 export declare function limitedIn(queue: readonly ChangeBatch[], batch: ChangeBatch, limits: readonly ProviderLimit[], state: (queue: readonly ChangeBatch[]) => VisibleLayer): SaveRefusal | null;
-export declare function buildBatch(input: SaveInput): BatchResult;
+export declare function buildBatch(input: SaveInput): Later<BatchResult>;

package/dist/mdruntime/shared.d.ts

@@ -1,10 +1,14 @@
 export type Paths<V> = Readonly<Record<string, V>>;
 type Weigh<V> = (key: string, value: V) => number;
+export declare function sharing<V>(map: Paths<V>): Generator<number, Paths<V>, void>;
 export declare function shared<V>(map: Paths<V>): Paths<V>;
 export declare function patched<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Paths<V>;
+export declare function patching<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Generator<number, Paths<V>, void>;
 export declare function tally<V>(map: Paths<V>, weigh: Weigh<V>): number;
 export declare function sizeOf<V>(map: Paths<V>): number;
+export declare function differences<V>(left: Paths<V>, right: Paths<V>, same?: (left: V, right: V) => boolean): Generator<number, ReadonlySet<string>, void>;
 export declare function differing<V>(left: Paths<V>, right: Paths<V>, same?: (left: V, right: V) => boolean): ReadonlySet<string>;
 export declare function drafted<V>(base: Paths<V>): Record<string, V>;
 export declare function settled<V>(draft: Record<string, V>): Paths<V>;
+export declare function settling<V>(draft: Record<string, V>): Generator<number, Paths<V>, void>;
 export {};

package/dist/mdruntime/store.d.ts

@@ -3,6 +3,7 @@ import type { Capability, HeadChange, Member, OperationScopes, ProviderLimit, Re
 import type { AcceptedMessage, KeptReceipt } from './adapter.js';
 import type { ChangeBatch } from './change.js';
 import { type HeldBinary } from './overlay.js';
+import { type Later } from './turn.js';
 import type { ChatDraftFile } from './file.js';
 import type { Submission } from './outcome.js';
 import type { RoomDraftRecord, SavedDraft } from './room-draft.js';
@@ -165,6 +166,7 @@ export type RuntimeStore = {
     rememberGeneration(value: string): Promise<void>;
     close(): void;
 };
+export declare function transacted<T>(database: IDBDatabase, stores: string | readonly string[], mode: IDBTransactionMode, work: (transaction: IDBTransaction) => Later<T>): Promise<T>;
 export declare function authoredHolder(): Promise<string | null>;
 export declare function authoredBy(holder: string): Promise<boolean>;
 export declare function authoredBinding(): Promise<string | null>;

package/dist/mdruntime/turn.d.ts

@@ -2,5 +2,7 @@ export declare function yielded(): Promise<void>;
 export declare const ROW_WEIGHT = 256;
 export type Later<T> = T | Promise<T>;
 export declare function after<T, R>(value: Later<T>, next: (value: T) => Later<R>): Later<R>;
-export declare function inUnits<T>(items: Iterable<T>, each: (item: T) => number, ended?: () => void): Later<void>;
+export declare function inUnits<T>(items: Iterable<T>, each: (item: T) => number, ended?: () => void, paused?: () => Promise<void>): Later<void>;
+export declare function finished<R>(steps: Generator<number, R, void>): R;
+export declare function stepped<R>(steps: Generator<number, R, void>): Later<R>;
 export declare function inChunks<T>(items: readonly T[], weigh: (item: T) => number, each: (chunk: readonly T[]) => Later<void>): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/app-bridge",
-  "version": "0.1.0-cfbb4f5408379",
+  "version": "0.1.0-cff4298f6ded6",
   "description": "Types of the agents.house App bridge House hands every App: navigation, the tab title and icon, ceremonies, installation, notifications and the icon badge, status, Site image reads, App release code, App and Site screenshot reads, and App messages, with an accessor and an in-page test host.",
   "license": "MIT",
   "type": "module",