@agentshouse/app-bridge 0.1.0-c646d0da70608 → 0.1.0-c66ec79ae3f1a

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;
@@ -13,6 +21,7 @@ export interface HouseCredentialState {
     readonly state: Open<'none' | 'held' | 'rejected'>;
     readonly expiresAt: number | null;
 }
+export type HouseDatabaseFailure = 'unsupported' | 'damaged' | 'update-required';
 export type HouseAnalyticsChoice = 'accept' | 'decline';
 export interface HouseAnalytics {
     readonly measures: boolean;
@@ -32,6 +41,7 @@ export interface HouseStatus {
         readonly retryable: boolean;
     } | null;
     readonly loss: string | null;
+    readonly database: Open<HouseDatabaseFailure> | null;
     readonly analytics: HouseAnalytics;
     readonly serviceMode: Open<'open' | 'write-halted'> | null;
     readonly offline: boolean;
@@ -72,6 +82,7 @@ export interface HouseExternalRequest {
     readonly body_base64?: string;
     readonly account?: string;
     readonly slot?: string;
+    readonly room_ref?: string;
 }
 export type HouseExternalAnswer = {
     readonly status: number;

package/dist/mdmodel/condition.d.ts

@@ -1,8 +1,8 @@
-import { type ValueFacts } from './definition.js';
+import { type Definition, 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 declare const CONDITION_OPERATORS: readonly ['eq', 'in', 'exists', 'contains', 'gt', 'gte', 'lt', 'lte', 'prefix'];
+export type ConditionOperator = (typeof CONDITION_OPERATORS)[number];
 export type ConditionTest = {
     readonly all: readonly ConditionTest[];
 } | {
@@ -41,6 +41,7 @@ type DocumentEventBase = {
     readonly on: 'documents';
     readonly scope: ConditionScope;
     readonly by?: ConditionTest;
+    readonly moved_between_rooms?: boolean;
 };
 export type DocumentCondition = (DocumentEventBase & {
     readonly mode: 'starts_matching';
@@ -114,13 +115,13 @@ export type DocumentEvent = {
     readonly after: DocumentFacts | null;
     readonly changed: readonly string[];
     readonly by: Actor;
+    readonly moved_between_rooms: boolean;
 };
 export type ItemFacts = {
     readonly delivery: string;
     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>>;
@@ -140,10 +141,21 @@ export declare function facts(document: Document, at: {
 }, model: VerifiedModel, resolve: (target: string) => Resolved | undefined): DocumentFacts;
 export declare function prosePaths(facts: DocumentFacts): string[];
 export declare function datePointers(fields: Readonly<Record<string, ValueFacts>>): string[];
+export declare function valuedChange(definition: Definition, field: string): boolean;
+export declare function changeFields(definition: Definition): string[];
+export declare function memberPointers(definition: Definition, memberType: string): string[];
+export declare const DOCUMENT_PATHS: readonly string[];
+export declare const ACTOR_PATHS: readonly string[];
+export declare const ITEM_PATHS: readonly string[];
+export declare function testOperators(definitions: readonly Definition[], path: string, memberType: string | null): readonly ConditionOperator[];
+export declare function actorOperators(path: string): readonly ConditionOperator[];
+export declare function itemOperators(path: string): readonly ConditionOperator[];
+export declare function itemKind(path: string): FactKind | null;
 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[];
@@ -29,12 +30,26 @@ export type Shape = {
     readonly schema: Readonly<Record<string, unknown>>;
     readonly defs: Readonly<Record<string, unknown>>;
 };
+export type RuleValue = string | number | boolean | null;
+export type Transition = {
+    readonly from: RuleValue;
+    readonly to: RuleValue;
+    readonly roles?: readonly string[];
+};
+export type FieldRules = {
+    readonly changeRoles?: readonly string[];
+    readonly initialRoles?: readonly string[];
+    readonly transitions?: readonly Transition[];
+};
 export type Definition = {
     readonly name: string;
     readonly memberDocument: boolean;
     readonly frontmatter: ValueFacts;
     readonly fields: Readonly<Record<string, ValueFacts>>;
     readonly sections: Readonly<Record<string, SectionSpec>>;
+    readonly rules: Readonly<Record<string, FieldRules>>;
+    readonly createRoles?: readonly string[];
+    readonly deleteRoles?: readonly string[];
     readonly shape: Shape;
 };
 export type Failure = {
@@ -62,4 +77,4 @@ export type PointerFacts = {
 export declare function crossedFacts(facts: ValueFacts): ValueFacts[];
 export declare function fieldFacts(definition: Definition, key: string): ValueFacts | undefined;
 export declare function pointerFacts(definition: Definition, pointer: string): PointerFacts | undefined;
-export declare function readSchema(text: string): VerifiedModel | Failure;
+export declare function readSchema(text: string, provided?: VerifiedModel): VerifiedModel | Failure;

package/dist/mdmodel/document.d.ts

@@ -1,15 +1,15 @@
 import { type Definition } from './definition.js';
-import type { ApplyResult, BodyResult, FrontmatterResult, Change, Document, Link, LinkOccurrence, ParseResult } from './types.js';
+import { type LinkInventory } from './links.js';
+import type { ApplyResult, BodyResult, FrontmatterResult, Change, Document, Link, ParseResult } from './types.js';
 import { type YamlMap } from './yaml.js';
+export declare function inventoryOf(document: Document): LinkInventory;
 export declare function parseFrontmatter(content: string, file?: string): FrontmatterResult;
 export declare function parse(content: string, file?: string): ParseResult;
-export declare function relativize(document: Document, file: string, handle: string, definition?: Definition): ApplyResult;
+export declare function relativize(document: Document, file: string, handle: string, definition?: Definition, kept?: ReadonlySet<string>): ApplyResult;
 export declare function relativizeBody(body: string, file: string, handle: string): BodyResult;
 export declare function relinkBody(body: string, file: string, moves: ReadonlyMap<string, string>): BodyResult;
 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,20 @@
-export { dated, datePointers, factKind, facts, fires, holds, instant, itemFires, 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 { ACTOR_PATHS, actorOperators, changeFields, CONDITION_OPERATORS, dated, datePointers, DOCUMENT_PATHS, factKind, facts, fires, holds, instant, ITEM_PATHS, itemFires, itemKind, itemOperators, memberPointers, members, pointed, prosePaths, testOperators, valuedChange, WRITE_DOORS, } from './condition.js';
+export type { Actor, Condition, ConditionOperator, 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 { apply, bodyLinks, 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, JsonType, PatternFacts, PointerFacts, SectionSpec, Shape, 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 { 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, ParseResult, Projection, ProjectionContext, Reached, Reference, Refusal, RoomReference, Span, Validation, ValidationContext, ValidationStep, VerifiedModel, } from './types.js';
+export { assess, bodyRoomLinks, checkDocument, resolves, roomReferences, sectionReferences, validate, validating, verdicts, verify, } from './validate.js';
+export type { Assessment, Verdicts } from './validate.js';
 export { VERSION } from './version.js';
-export { equalValue, frontmatterValue } from './yaml.js';
+export { bodyAfterFrontmatter, equalValue, frontmatterValue } from './yaml.js';
 export type { FrontmatterValue } from './yaml.js';

package/dist/mdmodel/links.d.ts

@@ -0,0 +1,28 @@
+export declare function escapes(text: string, index: number): boolean;
+export declare function spanCursor(spans: readonly (readonly [number, number])[]): (index: number) => number | undefined;
+export type HrefOccurrence = {
+    readonly href: string;
+    readonly start: number;
+    readonly end: number;
+    readonly bracketed: boolean;
+};
+export type LinkUse = {
+    readonly start: number;
+    readonly end: number;
+    readonly labelStart: number;
+    readonly labelEnd: number;
+    readonly destination: HrefOccurrence;
+};
+export type DefinitionBlock = {
+    readonly start: number;
+    readonly end: number;
+    readonly destination: HrefOccurrence;
+};
+export type LinkInventory = {
+    readonly uses: readonly LinkUse[];
+    readonly blocks: readonly DefinitionBlock[];
+};
+export declare function fenceSpans(text: string): readonly (readonly [number, number])[];
+export declare function linkInventory(body: string): LinkInventory;
+export declare function destinations(inventory: LinkInventory): readonly HrefOccurrence[];
+export declare function hrefOccurrences(body: string): readonly HrefOccurrence[];

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

@@ -13,13 +13,14 @@ export type ModelVerification = {
 };
 export type ValidationContext = {
     readonly binaryTargets: readonly string[];
+    readonly anyRoom?: true;
 };
 export type ProjectionContext = {
     readonly documentTargets: readonly string[];
     readonly definition?: Definition;
 };
 export type DivisionContext = ProjectionContext & {
-    readonly budget: number;
+    readonly bound: number;
 };
 export type Extent = {
     readonly start: number;
@@ -60,6 +61,10 @@ export type Validation = {
 } | ({
     readonly verdict: 'refuse';
 } & Refusal);
+export type ValidationStep = {
+    readonly path: string;
+    readonly resolved: number;
+};
 export type Projection = {
     readonly ok: true;
     readonly text: string;
@@ -92,14 +97,31 @@ export type Link = {
     readonly href: string;
     readonly target: string;
 };
-export type LinkOccurrence = Link & {
-    readonly start: number;
-};
 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 crossRoom?: true;
+} | {
+    readonly kind: 'item';
+    readonly section: string;
+    readonly href: string;
+    readonly to: readonly string[];
+    readonly crossRoom?: true;
+});
 export type Change = {
     readonly kind: 'field';
     readonly name: string;
@@ -130,6 +152,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,31 @@
 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, ValidationStep, 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 verify(schema: string, provided?: VerifiedModel): ModelVerification;
+export declare function checkDocument(file: string, content: string, model: VerifiedModel, context?: Pick<ValidationContext, 'anyRoom'>): 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[];
+type Placed = {
+    readonly reference: Reached;
+    readonly location: string;
+};
+export type Assessment = {
+    readonly file: string;
+    readonly type: string | undefined;
+    readonly targets: readonly string[];
+    readonly read: Validation | null;
+    readonly structured: Validation | null;
+    readonly fields: readonly Placed[];
+    readonly linked: boolean;
+    readonly sections: readonly Placed[];
+};
+export declare function assess(file: string, content: string, binary: boolean, model?: VerifiedModel, context?: Pick<ValidationContext, 'anyRoom'>): Assessment;
+export type Verdicts = {
+    add(assessment: Assessment, typeOf: (path: string) => string | undefined, binary: (path: string) => boolean): number;
+    verdict(): Validation;
+};
+export declare function verdicts(): Verdicts;
+export declare function validating(library: ReadonlyMap<string, string>, context?: ValidationContext, model?: VerifiedModel): Generator<ValidationStep, Validation, void>;
 export declare function validate(library: Library, context?: ValidationContext, model?: VerifiedModel): Validation;
+export {};

package/dist/mdruntime/adapter.d.ts

@@ -10,14 +10,13 @@ export type TypedSelection = {
     roots: readonly string[];
 };
 export type OperationScopes = {
-    read: readonly string[];
-    sync: readonly string[];
     write: readonly string[];
     delete: readonly string[];
 };
 export type ReplicaAdmission = {
     selection: string;
     admission: Open<'admitted' | 'unavailable'>;
+    offline: Open<'locked' | 'open'>;
 };
 export type DiscoveredRoom = {
     name: string;
@@ -49,8 +48,9 @@ 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 ConversationAction = 'conversation.create' | 'conversation.send' | 'conversation.attach' | 'conversation.answer' | 'conversation.interrupt' | 'conversation.kill' | 'conversation.cancel' | 'conversation.delete' | 'conversation.history';
 export type ConversationMessage = {
     identity: string;
     turn: string;
@@ -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;
@@ -187,6 +199,7 @@ export type ActionDeclaration = {
     name: string;
     inputShape: unknown;
     resultKind: unknown;
+    room?: string;
 };
 export type ProviderLimit = {
     name: string;
@@ -210,6 +223,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 +246,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 & {
@@ -238,7 +255,7 @@ export type ContractUnavailable = ProviderRefusal & {
 export type DiscoverResult = Discovery | TransportUncertainty | RevokedAuthorization | ContractUnavailable;
 export type PageToken = string;
 export type ChangeAuthor = {
-    kind: Open<'user' | 'site'>;
+    kind: Open<'user' | 'site' | 'inbox'>;
     id: string;
     name: string;
 };
@@ -257,9 +274,16 @@ export type BinaryFile = {
     mediaType: string;
     sha256: string;
 };
+export type HeldFile = {
+    readonly path: string;
+    readonly revision: string;
+};
 export type HeldContent = {
-    documents: Readonly<Record<string, string>>;
-    revisions: Readonly<Record<string, string>>;
+    files(after: string | null, limit: number): Promise<readonly HeldFile[]>;
+    contents(paths: readonly string[]): Promise<ReadonlyMap<string, {
+        readonly content: string;
+        readonly revision: string;
+    }>>;
 };
 export type BootstrapRequest = {
     locator: string;
@@ -277,8 +301,10 @@ export type BootstrapPage = {
     models?: RoomModels;
     documents: Readonly<Record<string, string>>;
     revisions: Readonly<Record<string, string>>;
+    fileIds?: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
     binaryFiles: Readonly<Record<string, BinaryFile>>;
+    folders?: readonly string[];
     pageToken?: PageToken;
 };
 export type BootstrapResult = BootstrapPage | {
@@ -296,9 +322,12 @@ export type RefreshPage = {
     models?: RoomModels;
     documents: Readonly<Record<string, string>>;
     revisions: Readonly<Record<string, string>>;
+    fileIds?: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
     binaryFiles: Readonly<Record<string, BinaryFile>>;
     removals: readonly string[];
+    folders?: readonly string[];
+    folderRemovals?: readonly string[];
     pageToken?: PageToken;
 };
 export type RefreshResult = {
@@ -309,6 +338,7 @@ export type RefreshResult = {
 export type MutationRequest = {
     locator: string;
     changeBatch: ChangeBatch;
+    file(localId: string): Promise<Blob>;
     upload?: unknown;
 };
 export type RetryableRefusal = ProviderRefusal & {
@@ -319,17 +349,21 @@ export type ServiceMode = Open<'open' | 'write-halted'>;
 export type ServiceModeSignal = {
     observe(notify: (mode: ServiceMode) => void): () => void;
 };
-export type MutationResult = {
-    kind: 'accepted';
+export type AcceptedRoom = {
     roomVersion: string;
     documents: Readonly<Record<string, string>>;
     revisions: Readonly<Record<string, string>>;
+    fileIds?: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
     removals: readonly string[];
     binaryFiles?: Readonly<Record<string, BinaryFile>>;
+};
+export type MutationResult = (AcceptedRoom & {
+    kind: 'accepted';
     author?: string;
     time?: string;
-} | (ProviderRefusal & {
+    destination?: AcceptedRoom;
+}) | (ProviderRefusal & {
     kind: 'conflicted';
     roomVersion?: string;
     affected: Readonly<Record<string, string>>;
@@ -346,7 +380,7 @@ export type HistoryAuthor = {
     kind: 'user';
     id: string;
 } | {
-    kind: 'site';
+    kind: 'site' | 'inbox';
     id: string;
     name: string;
 };
@@ -385,15 +419,21 @@ export type BinaryRequest = {
     referrer: unknown;
 };
 export type ReferrerScope = {
-    kind: 'room';
     locator: string;
     path?: string;
-} | {
-    kind: 'conversations';
 };
 export type BinaryResult = {
     kind: 'binary';
-    blob: Blob;
+    body: ReadableStream<Uint8Array>;
+    mediaType: string;
+    sha256?: string;
+} | (ProviderRefusal & {
+    kind: 'rejected';
+}) | AdapterFailure;
+export type BinaryLinkResult = {
+    kind: 'link';
+    url: string;
+    name: string;
 } | (ProviderRefusal & {
     kind: 'rejected';
 }) | AdapterFailure;
@@ -415,17 +455,20 @@ export type ActionResult = {
 export type HeldRoom = {
     locator: string;
     roomVersion: string;
-    documents: Readonly<Record<string, string>>;
-    revisions: Readonly<Record<string, string>>;
 };
+export type HeldRevisions = (locator: string, paths: readonly string[]) => Promise<ReadonlyMap<string, string>>;
 export type RoomStreamEvent = {
     kind: 'opened';
 } | {
     kind: 'closed';
     revoked: boolean;
+    lost: boolean;
 } | {
     kind: 'opening';
     expired: readonly string[];
+} | {
+    kind: 'authority-changed';
+    scope?: DiscoveryScope;
 } | {
     kind: 'room-version';
     locator: string;
@@ -444,26 +487,26 @@ 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;
+    observe(notify: (event: RoomStreamEvent) => void, receipts: StreamReceipts, revisions: HeldRevisions): () => void;
 };
 export type Adapter = {
     readonly localSaves?: true;
     readonly exhaustiveDiscovery?: true;
+    readonly roomTypes?: string;
     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/chain.d.ts

@@ -0,0 +1,10 @@
+import type { MdRuntimeClient } from './client.js';
+import type { DocumentQuery, DocumentResult, GroupQuery, GroupResult, PendingResult } from './query.js';
+type Rows = DocumentResult | GroupResult;
+export type WindowAnswer = Rows | PendingResult;
+export type WindowChain = {
+    want(count: number): void;
+    close(): void;
+};
+export declare function chainedWindows(runtime: MdRuntimeClient, query: DocumentQuery | GroupQuery, count: number, publish: (answers: readonly (WindowAnswer | null)[], settled: boolean) => void): WindowChain;
+export {};

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

@@ -1,10 +1,6 @@
-import { type Replica } from './replica.js';
-import { type Row } from './rows.js';
 export type DocumentChange = {
-    locator: string;
-    path: string;
-    before: readonly Row[];
-    after: readonly Row[];
+    readonly locator: string;
+    readonly path: string | null;
 };
 export type MessageChange = {
     conversation: string;
@@ -23,12 +19,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 = {
+    documents?: readonly string[] | null;
     drafts?: readonly string[];
     room?: boolean;
     queue?: boolean;
     presentation?: string;
-}): ChangeSet;
-export declare function entering(locator: string, replica: Replica, paths: readonly string[]): ChangeSet;
+};
+export declare function changeSet(locator: string, changed?: Changed): ChangeSet;
 export declare function conversationChangeSet(messages: readonly MessageChange[], conversations: readonly string[]): ChangeSet;
 export declare function mergeChangeSets(sets: readonly ChangeSet[]): ChangeSet;
+export declare function touches(set: ChangeSet, locator: string, path: string): boolean;
+export {};