@agentshouse/app-bridge 0.1.0-ccf413b4e709d → 0.1.0-cd2d3edbf9805

package/dist/calls.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,5 +1,18 @@
-import type { MdRuntimeClient } from '@agentshouse/mdruntime/client';
-type Open<Value extends string> = Value | (string & {});
+import type { MdRuntimeClient, Open } from './mdruntime/client.js';
+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 HouseMethods>>(method: Name, params: HouseParams<Name>): Promise<HouseResult<Name>>;
+}
 export interface HouseSyncState {
     readonly state: string;
     readonly providerUnreachable: boolean;
@@ -8,6 +21,7 @@ export interface HouseCredentialState {
     readonly state: Open<'none' | 'held' | 'rejected'>;
     readonly expiresAt: number | null;
 }
+export type HouseDatabaseFailure = 'unsupported' | 'damaged';
 export type HouseAnalyticsChoice = 'accept' | 'decline';
 export interface HouseAnalytics {
     readonly measures: boolean;
@@ -27,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;
@@ -65,8 +80,7 @@ export interface HouseExternalRequest {
     readonly headers?: Readonly<Record<string, string>>;
     readonly body?: string;
     readonly body_base64?: string;
-    readonly account?: string;
-    readonly slot?: string;
+    readonly room_ref?: string;
 }
 export type HouseExternalAnswer = {
     readonly status: number;
@@ -104,8 +118,32 @@ export interface HouseBrowserRefused extends Error {
     readonly code: string;
     readonly retryable: boolean;
 }
+export interface HouseCooperation {
+    placed(): Promise<void> | void;
+}
+export type HouseChatWidth = 'full' | '3/4' | '1/2' | '1/3';
+export interface HouseChatOpened {
+    readonly conversation: string | null;
+    readonly agent: string | null;
+}
+export interface HouseChatOptions {
+    readonly conversation?: string | null;
+    readonly agent?: string | null;
+    readonly showChats?: boolean;
+    readonly width?: HouseChatWidth;
+    readonly onOpen?: (opened: HouseChatOpened) => void;
+    readonly onLink?: (href: string) => void;
+}
+export interface HouseMountedChat {
+    update(options: HouseChatOptions): void;
+    unmount(): void;
+}
+export interface HouseChat {
+    mount(element: object, options?: HouseChatOptions): Promise<HouseMountedChat>;
+}
 export interface HouseBridge {
-    readonly runtime: Promise<MdRuntimeClient>;
+    readonly runtime: Promise<HouseRuntime>;
+    readonly chat: HouseChat;
     address(): string | null;
     onAddress(listener: (address: string) => void): () => void;
     push(address: string): Promise<string>;
@@ -124,9 +162,9 @@ export interface HouseBridge {
     onStatus(listener: (status: HouseStatus) => void): () => void;
     messages(listener: (message: HouseAppMessage) => void): () => void;
     analyticsConsent(choice: HouseAnalyticsChoice): void;
+    cooperate(cooperation: HouseCooperation): () => void;
 }
 export interface HouseHeld {
     readonly houseBridge: HouseBridge;
 }
 export declare const houseBridge: () => HouseBridge;
-export {};

package/dist/mdmodel/blocks.d.ts

@@ -0,0 +1,10 @@
+import type { Extent } from './types.js';
+export type HeadingLine = {
+    readonly level: number;
+    readonly name: string;
+    readonly start: number;
+    readonly textEnd: number;
+    readonly next: number;
+};
+export declare function headingLines(content: string, from: number, to: number): HeadingLine[];
+export declare function blockRanges(content: string, from: number, to: number): Extent[];

package/dist/mdmodel/condition.d.ts

@@ -0,0 +1,167 @@
+import { type Definition, type ValueFacts } from './definition.js';
+import type { Document, VerifiedModel } from './types.js';
+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[];
+} | {
+    readonly any: readonly ConditionTest[];
+} | {
+    readonly not: ConditionTest;
+} | ({
+    readonly path: string;
+} & ({
+    readonly eq: ConditionValue;
+} | {
+    readonly in: readonly ConditionValue[];
+} | {
+    readonly exists: boolean;
+} | {
+    readonly contains: ConditionValue;
+} | {
+    readonly gt: number | string;
+} | {
+    readonly gte: number | string;
+} | {
+    readonly lt: number | string;
+} | {
+    readonly lte: number | string;
+} | {
+    readonly prefix: string;
+}));
+export type ConditionScope = {
+    readonly type: string;
+} | {
+    readonly folder: string;
+} | {
+    readonly document: string;
+};
+type DocumentEventBase = {
+    readonly on: 'documents';
+    readonly scope: ConditionScope;
+    readonly by?: ConditionTest;
+    readonly moved_between_rooms?: boolean;
+};
+export type DocumentCondition = (DocumentEventBase & {
+    readonly mode: 'starts_matching';
+    readonly new_documents: boolean;
+    readonly match: ConditionTest;
+}) | (DocumentEventBase & {
+    readonly mode: 'field_changes';
+    readonly field: string;
+    readonly from?: readonly ConditionValue[] | 'new';
+    readonly to?: readonly ConditionValue[] | 'deleted';
+    readonly match?: ConditionTest;
+});
+export type ItemCondition = {
+    readonly on: 'items';
+    readonly source?: string;
+    readonly address?: string;
+    readonly match?: ConditionTest;
+};
+export type CronCondition = {
+    readonly on: 'clock';
+    readonly cron: string;
+    readonly time_zone: string;
+};
+export type DateCondition = {
+    readonly on: 'clock';
+    readonly scope: {
+        readonly type: string;
+    };
+    readonly date: string;
+    readonly days: number;
+    readonly at: string;
+    readonly time_zone: string;
+    readonly match?: ConditionTest;
+};
+export type NotificationCondition = {
+    readonly on: 'notifications';
+    readonly match?: ConditionTest;
+};
+export type Condition = DocumentCondition | ItemCondition | CronCondition | DateCondition | NotificationCondition;
+export type FactKind = 'string' | 'number' | 'boolean' | 'date' | 'time' | 'enum' | 'reference';
+type Scalar = string | number | boolean;
+export type Fact = {
+    readonly kind: FactKind;
+    readonly value: Scalar;
+    readonly member?: string;
+} | {
+    readonly kind: 'prose';
+} | {
+    readonly kind: 'null';
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'list';
+    readonly items: readonly Fact[];
+} | {
+    readonly kind: 'object';
+    readonly fields: Readonly<Record<string, Fact>>;
+};
+export type DocumentFacts = {
+    readonly id: string;
+    readonly path: string;
+    readonly type: string | null;
+    readonly fields: Readonly<Record<string, Fact>>;
+    readonly sections: readonly string[];
+};
+export declare const TEXT_FIELD = "/text";
+export declare const WRITE_DOORS: readonly ['browser', 'agent', 'client', 'function'];
+export type WriteDoor = (typeof WRITE_DOORS)[number];
+export type Actor = {
+    readonly user?: string;
+    readonly site?: string;
+    readonly app?: string;
+    readonly door?: WriteDoor;
+};
+export type DocumentEvent = {
+    readonly before: DocumentFacts | null;
+    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 container: string | null;
+    readonly author: string | null;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly json: {
+        readonly value: unknown;
+    } | null;
+};
+export type Resolved = {
+    readonly id: string;
+    readonly member?: string;
+};
+type Truth = boolean | undefined;
+export declare function factKind(facts: ValueFacts): FactKind | null;
+export declare function facts(document: Document, at: {
+    readonly id: string;
+    readonly path: string;
+}, 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 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 declare function notificationFires(condition: NotificationCondition, notification: DocumentFacts): boolean;
+export {};

package/dist/mdmodel/definition.d.ts

@@ -0,0 +1,81 @@
+import type { VerifiedModel } from './types.js';
+export type JsonType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+export type ValueFacts = {
+    readonly type?: JsonType;
+    readonly format?: string;
+    readonly values?: readonly unknown[];
+    readonly reference?: readonly string[];
+    readonly crossRoom?: true;
+    readonly prose: boolean;
+    readonly conditional?: true;
+    readonly prefix?: readonly ValueFacts[];
+    readonly items?: ValueFacts;
+    readonly properties?: Readonly<Record<string, ValueFacts>>;
+    readonly patterns?: readonly PatternFacts[];
+    readonly additional?: ValueFacts;
+};
+export type PatternFacts = {
+    readonly pattern: string;
+    readonly facts: ValueFacts;
+};
+export type SectionSpec = {
+    readonly kind: 'text';
+    readonly required: boolean;
+} | {
+    readonly kind: 'list';
+    readonly required: boolean;
+    readonly items: ValueFacts;
+};
+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 = {
+    readonly rule: string;
+    readonly location?: string;
+};
+export declare const JSON_TYPES: readonly JsonType[];
+export declare const BUILT_IN_TYPE = "any";
+export declare const ATTACHMENT = "attachment";
+export declare const ARRAY_INDEX: RegExp;
+export declare const JSON_POINTER: RegExp;
+export declare function escapePointer(key: string): string;
+export declare function pointerSegments(pointer: string): string[];
+export declare function refTarget(reference: string, defs: Readonly<Record<string, unknown>>): {
+    readonly name: string;
+    readonly node: unknown;
+} | undefined;
+export declare function valueFacts(node: unknown, defs: Readonly<Record<string, unknown>>): ValueFacts;
+export declare function itemFacts(facts: ValueFacts, index: number): ValueFacts | undefined;
+export declare function memberFacts(facts: ValueFacts, key: string): ValueFacts | undefined;
+export type PointerFacts = {
+    readonly facts: ValueFacts;
+    readonly through: boolean;
+    readonly conditional: boolean;
+};
+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, provided?: VerifiedModel): VerifiedModel | Failure;

package/dist/mdmodel/divide.d.ts

@@ -0,0 +1,2 @@
+import type { Division, DivisionContext, Document } from './types.js';
+export declare function divide(document: Document, file: string, context: DivisionContext): Division;

package/dist/mdmodel/document.d.ts

@@ -0,0 +1,15 @@
+import { type Definition } from './definition.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, 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 bodyLinks(body: string, file: string): readonly Link[];
+export declare function apply(document: Document, changes: readonly Change[]): ApplyResult;
+export declare function serialize(document: Document): string;
+export declare function frontmatter(document: Document): YamlMap | null;

package/dist/mdmodel/fields.d.ts

@@ -0,0 +1,5 @@
+export declare const TYPE_FIELD = "type";
+export declare const MEMBER_FIELD = "member";
+export declare const SITE_FIELD = "site";
+export declare const RECEIVED_FIELD = "received";
+export declare const HOUSE_FIELDS: readonly string[];

package/dist/mdmodel/index.d.ts

@@ -0,0 +1,20 @@
+export { ACTOR_PATHS, actorOperators, changeFields, CONDITION_OPERATORS, dated, datePointers, DOCUMENT_PATHS, factKind, facts, fires, holds, instant, ITEM_PATHS, itemFires, itemKind, itemOperators, memberPointers, members, notificationFires, pointed, prosePaths, testOperators, TEXT_FIELD, valuedChange, WRITE_DOORS, } from './condition.js';
+export type { Actor, Condition, ConditionOperator, ConditionScope, ConditionTest, ConditionValue, CronCondition, DateCondition, DocumentCondition, DocumentEvent, DocumentFacts, Fact, FactKind, ItemCondition, ItemFacts, NotificationCondition, Resolved, WriteDoor, } from './condition.js';
+export { headingLines } from './blocks.js';
+export type { HeadingLine } from './blocks.js';
+export { divide } from './divide.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, 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, JSON_POINTER, 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, 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 { 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

@@ -0,0 +1,25 @@
+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;
+export declare const SHELL_ROOMS = "/rooms/";
+export declare function shellTarget(href: string, handle: string): string | null;

package/dist/mdmodel/profile.d.ts

@@ -0,0 +1,5 @@
+export declare const MARKDOWN_SYNTAX_PROFILE: {
+    readonly name: 'GitHub Flavored Markdown';
+    readonly spec: '0.29';
+    readonly url: 'https://github.github.com/gfm/';
+};

package/dist/mdmodel/project.d.ts

@@ -0,0 +1,21 @@
+import type { Document, Extent, Projection, ProjectionContext, Refusal } from './types.js';
+export type Piece = Extent & {
+    readonly text: string;
+};
+export type Edit = Piece;
+export type Input = {
+    readonly values: readonly Piece[];
+    readonly ranges: readonly Extent[];
+    readonly edits: readonly Edit[];
+};
+export type InputResult = {
+    readonly ok: true;
+    readonly input: Input;
+} | {
+    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/references.d.ts

@@ -0,0 +1,3 @@
+import { type Definition } from './definition.js';
+import type { Frontmatter, Reference } from './types.js';
+export declare function references(document: Pick<Frontmatter, 'fields'>, definition: Definition): readonly Reference[];

package/dist/mdmodel/types.d.ts

@@ -0,0 +1,167 @@
+import type { Definition } from './definition.js';
+export type Library = Readonly<Record<string, string>>;
+export type VerifiedModel = {
+    readonly types: Readonly<Record<string, Definition>>;
+    readonly nameable?: readonly string[];
+};
+export type ModelVerification = {
+    readonly verdict: 'accept';
+    readonly model: VerifiedModel;
+} | {
+    readonly verdict: 'refuse';
+    readonly rule: string;
+    readonly location?: string;
+};
+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 bound: number;
+};
+export type Extent = {
+    readonly start: number;
+    readonly end: number;
+};
+export type Span = Extent & {
+    readonly text: string;
+};
+export type Frontmatter = {
+    readonly content: string;
+    readonly type: string | undefined;
+    readonly fields: Readonly<Record<string, unknown>>;
+};
+export type Document = Frontmatter & {
+    readonly preamble: string;
+    readonly sections: Readonly<Record<string, string>>;
+};
+export type Refusal = {
+    readonly file: string;
+    readonly rule: string;
+    readonly location?: string;
+    readonly referrers?: readonly string[];
+};
+export type Reached = {
+    readonly target: string | null;
+    readonly to: readonly string[];
+};
+export type DocumentCheck = {
+    readonly ok: false;
+} | {
+    readonly ok: true;
+    readonly type: string;
+    readonly typed: boolean;
+    readonly references: readonly Reached[];
+};
+export type Validation = {
+    readonly verdict: 'accept';
+} | ({
+    readonly verdict: 'refuse';
+} & Refusal);
+export type ValidationStep = {
+    readonly path: string;
+    readonly resolved: number;
+};
+export type Projection = {
+    readonly ok: true;
+    readonly text: string;
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+export type Division = {
+    readonly ok: true;
+    readonly spans: readonly Span[];
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+export type FrontmatterResult = {
+    readonly ok: true;
+    readonly frontmatter: Frontmatter;
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+export type ParseResult = {
+    readonly ok: true;
+    readonly document: Document;
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+export type Link = {
+    readonly href: string;
+    readonly target: string;
+};
+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;
+    readonly value: unknown;
+    readonly prior: unknown;
+} | {
+    readonly kind: 'section';
+    readonly name: string;
+    readonly value: string;
+    readonly prior: string;
+} | {
+    readonly kind: 'preamble';
+    readonly value: string;
+    readonly prior: string;
+} | {
+    readonly kind: 'link';
+    readonly href: string;
+    readonly to: string;
+} | {
+    readonly kind: 'reference';
+    readonly pointer: string;
+    readonly value: string;
+    readonly prior: string;
+};
+export type ApplyResult = {
+    readonly outcome: 'applied';
+    readonly document: Document;
+} | {
+    readonly outcome: 'stale';
+    readonly document: Document;
+    readonly stale: readonly number[];
+} | {
+    readonly outcome: 'refuse';
+    readonly refusal: Refusal;
+};
+export type BodyResult = {
+    readonly outcome: 'applied';
+    readonly body: string;
+} | {
+    readonly outcome: 'refuse';
+    readonly refusal: Refusal;
+};