@agentshouse/app-bridge 0.1.0-cd783686e8a2c → 0.1.0-cd8ceab09121a

package/dist/mdruntime/outcome.d.ts

@@ -0,0 +1,76 @@
+import type { ActionResult, AdapterFailure, BinaryLinkResult, HistoryResult, HistoryRevision, ProviderRefusal, RoomVersionAt, ScopedRefusal } from './adapter.js';
+import type { ChangeBatch } from './change.js';
+import type { KeptBinary, KeptResult } from './opened.js';
+type Refused<Kind extends string> = ProviderRefusal & {
+    kind: Kind;
+};
+export type Failure = Refused<'transport-uncertainty'> | Refused<'revoked-authorization'> | (Refused<'room-not-readable'> & {
+    locator: string;
+}) | (Refused<'room-locked'> & {
+    locator: string;
+}) | ScopedRefusal;
+export type CallResult = {
+    kind: 'action';
+    result: unknown;
+    at?: RoomVersionAt;
+} | Refused<'rejected'> | Refused<'undeclared'> | Failure;
+export type HistoryAnswer = Exclude<HistoryResult, {
+    kind: Failure['kind'];
+}> | Failure;
+type BinaryRefusal = Refused<'rejected'> | Refused<'absent'> | Failure;
+export type BinaryAnswer = {
+    kind: 'binary';
+    stream: ReadableStream<Uint8Array>;
+    byteLength: number;
+    mediaType: string;
+} | BinaryRefusal;
+export type HeldBinaryAnswer = KeptBinary | BinaryRefusal;
+export type BinaryLinkAnswer = {
+    kind: 'link';
+    url: string;
+    name: string;
+} | Refused<'rejected'> | Refused<'absent'> | Failure;
+export type Resolution = {
+    readonly kind: 'document';
+    readonly room: string;
+    readonly path: string;
+} | {
+    readonly kind: 'deleted';
+    readonly room: string;
+    readonly path: string;
+    readonly revision: HistoryRevision;
+} | Refused<'unreadable'> | Refused<'absent'> | Failure;
+export declare const UNREADABLE: Refused<'unreadable'>;
+export declare const LOCKED_UNREADABLE: Refused<'unreadable'>;
+export declare const ABSENT_TARGET: Refused<'absent'>;
+export declare function absentBinary(path: string): Refused<'absent'>;
+export declare function binaryAnswer(result: KeptResult): HeldBinaryAnswer;
+export declare function binaryLinkAnswer(result: BinaryLinkResult): BinaryLinkAnswer;
+export declare const ROOM_LOCKED = "room-locked";
+export declare function lockedRoom(locator: string): Refused<'room-locked'> & {
+    locator: string;
+};
+export type Offline = {
+    readonly kind: 'offline';
+};
+export declare const OFFLINE: Offline;
+export declare const UNCERTAIN: Failure;
+export declare function undeclared(name: string): CallResult;
+export declare function failure(result: AdapterFailure): Failure;
+export declare function calledResult(result: ActionResult): CallResult;
+export declare function historyAnswer(result: HistoryResult): HistoryAnswer;
+export type Submission = {
+    readonly state: 'waiting' | 'submitted';
+} | {
+    readonly state: 'reset';
+    readonly reset: string;
+};
+export type QueueEntry = {
+    readonly batch: ChangeBatch;
+} & (Submission | {
+    readonly state: 'local';
+} | {
+    readonly state: 'accepted';
+    readonly roomVersion: string;
+});
+export {};

package/dist/mdruntime/overlay.d.ts

