@agentshouse/app-bridge 0.1.0-ca559eade7c19 → 0.1.0-caae3da69c1c2

package/dist/index.d.ts

@@ -1,9 +1,17 @@
 import type { MdRuntimeClient, Open } from './mdruntime/client.js';
-import type { HouseCalls } from './calls.js';
-export type { HouseCalls } from './calls.js';
-export type HouseCallInput<Name extends string> = Name extends keyof HouseCalls ? HouseCalls[Name] : unknown;
+import type { HouseMethods } from './calls.js';
+export type { HouseMethods } from './calls.js';
+export type HouseParams<Name extends string> = Name extends keyof HouseMethods ? HouseMethods[Name]['params'] : unknown;
+type CallResult = Awaited<ReturnType<MdRuntimeClient['call']>>;
+export type HouseResult<Name extends string> = Exclude<CallResult, {
+    readonly kind: 'action';
+}> | (Extract<CallResult, {
+    readonly kind: 'action';
+}> & {
+    readonly result: Name extends keyof HouseMethods ? HouseMethods[Name]['result'] : unknown;
+});
 export interface HouseRuntime extends Omit<MdRuntimeClient, 'call'> {
-    call<Name extends Open<keyof HouseCalls>>(name: Name, input: HouseCallInput<Name>): ReturnType<MdRuntimeClient['call']>;
+    call<Name extends Open<keyof HouseMethods>>(method: Name, params: HouseParams<Name>): Promise<HouseResult<Name>>;
 }
 export interface HouseSyncState {
     readonly state: string;

package/dist/mdmodel/condition.d.ts

@@ -1,8 +1,6 @@
 import { type ValueFacts } from './definition.js';
 import type { Document, VerifiedModel } from './types.js';
-export type ConditionValue = string | number | boolean | {
-    readonly owner: true;
-};
+export type ConditionValue = string | number | boolean;
 export type ConditionTest = {
     readonly all: readonly ConditionTest[];
 } | {
@@ -120,7 +118,6 @@ export type ItemFacts = {
     readonly source: string | null;
     readonly address: string | null;
     readonly has_attachment: boolean;
-    readonly provider: string | null;
     readonly container: string | null;
     readonly author: string | null;
     readonly headers: Readonly<Record<string, string>>;
@@ -143,7 +140,8 @@ export declare function datePointers(fields: Readonly<Record<string, ValueFacts>
 export declare function dated(value: unknown): value is string;
 export declare function instant(value: unknown): bigint | undefined;
 export declare function pointed(value: unknown, pointer: string): unknown;
-export declare function holds(test: ConditionTest, document: DocumentFacts, owner: string): Truth;
-export declare function fires(condition: DocumentCondition, event: DocumentEvent, owner: string): boolean;
-export declare function itemFires(condition: ItemCondition, item: ItemFacts, owner: string): boolean;
+export declare function members(document: DocumentFacts, path: string): readonly string[];
+export declare function holds(test: ConditionTest, document: DocumentFacts): Truth;
+export declare function fires(condition: DocumentCondition, event: DocumentEvent): boolean;
+export declare function itemFires(condition: ItemCondition, item: ItemFacts): boolean;
 export {};

package/dist/mdmodel/definition.d.ts

@@ -5,6 +5,7 @@ export type ValueFacts = {
     readonly format?: string;
     readonly values?: readonly unknown[];
     readonly reference?: readonly string[];
+    readonly crossRoom?: true;
     readonly prose: boolean;
     readonly conditional?: true;
     readonly prefix?: readonly ValueFacts[];

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

@@ -1,18 +1,19 @@
-export { dated, datePointers, factKind, facts, fires, holds, instant, itemFires, pointed, prosePaths, WRITE_DOORS, } from './condition.js';
+export { dated, datePointers, factKind, facts, fires, holds, instant, itemFires, members, pointed, prosePaths, WRITE_DOORS, } from './condition.js';
 export type { Actor, Condition, ConditionScope, ConditionTest, ConditionValue, CronCondition, DateCondition, DocumentCondition, DocumentEvent, DocumentFacts, Fact, FactKind, ItemCondition, ItemFacts, Resolved, WriteDoor, } from './condition.js';
 export { headingLines } from './blocks.js';
 export type { HeadingLine } from './blocks.js';
 export { divide } from './divide.js';
 export { apply, bodyLinks, fieldStart, linkOccurrences, links, parse, parseFrontmatter, relativize, relativizeBody, relinkBody, serialize, } from './document.js';
 export { HOUSE_FIELDS, MEMBER_FIELD, RECEIVED_FIELD, SITE_FIELD, TYPE_FIELD } from './fields.js';
-export { relative, retarget, target } from './paths.js';
+export { relative, retarget, roomPath, roomTarget, target } from './paths.js';
+export type { RoomTarget } from './paths.js';
 export { MARKDOWN_SYNTAX_PROFILE } from './profile.js';
 export { project } from './project.js';
 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 type { ApplyResult, BodyResult, Change, Division, DivisionContext, Document, DocumentCheck, Frontmatter, FrontmatterResult, Library, ModelVerification, Link, LinkOccurrence, ParseResult, Projection, ProjectionContext, Reached, Reference, Refusal, RoomReference, Span, Validation, ValidationContext, VerifiedModel, } from './types.js';
+export { bodyRoomLinks, checkDocument, resolves, roomReferences, 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/paths.d.ts

@@ -2,14 +2,22 @@ export declare function dirname(path: string): string;
 export declare function join(base: string, relative: string): string;
 export declare function normalize(path: string): string | null;
 export declare function destinationPath(href: string): string | null;
+export type RoomTarget = {
+    readonly handle: string;
+    readonly path: string;
+};
 export declare function classifyHref(from: string, href: string): {
     kind: 'skip';
 } | {
     kind: 'path';
     path: string;
-} | {
+} | ({
+    kind: 'room';
+} & RoomTarget) | {
     kind: 'invalid';
 };
+export declare function roomTarget(href: string): RoomTarget | null;
+export declare function roomPath(href: string): string | null;
 export declare function target(from: string, href: string): string | null;
 export declare function retarget(href: string, to: string): string;
 export declare function relative(from: string, target: string): string;

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

@@ -99,7 +99,25 @@ export type Reference = {
     readonly pointer: string;
     readonly value: string;
     readonly to: readonly string[];
+    readonly crossRoom?: true;
 };
+export type RoomReference = {
+    readonly handle: string;
+    readonly path: string;
+} & ({
+    readonly kind: 'link';
+    readonly href: string;
+} | {
+    readonly kind: 'field';
+    readonly pointer: string;
+    readonly value: string;
+    readonly to: readonly string[];
+} | {
+    readonly kind: 'item';
+    readonly section: string;
+    readonly href: string;
+    readonly to: readonly string[];
+});
 export type Change = {
     readonly kind: 'field';
     readonly name: string;
@@ -130,6 +148,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

@@ -1,7 +1,10 @@
 import { type Definition } from './definition.js';
-import type { DocumentCheck, Library, ModelVerification, Reached, Validation, ValidationContext, VerifiedModel } from './types.js';
+import type { DocumentCheck, Library, ModelVerification, Reached, RoomReference, Validation, ValidationContext, VerifiedModel } from './types.js';
 export declare function resolves(reference: Reached, typeOf: (path: string) => string | undefined, binary: (path: string) => boolean): boolean;
 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 bodyRoomLinks(body: string): RoomReference[];
+export declare function roomReferences(file: string, content: string, definition?: Definition): readonly RoomReference[];
+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

@@ -10,8 +10,6 @@ export type TypedSelection = {
     roots: readonly string[];
 };
 export type OperationScopes = {
-    read: readonly string[];
-    sync: readonly string[];
     write: readonly string[];
     delete: readonly string[];
 };
@@ -49,6 +47,7 @@ export type ListedConversation = {
     created: string;
     finished: string | null;
     outcome: string | null;
+    waiting: boolean;
 };
 export type ConversationAction = 'conversation.create' | 'conversation.send' | 'conversation.answer' | 'conversation.interrupt' | 'conversation.kill' | 'conversation.cancel' | 'conversation.delete' | 'conversation.history';
 export type ConversationMessage = {
@@ -162,6 +161,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;
@@ -210,6 +221,10 @@ export type Discovery = {
     providerLimits: readonly ProviderLimit[];
     retention: Retention;
     member?: Member;
+    covered?: readonly string[];
+};
+export type DiscoveryScope = {
+    readonly authorities: readonly string[];
 };
 export type TransportUncertainty = {
     kind: 'transport-uncertainty';
@@ -229,7 +244,7 @@ export type ProviderRefusal = {
 export type ScopedRefusal = ProviderRefusal & {
     kind: 'scoped-refusal';
     locator: string;
-    scope: Open<'content' | 'sync' | 'model' | 'operation' | 'undisclosed'>;
+    scope: Open<'content' | 'model' | 'operation' | 'undisclosed'>;
 };
 export type AdapterFailure = TransportUncertainty | RoomNotReadable | RevokedAuthorization | ScopedRefusal;
 export type ContractUnavailable = ProviderRefusal & {
@@ -400,6 +415,13 @@ export type BinaryResult = {
 } | (ProviderRefusal & {
     kind: 'rejected';
 }) | AdapterFailure;
+export type BinaryLinkResult = {
+    kind: 'link';
+    url: string;
+    name: string;
+} | (ProviderRefusal & {
+    kind: 'rejected';
+}) | AdapterFailure;
 export type ActionRequest = {
     name: string;
     input: unknown;
@@ -430,6 +452,9 @@ export type RoomStreamEvent = {
 } | {
     kind: 'opening';
     expired: readonly string[];
+} | {
+    kind: 'authority-changed';
+    scope?: DiscoveryScope;
 } | {
     kind: 'room-version';
     locator: string;
@@ -448,12 +473,8 @@ export type StreamReceipts = {
     }): Promise<void>;
     drop(keys: readonly string[]): Promise<void>;
 };
-export type AcquiredDemand = {
-    rooms: readonly string[];
-    conversations: boolean;
-};
 export type RoomStream = {
-    hold(rooms: readonly HeldRoom[], demand: AcquiredDemand | null): void;
+    hold(rooms: readonly HeldRoom[]): void;
     reopen(): void;
     published(locator: string, roomVersion: string): void;
     observe(notify: (event: RoomStreamEvent) => void, receipts: StreamReceipts): () => void;
@@ -462,12 +483,15 @@ export type Adapter = {
     readonly localSaves?: true;
     readonly exhaustiveDiscovery?: true;
     authorize(): Promise<Authorization>;
-    discover(authorization: Authorization): Promise<DiscoverResult>;
+    discover(authorization: Authorization, scope?: DiscoveryScope): Promise<DiscoverResult>;
     bootstrap(authorization: Authorization, request: BootstrapRequest): Promise<BootstrapResult>;
     refresh(authorization: Authorization, request: RefreshRequest): Promise<RefreshResult>;
     mutate(authorization: Authorization, request: MutationRequest, keep: (upload: unknown) => Promise<void>): Promise<MutationResult>;
     history(authorization: Authorization, request: HistoryRequest): Promise<HistoryResult>;
     binary(authorization: Authorization, request: BinaryRequest): Promise<BinaryResult>;
+    link(authorization: Authorization, request: Extract<BinaryRequest, {
+        kind: 'path';
+    }>): Promise<BinaryLinkResult>;
     referrerScope(referrer: unknown): ReferrerScope | null;
     action(authorization: Authorization, request: ActionRequest): Promise<ActionResult>;
     reached(locator: string, roomVersion: string, target: string): boolean;

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/client.d.ts

@@ -1,9 +1,9 @@
-import type { AppRoom, ConnectionRefusal, HistoryQuery, RoomSchemas, SavedRoomDraft, SaveResult } from './connection.js';
+import type { AppRoom, ConnectionRefusal, HistoryQuery, RoomSchemas, SavedParts, SavedRoomDraft, SaveResult } from './connection.js';
 import type { Member, ServiceMode } from './adapter.js';
 import type { ChatDraft, ConversationAgent, ConversationEntry, ConversationOptions, ConversationView } from './conversation.js';
 import { type Observation } from './observation.js';
 import type { BinaryReference } from './binary.js';
-import type { BinaryAnswer, CallResult, HistoryAnswer, Offline, QueueEntry } from './outcome.js';
+import type { BinaryAnswer, BinaryLinkAnswer, CallResult, HistoryAnswer, Offline, QueueEntry } from './outcome.js';
 import type { DocumentQuery, DocumentResult, GroupQuery, GroupResult, PendingResult } from './query.js';
 import type { RoomDraft, RoomDraftParts, RoomDraftWrite } from './room-draft.js';
 import type { SearchRequest, SearchResult } from './search.js';
@@ -25,9 +25,11 @@ export type MdRuntimeClient = {
         discard(room: string, path: string, revision: string): Promise<RoomDraftWrite>;
     };
     save(room: string, roomDrafts: readonly SavedRoomDraft[]): Promise<SaveResult>;
+    saveParts(room: string, parts: readonly SavedParts[]): Promise<SaveResult>;
     presentation: {
         read(): Promise<unknown>;
         write(value: unknown): Promise<void>;
+        edit(members: Readonly<Record<string, unknown>>): Promise<void>;
     };
     conversation: {
         list(): Promise<readonly ConversationEntry[]>;
@@ -42,11 +44,13 @@ export type MdRuntimeClient = {
     };
     chatDraft: {
         write(conversation: string, draft: ChatDraft, revision?: string): Promise<void>;
+        prepend(conversation: string, draft: ChatDraft): Promise<void>;
         discard(conversation: string): Promise<void>;
     };
     history(locator: string, path: string, query?: HistoryQuery): Promise<HistoryAnswer>;
     binaryFile: {
         read(room: string, path: string, revision?: string): Promise<BinaryAnswer>;
+        link(room: string, path: string, revision?: string): Promise<BinaryLinkAnswer>;
         readReference(reference: BinaryReference): Promise<BinaryAnswer>;
     };
     call(name: string, input: unknown): Promise<CallResult>;

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/connection.d.ts

@@ -8,13 +8,12 @@ import { type ChatDraftSurface, type ConversationAgent, type ConversationEntry,
 import { type WrittenBy } from './change.js';
 import type { Open } from './open.js';
 import { type BinaryReference } from './binary.js';
-import { type BinaryAnswer, type CallResult, type HistoryAnswer, type QueueEntry } from './outcome.js';
+import { type BinaryAnswer, type BinaryLinkAnswer, type CallResult, type HistoryAnswer, type QueueEntry } from './outcome.js';
 import { type Recovery } from './recovery.js';
 import { type SaveRefusal } from './save.js';
-import { type RoomDraft, type RoomDraftWrite } from './room-draft.js';
+import { type RoomDraft, type RoomDraftParts, type RoomDraftWrite } from './room-draft.js';
 import { type SyncStatus } from './status.js';
 import { type RuntimeShell } from './durability.js';
-import { type RuntimeDemand } from './acquisition.js';
 import { type CapacityCause, type CodeAvailability, type Persistence, type Readiness, type SearchObligation } from './readiness.js';
 import { type NarrowedView, type PortReach, type RuntimeView } from './reach.js';
 export type AppTypedSelection = {
@@ -64,6 +63,10 @@ export type SavedRoomDraft = {
     readonly path: string;
     readonly revision: string;
 };
+export type SavedParts = {
+    readonly path: string;
+    readonly parts: RoomDraftParts;
+};
 export type RoomDraftSurface = {
     list(): Promise<readonly RoomDraft[]>;
     read(room: string, path: string): RoomDraft | null;
@@ -73,9 +76,11 @@ export type RoomDraftSurface = {
 export type PresentationSurface = {
     read(app: string): Promise<unknown>;
     write(app: string, value: unknown): Promise<void>;
+    edit(app: string, members: Readonly<Record<string, unknown>>): Promise<void>;
 };
 export type BinaryFileSurface = {
     read(room: string, path: string, revision?: string): Promise<BinaryAnswer>;
+    link(room: string, path: string, revision?: string): Promise<BinaryLinkAnswer>;
     readReference(reference: BinaryReference): Promise<BinaryAnswer>;
 };
 export type HistoryQuery = {
@@ -96,6 +101,7 @@ export type MdRuntime = {
     chatDraft: ChatDraftSurface;
     presentation: PresentationSurface;
     save(room: string, roomDrafts: readonly SavedRoomDraft[], writtenBy?: WrittenBy): Promise<SaveResult>;
+    saveParts(room: string, parts: readonly SavedParts[], writtenBy?: WrittenBy): Promise<SaveResult>;
     history(locator: string, path: string, query?: HistoryQuery): Promise<HistoryAnswer>;
     binaryFile: BinaryFileSurface;
     call(name: string, input: unknown): Promise<CallResult>;
@@ -133,7 +139,6 @@ export type ComposedRuntime = RuntimeView & {
     seed(entry: EntrySeed): void;
     stop(): Promise<void>;
     lose(locators: readonly string[]): Promise<void>;
-    acquire(demand: RuntimeDemand): void;
     persisted(answer: Persistence): void;
     within(reach: PortReach | null, port: ReadinessPort): NarrowedView;
 };

package/dist/mdruntime/conversation.d.ts

@@ -17,6 +17,7 @@ export type ConversationEntry = {
     created: string;
     finished: string | null;
     outcome: string | null;
+    waiting: boolean;
     state: ConversationState;
     started: string | null;
 };
@@ -36,10 +37,14 @@ export type ChatDraft = {
 };
 export type ConversationOptions = {
     limit?: number;
+    after?: string;
+    total?: true;
 };
 export type ConversationView = {
     conversation: string;
     messages: readonly ConversationMessage[];
+    next?: string;
+    total?: number;
     turn: RunningTurn | null;
     questions: readonly unknown[];
     process: {
@@ -47,6 +52,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;
@@ -64,6 +74,7 @@ export type ConversationSurface = {
 };
 export type ChatDraftSurface = {
     write(conversation: string, draft: ChatDraft, revision?: string): Promise<void>;
+    prepend(conversation: string, draft: ChatDraft): Promise<void>;
     discard(conversation: string): Promise<void>;
 };
 export type ConversationDependencies = {

package/dist/mdruntime/observation.d.ts

@@ -14,6 +14,8 @@ export type QueryChange = {
     removed: readonly RowKey[];
     order: readonly RowKey[] | null;
     coverage?: QueryCoverage;
+    next?: string | null;
+    total?: number;
 };
 export type QueryMessage = KeyedResult | QueryChange;
 export type Observed = {

package/dist/mdruntime/outcome.d.ts

@@ -1,4 +1,4 @@
-import type { ActionResult, AdapterFailure, BinaryResult, HistoryResult, ProviderRefusal, RoomVersionAt, ScopedRefusal } from './adapter.js';
+import type { ActionResult, AdapterFailure, BinaryLinkResult, BinaryResult, HistoryResult, ProviderRefusal, RoomVersionAt, ScopedRefusal } from './adapter.js';
 import type { ChangeBatch } from './change.js';
 type Refused<Kind extends string> = ProviderRefusal & {
     kind: Kind;
@@ -18,8 +18,14 @@ export type BinaryAnswer = {
     kind: 'binary';
     blob: Blob;
 } | Refused<'rejected'> | Refused<'absent'> | Failure;
-export declare function absentBinary(path: string): BinaryAnswer;
+export type BinaryLinkAnswer = {
+    kind: 'link';
+    url: string;
+    name: string;
+} | Refused<'rejected'> | Refused<'absent'> | Failure;
+export declare function absentBinary(path: string): Refused<'absent'>;
 export declare function binaryAnswer(result: BinaryResult): BinaryAnswer;
+export declare function binaryLinkAnswer(result: BinaryLinkResult): BinaryLinkAnswer;
 export type Offline = {
     readonly kind: 'offline';
 };

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/query.d.ts

@@ -38,6 +38,8 @@ export type Filter = {
     types?: readonly string[];
     where?: Where;
     pathPrefix?: string;
+    folder?: string;
+    paths?: readonly string[];
     hop?: Related & {
         field: string;
     };
@@ -45,7 +47,7 @@ export type Filter = {
         field?: string;
     };
 };
-export type Key = 'room' | 'path' | 'type' | {
+export type Key = 'room' | 'path' | 'type' | 'folder' | {
     field: string;
 };
 export type Select = 'all' | {
@@ -71,6 +73,8 @@ export type DocumentQuery = Filter & {
         direction?: Direction;
     } & OrderOptions)[];
     limit?: number;
+    after?: string;
+    total?: true;
 };
 export type GroupQuery = Filter & {
     groupBy: readonly Exclude<Key, 'path'>[];
@@ -79,6 +83,8 @@ export type GroupQuery = Filter & {
         direction?: Direction;
     }[];
     limit?: number;
+    after?: string;
+    total?: true;
 };
 export type LocalQuery = DocumentQuery | GroupQuery;
 export type Backlink = {
@@ -123,9 +129,13 @@ export type PendingResult = {
 };
 export type DocumentRows = {
     documents: readonly QueryDocument[];
+    next?: string;
+    total?: number;
 };
 export type GroupRows = {
     groups: readonly QueryGroup[];
+    next?: string;
+    total?: number;
 };
 export type QueryRows = DocumentRows | GroupRows;
 export type DocumentResult = DocumentRows & {
@@ -189,6 +199,8 @@ export type KeyPlan = {
     of: 'path';
 } | {
     of: 'type';
+} | {
+    of: 'folder';
 } | {
     of: 'field';
     field: string;
@@ -221,11 +233,17 @@ export type PlanReach = {
     rooms: readonly string[];
     documents: readonly string[];
 };
+export type Continuation = {
+    text: string;
+    values: readonly unknown[] | null;
+};
 export type Plan = {
     key: string;
     rooms: readonly string[] | null;
     reach: PlanReach | null;
     root: Scope;
+    folder: string | null;
+    paths: readonly string[] | null;
     hop: (Scope & {
         field: string;
     }) | null;
@@ -234,6 +252,8 @@ export type Plan = {
     }) | null;
     shape: DocumentShape | GroupShape;
     limit: number | null;
+    after: Continuation | null;
+    total: boolean;
 };
 export declare class QueryError extends Error {
     readonly code: QueryErrorCode;

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,15 +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 declare function withdrawals(confirmed: ConfirmedLayer, queue: readonly ChangeBatch[], withdrawable: (batch: ChangeBatch) => boolean, local: boolean): readonly ChangeBatch[];
+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): Generator<number, Standing, void>;
 export {};

package/dist/mdruntime/rows.d.ts

@@ -13,6 +13,7 @@ export type DocumentRow = {
     values: Fields;
     reached: Readonly<Record<string, readonly unknown[]>>;
     directories: readonly string[];
+    folder: string;
     text: string | null;
     change: HeadChange | null;
     fileId: string | null;