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

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';
 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;
@@ -70,8 +80,6 @@ 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 = {
@@ -110,22 +118,32 @@ export interface HouseBrowserRefused extends Error {
     readonly code: string;
     readonly retryable: boolean;
 }
-export interface HouseTrialWithheld {
-    readonly code: Open<'house_trial_withheld'>;
-    readonly retryable: true;
-}
-export type HouseTask = unknown;
-export type HouseActivation = Open<'committed' | 'abandoned'>;
 export interface HouseCooperation {
-    checkpoint(): Promise<void> | void;
-    persist(): Promise<void> | void;
-    capture(): Promise<HouseTask> | HouseTask;
-    restore(task: HouseTask | null): Promise<void> | void;
-    ready(): Promise<boolean> | boolean;
-    settle(activation: HouseActivation): void;
+    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<HouseRuntime>;
+    readonly chat: HouseChat;
     address(): string | null;
     onAddress(listener: (address: string) => void): () => void;
     push(address: string): Promise<string>;

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';
@@ -102,11 +103,13 @@ export type DocumentFacts = {
     readonly fields: Readonly<Record<string, Fact>>;
     readonly sections: readonly string[];
 };
-export declare const WRITE_DOORS: readonly ['browser', 'agent', 'client'];
+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 = {
@@ -114,13 +117,12 @@ 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 +142,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[];
@@ -59,6 +60,7 @@ 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>>): {
@@ -76,4 +78,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, 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, 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 { 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, 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, 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

@@ -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

@@ -2,6 +2,7 @@ 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';
@@ -13,13 +14,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 +62,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 +98,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 +153,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 {};