@@ -0,0 +1,24 @@
+import type { BinaryFile, HeadChange } from './adapter.js';
+import type { ChangeBatch } from './change.js';
+export type Heads = {
+    revisions: Readonly<Record<string, string>>;
+    fileIds: Readonly<Record<string, string>>;
+    changes: Readonly<Record<string, HeadChange>>;
+};
+export type HeldBinary = ({
+    readonly state: 'accepted';
+} & BinaryFile) | {
+    readonly state: 'pending';
+    readonly localId: string;
+    readonly byteLength: number;
+    readonly mediaType: string;
+    readonly sha256: string;
+};
+export type Layer = Heads & {
+    documents: Readonly<Record<string, string>>;
+    binaries: Readonly<Record<string, HeldBinary>>;
+};
+export declare function acceptedBinaries(files: Readonly<Record<string, BinaryFile>>): Generator<readonly [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 overlaying(base: Layer, queue: readonly ChangeBatch[], unapplied?: () => void): Generator<number, Layer, void>;

package/dist/mdruntime/query.d.ts

@@ -0,0 +1,283 @@
+import { type Definition } from '../mdmodel/index.js';
+import type { HeadChange } from './adapter.js';
+import type { BinaryFileRecord } from './binary.js';
+import type { Open } from './open.js';
+export type Value = string | number | boolean | null;
+export type Predicate = Value | {
+    $eq: Value;
+} | {
+    $ne: Value;
+} | {
+    $in: readonly Value[];
+} | {
+    $nin: readonly Value[];
+} | {
+    $gt?: Value;
+    $gte?: Value;
+    $lt?: Value;
+    $lte?: Value;
+} | {
+    $all: readonly Value[];
+} | {
+    $size: number;
+} | {
+    $exists: boolean;
+};
+export type Where = {
+    $and?: readonly Where[];
+    $or?: readonly Where[];
+    [field: string]: Predicate | readonly Where[] | undefined;
+};
+export type Related = {
+    types?: readonly string[];
+    where?: Where;
+    pathPrefix?: string;
+};
+export type Filter = {
+    rooms?: readonly string[];
+    types?: readonly string[];
+    where?: Where;
+    pathPrefix?: string;
+    folder?: string;
+    paths?: readonly string[];
+    hop?: Related & {
+        field: string;
+    };
+    backlinks?: Related & {
+        field?: string;
+    };
+};
+export type Key = 'room' | 'path' | 'type' | 'folder' | {
+    field: string;
+};
+export type Select = 'all' | {
+    fields?: 'all' | readonly string[];
+    sections?: 'all' | readonly string[];
+    preamble?: true;
+    markdown?: true;
+    backlinks?: true;
+    change?: true;
+    fileId?: true;
+    revision?: true;
+};
+export type OrderOptions = {
+    nulls?: 'first' | 'last';
+    stringSort?: 'lexical' | 'locale';
+    locale?: string;
+    localeOptions?: Readonly<Record<string, unknown>>;
+};
+export type Direction = 'asc' | 'desc';
+export type DocumentQuery = Filter & {
+    select: Select;
+    orderBy?: readonly ({
+        by: Key;
+        direction?: Direction;
+    } & OrderOptions)[];
+    limit?: number;
+    after?: string;
+    total?: true;
+};
+export type GroupQuery = Filter & {
+    groupBy: readonly Exclude<Key, 'path'>[];
+    orderBy?: readonly {
+        by: 'count' | Exclude<Key, 'path'>;
+        direction?: Direction;
+    }[];
+    limit?: number;
+    after?: string;
+    total?: true;
+};
+export type LocalQuery = DocumentQuery | GroupQuery;
+export type Backlink = {
+    path: string;
+    type: string;
+    field: string;
+};
+export type QueryDocument = {
+    room: string;
+    path: string;
+    type?: string;
+    fields?: Readonly<Record<string, unknown>>;
+    sections?: Readonly<Record<string, string>>;
+    preamble?: string;
+    markdown?: string;
+    backlinks?: readonly Backlink[];
+    change?: HeadChange | null;
+    fileId?: string | null;
+    revision?: string | null;
+    binaryFile?: BinaryFileRecord;
+};
+export type QueryGroup = {
+    key: readonly unknown[];
+    count: number;
+};
+export type CoveredRoom = {
+    room: string;
+    generation: string;
+    current: boolean;
+};
+export type QueryCoverage = {
+    rooms: readonly CoveredRoom[];
+    indexes: readonly string[];
+    overlay: readonly string[];
+};
+export type Awaits = Open<'acquisition' | 'preparation' | 'unlock'>;
+export type PendingRoom = {
+    room: string;
+    awaits: Awaits;
+};
+export type PendingResult = {
+    pending: readonly PendingRoom[];
+};
+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 & {
+    coverage: QueryCoverage;
+};
+export type GroupResult = GroupRows & {
+    coverage: QueryCoverage;
+};
+export type QueryResult = DocumentResult | GroupResult | PendingResult;
+export type QueryErrorCode = 'invalid-query' | 'unknown-type' | 'unknown-field' | 'wrong-kind';
+export type RoomFacts = {
+    locator: string;
+    available: boolean;
+    types: readonly Definition[];
+};
+export type HeldRooms = {
+    listed: boolean;
+    rooms: readonly RoomFacts[];
+};
+export type Test = {
+    op: 'eq';
+    value: Value;
+} | {
+    op: 'ne';
+    value: Value;
+} | {
+    op: 'in';
+    values: readonly Value[];
+} | {
+    op: 'nin';
+    values: readonly Value[];
+} | {
+    op: 'range';
+    bounds: readonly (readonly ['gt' | 'gte' | 'lt' | 'lte', Value])[];
+} | {
+    op: 'all';
+    values: readonly Value[];
+} | {
+    op: 'size';
+    size: number;
+} | {
+    op: 'exists';
+    exists: boolean;
+};
+export type Condition = {
+    every: readonly Condition[];
+} | {
+    some: readonly Condition[];
+} | {
+    field: string;
+    test: Test;
+};
+export type Scope = {
+    types: readonly string[] | null;
+    where: Condition | null;
+    pathPrefix: string | null;
+};
+export type KeyPlan = {
+    of: 'room';
+} | {
+    of: 'path';
+} | {
+    of: 'type';
+} | {
+    of: 'folder';
+} | {
+    of: 'field';
+    field: string;
+};
+export type DocumentShape = {
+    kind: 'documents';
+    fields: 'all' | readonly string[] | null;
+    sections: 'all' | readonly string[] | null;
+    preamble: boolean;
+    markdown: boolean;
+    backlinks: boolean;
+    change: boolean;
+    fileId: boolean;
+    revision: boolean;
+    orderBy: readonly {
+        key: KeyPlan;
+        options: OrderOptions & {
+            direction: Direction;
+        };
+    }[];
+};
+export type GroupShape = {
+    kind: 'groups';
+    groupBy: readonly KeyPlan[];
+    orderBy: readonly {
+        by: 'count' | number;
+        direction: Direction;
+    }[];
+};
+export type PlanArea = {
+    room: string;
+    path: string;
+    types: readonly string[];
+};
+export type PlanReach = {
+    rooms: readonly string[];
+    documents: readonly string[];
+    areas: readonly PlanArea[];
+};
+export type Continuation = {
+    text: string;
+    values: readonly unknown[] | null;
+};
+export type Plan = {
+    key: string;
+    rooms: readonly string[] | null;
+    reach: PlanReach | null;
+    locked: readonly string[];
+    root: Scope;
+    folder: string | null;
+    paths: readonly string[] | null;
+    hop: (Scope & {
+        field: string;
+    }) | null;
+    backlinks: (Scope & {
+        field: string | null;
+    }) | null;
+    shape: DocumentShape | GroupShape;
+    limit: number | null;
+    after: Continuation | null;
+    total: boolean;
+};
+export declare class QueryError extends Error {
+    readonly code: QueryErrorCode;
+    readonly retryable = false;
+    constructor(code: QueryErrorCode, at: string, problem: string);
+}
+type Entries = Readonly<Record<string, unknown>>;
+export declare function invalid(at: string, problem: string): never;
+export declare function plain(value: unknown): value is Entries;
+export declare function known(value: Entries, allowed: readonly string[], at: string): void;
+export declare function flag(input: unknown, at: string): boolean;
+export declare function planOf(input: unknown, facts: HeldRooms, reach?: PlanReach | null): Plan;
+export declare function limitOf(input: unknown): number | null;
+export declare function filterOf(input: unknown, facts: HeldRooms, reach?: PlanReach | null): Plan;
+export declare function queryKey(query: unknown): string;
+export declare function identityOf(plan: Plan): string;
+export {};

package/dist/mdruntime/reach.d.ts

@@ -0,0 +1,52 @@
+import type { MdRuntime, ReadinessPort, RuntimeTopic } from './connection.js';
+import type { Plan, PlanReach, QueryResult } from './query.js';
+import type { Readiness } from './readiness.js';
+import { type SearchResult } from './search.js';
+export type ReachedDocument = {
+    readonly room: string;
+    readonly path: string;
+};
+export type ReachedArea = {
+    readonly room: string;
+    readonly path: string;
+    readonly types: readonly string[];
+};
+export type PortReach = {
+    readonly rooms: readonly string[];
+    readonly documents: readonly ReachedDocument[];
+    readonly areas?: readonly ReachedArea[];
+    readonly conversations: boolean;
+};
+export type Deliver = (message: unknown) => void;
+export type Watch = (topic: RuntimeTopic, input: readonly unknown[], deliver: Deliver) => () => void;
+export type RuntimeView = {
+    md: MdRuntime;
+    watch: Watch;
+};
+export type NarrowedView = RuntimeView & {
+    narrow(reach: PortReach | null): void;
+    facts(port: ReadinessPort): void;
+};
+export type Reachable = RuntimeView & {
+    plan(input: unknown, reach: PortReach | null): Plan;
+    query(plan: Plan): Promise<QueryResult>;
+    watchPlan(plan: Plan, deliver: (message: unknown) => void): () => void;
+    search(input: unknown, reach: PortReach | null, locked: readonly string[]): Promise<SearchResult>;
+    watchReadiness(port: ReadinessPort, reach: PortReach | null, deliver: (readiness: Readiness) => void): () => void;
+    locked(room: string): boolean;
+    lockedRooms(): readonly string[];
+    watchLocks(notify: () => void): () => void;
+    located(room: string, path: string, destination: string): ReachedDocument | null;
+};
+export declare function holds(reach: PortReach | null, room: string): boolean;
+export declare function governs(reach: PortReach | null, room: {
+    readonly locator: string;
+    readonly typedSelection: {
+        roots: readonly string[];
+    } | null;
+}): {
+    readonly collection: boolean;
+    readonly selection: boolean;
+};
+export declare function planReach(reach: PortReach | null): PlanReach | null;
+export declare function narrowed(runtime: Reachable, given: PortReach | null, told: ReadinessPort): NarrowedView;

package/dist/mdruntime/readiness.d.ts

@@ -0,0 +1,63 @@
+import type { Open } from './open.js';
+export type CodeAvailability = Open<'stored' | 'absent'>;
+export type RoomPreparation = Open<'complete' | 'acquiring' | 'preparing' | 'refused' | 'unadmitted'>;
+export type RoomCoverage = {
+    readonly room: string;
+    readonly state: RoomPreparation;
+};
+export type ConversationCoverage = Open<'complete' | 'acquiring' | 'undeclared'>;
+export type SearchObligation = Open<'required' | 'unused'>;
+export type TargetCoverage = {
+    readonly complete: boolean;
+    readonly listed: boolean;
+    readonly rooms: readonly RoomCoverage[];
+    readonly conversations: ConversationCoverage;
+    readonly search: SearchObligation;
+};
+export type Persistence = Open<'granted' | 'denied' | 'unavailable'>;
+export type Durability = Open<'persistent' | 'best-effort'>;
+export type ConnectionAvailability = Open<'connected' | 'connecting' | 'unreachable'>;
+export type HouseOutcome = Open<'open' | 'write-halted' | 'refused'>;
+export type Space = Open<'full'>;
+export type RefusedRoom = {
+    readonly room: string;
+    readonly name: string;
+    readonly file: string;
+    readonly rule: string;
+    readonly location: string | null;
+};
+export type InstallationStep = Open<'listing' | 'downloading' | 'writing' | 'replaying'>;
+export type InstallationPause = Open<'hidden'>;
+export type InstallationAmount = {
+    readonly done: number;
+    readonly total: number;
+};
+export type Installation = {
+    readonly step: InstallationStep | null;
+    readonly paused: InstallationPause | null;
+    readonly rooms: InstallationAmount;
+    readonly parts: InstallationAmount;
+    readonly bytes: InstallationAmount;
+    readonly received: InstallationAmount;
+};
+export type ReadinessStatus = Open<'preparing' | 'paused' | 'refused' | 'ready' | 'lost'>;
+export type Readiness = {
+    readonly status: ReadinessStatus;
+    readonly ready: boolean;
+    readonly usable: boolean;
+    readonly code: CodeAvailability;
+    readonly coverage: TargetCoverage;
+    readonly durability: Durability;
+    readonly persistence: Persistence;
+    readonly connection: ConnectionAvailability;
+    readonly house: HouseOutcome;
+    readonly space: Space | null;
+    readonly installation: Installation;
+    readonly refused: readonly RefusedRoom[];
+    readonly lost: boolean;
+};
+export type ReadinessFacts = Omit<Readiness, 'status' | 'ready' | 'usable' | 'durability' | 'coverage'> & {
+    readonly coverage: Omit<TargetCoverage, 'complete'>;
+    readonly established: boolean;
+};
+export declare function readinessOf(facts: ReadinessFacts): Readiness;

package/dist/mdruntime/recovery.d.ts

@@ -0,0 +1,24 @@
+export type Attempted = 'done' | 'again' | {
+    readonly at: number;
+};
+export type Attempt = (signal: AbortSignal) => Promise<Attempted>;
+export type AttemptOptions = {
+    readonly at?: number;
+    readonly again?: boolean;
+};
+export type RecoveryOptions = {
+    readonly firstMs?: number;
+    readonly maxMs?: number;
+    readonly attempts?: number;
+    readonly inFlight?: number;
+};
+export type Recovery = {
+    attempt(intent: string, run: Attempt, options?: AttemptOptions): Promise<boolean>;
+    pending(intent: string): boolean;
+    resume(): void;
+    cancel(intent: string): void;
+    scope(inFlight?: number): Recovery;
+    retire(): Promise<void>;
+};
+export declare function retryDelay(tries: number, firstMs?: number, maxMs?: number): number;
+export declare function createRecovery(options?: RecoveryOptions): Recovery;

package/dist/mdruntime/replica.d.ts

@@ -0,0 +1,68 @@
+import type { BootstrapInventory, MutationResult, OperationScopes, ReplicaAdmission, TypedSelection } from './adapter.js';
+import { type ChangeBatch, type Precondition } from './change.js';
+import { type Collection, type Composition } from './collection.js';
+import type { ModelState } from './model.js';
+import { type Layer } from './overlay.js';
+import type { HeldEntry, OverlayEntry, StoredEntry } from './tables.js';
+export type ReplicaRecord = {
+    readonly locator: string;
+    readonly name: string;
+    readonly handle: string;
+    readonly operations: OperationScopes;
+    readonly replica: ReplicaAdmission;
+    readonly model: ModelState;
+    readonly typedSelection: TypedSelection | null;
+    readonly providerOwnedPaths: readonly string[];
+    readonly roomVersion: string;
+    readonly transfer: string;
+    readonly inventory: BootstrapInventory | null;
+    readonly key: number;
+};
+export type HeldReplica = {
+    readonly record: ReplicaRecord;
+    readonly queue: readonly ChangeBatch[];
+    readonly overlaid: ReadonlySet<string>;
+    readonly count: number;
+    readonly confirmed: number;
+    readonly indexed: boolean;
+};
+export type VisibleLayer = Layer & {
+    readonly collection: Collection;
+};
+export type Slice = Layer & {
+    readonly written: Readonly<Record<string, string>>;
+    readonly held: ReadonlySet<string>;
+};
+export declare function compositionOf(record: Pick<ReplicaRecord, 'model' | 'typedSelection'>, builtIn: ModelState): Composition;
+export declare function sameMembership(record: Pick<ReplicaRecord, 'typedSelection'>, other: Pick<ReplicaRecord, 'typedSelection'>): boolean;
+export declare function storedRecord(record: ReplicaRecord): string;
+export declare function slicing(entries: readonly HeldEntry[], paths: Iterable<string>): Generator<number, Slice, void>;
+export declare function entryAt(layer: Layer & {
+    readonly written?: Readonly<Record<string, string>>;
+}, path: string): StoredEntry | null;
+export declare function slicingWith(slice: Slice, set: readonly StoredEntry[], removed: readonly string[]): Generator<number, Slice, void>;
+export declare function touchedBy(queue: readonly ChangeBatch[]): Set<string>;
+export declare function movedBy(queue: readonly ChangeBatch[], locator: string): Set<string>;
+export type Replayed = {
+    readonly visible: VisibleLayer;
+    readonly touched: ReadonlySet<string>;
+};
+export declare function replaying(confirmed: Slice, queue: readonly ChangeBatch[], locator: string, composition: Composition): Generator<number, Replayed, void>;
+export declare function overlayOf(visible: Layer, touched: Iterable<string>): Generator<number, OverlayEntry[], void>;
+export declare function holds(layer: Layer, preconditions: readonly Precondition[]): boolean;
+export declare function landed(batch: ChangeBatch, confirmed: Layer, current?: Readonly<Record<string, string>>): boolean;
+export type Standing = {
+    readonly withdrawn: readonly ChangeBatch[];
+    readonly kept: readonly ChangeBatch[];
+};
+export declare function standing(confirmed: Slice, queue: readonly ChangeBatch[], withdrawable: (batch: ChangeBatch) => boolean, local: boolean, locator: string, composition: Composition): Generator<number, Standing, void>;
+type Accepted = Extract<MutationResult, {
+    kind: 'accepted';
+}>;
+export type Returned = {
+    readonly set: readonly StoredEntry[];
+    readonly removed: readonly string[];
+};
+export declare function returnedPaths(submitted: ChangeBatch, accepted: Accepted): Set<string>;
+export declare function returning(confirmed: Slice, submitted: ChangeBatch, accepted: Accepted, writtenAt: string): Generator<number, Returned, void>;
+export {};