@agentshouse/app-bridge 0.1.0-alpha.9 → 0.1.0-c094380be07ea

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton (trof3039)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,70 +1,26 @@
 # @agentshouse/app-bridge
 
-The renderer-side client of the agents.house App bridge. An App served by House
-receives one message port before its own scripts run; this package is that
-port's one listener. It carries six families:
+The types of the agents.house App bridge, an accessor and an in-page test host.
+House builds the bridge object in every App it serves and hands it to the page
+before the App's own scripts run; `houseBridge()` returns that object, so an App
+carries no bridge code of its own. It carries eleven families: navigation,
+ceremonies, installation, notifications, status, Site image reads, App release
+code, external calls, App messages and App and Site screenshot reads.
+[docs/families.md](docs/families.md) describes each and the test host.
 
-- **Navigation** - the part of the shell's URL below the App's path, with its
-  query and fragment. The shell delivers it when the App starts and whenever the
-  User navigates; the App asks the shell to push or replace it. The App also
-  sets its tab's title and icon with `setTab({ title, icon })`, either or both:
-  a title of at most 200 characters and an icon given as a base64 `data:` URL
-  of an SVG, PNG, GIF or WebP image of at most 1,048,576 characters. The shell
-  shows them over the App's display name, or a Site's title, and its tab icon
-  until the next load, and ignores a request outside those bounds.
-- **Ceremony** - the App asks the shell to leave for one of House's own
-  purpose-bound authenticated pages. The shell navigates only to a same-origin
-  absolute path, carries its current address as the return target, and the page
-  returns there when it completes. An App names an address House gave it in a
-  reading and composes none.
-- **Installation** - `install()` offers the page as a Home-screen app. Where the
-  browser has an install prompt ready the shell shows it and the call resolves
-  `'accepted'` or `'dismissed'` with the User's choice, spending that prompt;
-  otherwise, as on every iPhone and iPad, it resolves `'manual'` and the App
-  shows its own instructions. A prompt the browser refuses to show, as for a
-  call made without a click, rejects with the browser's own `DOMException`
-  and stays ready. Call it from a click. The standard
-  `display-mode: standalone` media query tells the App it runs installed.
-- **Status** - the App reference the Runtime port is attached under, sync
-  state, credential state, release availability and observed failure, `ga`:
-  whether the page measures and the visitor's stored analytics choice, and
-  `service_mode`: `open`, `write-halted` while House refuses writes, so the
-  App can stop retrying them, or `null` while the runtime holds no House
-  connection.
-  The App reports the visitor's choice with `gaConsent('accept')` or
-  `gaConsent('decline')`; the shell hands it to House's analytics loader, and
-  the choice never reaches House.
-- **Site image read** - given a Published Room and an original attachment
-  reference, it answers the web copy's path and metadata, or `null` when no
-  copy exists. The original bytes never cross this bridge at a Site.
-- **App release code** - `sourceTop(app, release)` answers the top level of
-  the latest successful release of an App the User may use: its folders, its
-  files with their sizes and its root README's text, or `null` for none;
-  `sourceDownload(app, release)` answers every file of that release with its
-  path, its size and its `text`, or its bytes as `base64`. The browser keeps
-  each answer per App and release: a read naming a release it holds answers
-  without asking House, and keeping a newer release drops the earlier one. A
-  refusal is House's `{ error: { code } }`, `app_release_not_found` for an
-  App with no release; a read House does not answer, or one that outlived
-  the browser's signed-in User, is `null`.
-- **App screenshot read** - given an App reference, `readScreenshot(app)`
-  answers the image this browser captured of that App's screen the first time
-  it ran its current release, as a PNG `Blob` at most 1200 pixels wide, or
-  `null` when this browser holds none. The image stays in the browser; a Site
-  holds none.
+The bridge carries no credential handling and no Runtime family. House builds
+the MD Runtime client into the page beside the bridge, and `bridge.runtime`
+resolves to that client, so the App imports and constructs none.
 
-The package carries no credential handling and no Runtime family. It surfaces
-the dedicated Runtime port the worker transfers over the bridge as a plain
-message port, which the App hands to the MD Runtime client entry.
+House's `find_command` "App" is the guide to building an App or a Site.
 
 ## Use
 
 ```js
-import { connectHouseBridge } from '@agentshouse/app-bridge';
-import { connectMdRuntime } from '@agentshouse/mdruntime/client';
+import { houseBridge } from '@agentshouse/app-bridge';
 
-const bridge = connectHouseBridge();
-const md = connectMdRuntime(await bridge.runtime);
+const bridge = houseBridge();
+const md = await bridge.runtime;
 
 bridge.onAddress((address) => render(address));
 bridge.onStatus((status) => showSync(status.sync));
@@ -79,39 +35,25 @@ async function manageSecurity(securityPath) {
   try {
     await bridge.ceremony(securityPath);
   } catch (refusal) {
-    report(refusal);
+    if (refusal.name === 'HouseCeremonyRefused') report(refusal.path);
   }
 }
 ```
 
-`bridge.runtime` resolves with a structural `HouseMessagePort`. A consumer whose
-Runtime client entry asks for the DOM `MessagePort` type passes it through
-directly at run time and casts at the type level.
+`bridge.runtime` resolves to the `MdRuntimeClient` of
+`@agentshouse/mdruntime/client`, whose README describes its members. Its
+`call(name, input)` reaches House: `HouseCalls` names each Call an App makes
+and the input it takes, such as `call('member.list', { room_ref })`.
 
 ## Test without a House
 
 ```js
-import { connectHouseBridge } from '@agentshouse/app-bridge';
+import { houseBridge } from '@agentshouse/app-bridge';
 import { createHouseBridgeTestHost } from '@agentshouse/app-bridge/test-host';
 
 const host = createHouseBridgeTestHost({ address: '/rooms/atlas' });
-const bridge = connectHouseBridge(host.port);
+const bridge = houseBridge();
 
 bridge.push('/rooms/atlas/members');
 host.open('/rooms/atlas');
 ```
-
-The host plays the shell and the worker: it delivers the address the App starts
-at and each address `open` plays as Back or Forward through the shell's own
-slice below the App's path, admitting nothing, so it delivers `//notes` exactly
-as a browser at `/apps/<app>//notes` does. It records every push and replace
-and answers each with the address the shell would then show, records an
-admitted ceremony, refuses a push, replace or ceremony that is not a
-same-origin absolute path, publishes a status, its `service_mode` included,
-records in `consents` each
-`gaConsent` it takes while that status measures and publishes the status the
-choice leaves, records in `tabs` each `setTab` the shell would take and ignores
-any other, answers a release code read from the `sources` it was given, or
-`null`, answers `readScreenshot` from the `screenshots` it was given by App
-reference, answers every `install()` `'manual'`, as a browser with no install
-prompt does, and attaches a Runtime port.

package/dist/calls.d.ts

@@ -0,0 +1,117 @@
+export interface HouseCalls {
+    readonly 'access.read': {
+        readonly room_ref: string;
+    };
+    readonly 'conversation.answer': {
+        readonly answer: {
+            readonly interaction_id: string;
+            readonly response: unknown;
+        };
+        readonly conversation: string;
+        readonly operation_id?: string;
+    };
+    readonly 'conversation.create': {
+        readonly agent_id: string;
+        readonly operation_id?: string;
+    };
+    readonly 'conversation.delete': {
+        readonly conversation: string;
+        readonly operation_id?: string;
+    };
+    readonly 'conversation.history': {
+        readonly conversations: readonly {
+            readonly after?: string;
+            readonly conversation: string;
+        }[];
+    };
+    readonly 'conversation.interrupt': {
+        readonly conversation: string;
+        readonly operation_id?: string;
+    };
+    readonly 'conversation.kill': {
+        readonly conversation: string;
+        readonly operation_id?: string;
+    };
+    readonly 'conversation.markDone': {
+        readonly conversation_id?: string;
+        readonly result?: string;
+        readonly operation_id: string;
+    };
+    readonly 'conversation.rename': {
+        readonly conversation_id: string;
+        readonly operation_id: string;
+        readonly name: string;
+    };
+    readonly 'conversation.send': {
+        readonly conversation: string;
+        readonly files?: readonly {
+            readonly blob: Blob;
+            readonly byteLength: number;
+            readonly contentHash: string;
+            readonly height?: number;
+            readonly mediaType: string;
+            readonly name: string;
+            readonly width?: number;
+        }[];
+        readonly operation_id: string;
+        readonly text?: string;
+    };
+    readonly 'conversation.setOption': {
+        readonly conversation_id: string;
+        readonly operation_id: string;
+        readonly option: string;
+        readonly value: string | boolean;
+    };
+    readonly 'feature.list': Readonly<Record<string, never>>;
+    readonly 'holder.list': Readonly<Record<string, never>>;
+    readonly 'holder.ring': {
+        readonly to: string;
+    };
+    readonly 'member.list': {
+        readonly room_ref: string;
+        readonly history?: boolean;
+        readonly limit?: number;
+        readonly cursor?: string;
+    };
+    readonly 'message.send': {
+        readonly to: string;
+        readonly body: unknown;
+    };
+    readonly 'processing.read': {
+        readonly room_ref: string;
+        readonly path: string;
+    };
+    readonly 'record.list': {
+        readonly room_ref: string;
+        readonly record?: string;
+        readonly cursor?: string;
+        readonly limit?: number;
+        readonly order?: 'asc' | 'desc';
+    };
+    readonly 'relay.read': Readonly<Record<string, never>>;
+    readonly 'routine.list': {
+        readonly room_ref: string;
+    };
+    readonly 'routineAccess.list': {
+        readonly room_ref: string;
+    };
+    readonly 'routineAllowance.list': {
+        readonly room_ref: string;
+        readonly access: string;
+    };
+    readonly 'routineRequest.list': {
+        readonly room_ref: string;
+    };
+    readonly 'storage.read': {
+        readonly room_ref?: string;
+    };
+    readonly submit: {
+        readonly content: string;
+    };
+    readonly 'trigger.list': {
+        readonly room_ref: string;
+    };
+    readonly 'triggerOccurrence.list': {
+        readonly room_ref: string;
+    };
+}

package/dist/calls.js

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

package/dist/index.d.ts

@@ -0,0 +1,152 @@
+import type { MdRuntimeClient } from './mdruntime/client.js';
+import type { HouseCalls } from './calls.js';
+export type { HouseCalls } from './calls.js';
+type Open<Value extends string> = Value | (string & {});
+export type HouseCallInput<Name extends string> = Name extends keyof HouseCalls ? HouseCalls[Name] : unknown;
+export interface HouseRuntime extends Omit<MdRuntimeClient, 'call'> {
+    call<Name extends Open<keyof HouseCalls>>(name: Name, input: HouseCallInput<Name>): ReturnType<MdRuntimeClient['call']>;
+}
+export interface HouseSyncState {
+    readonly state: string;
+    readonly providerUnreachable: boolean;
+}
+export interface HouseCredentialState {
+    readonly state: Open<'none' | 'held' | 'rejected'>;
+    readonly expiresAt: number | null;
+}
+export type HouseAnalyticsChoice = 'accept' | 'decline';
+export interface HouseAnalytics {
+    readonly measures: boolean;
+    readonly choice: Open<HouseAnalyticsChoice> | null;
+}
+export interface HouseStatus {
+    readonly app: string | null;
+    readonly preferences: {
+        readonly roomRef: string;
+        readonly path: string;
+    } | null;
+    readonly runtime: string;
+    readonly credential: HouseCredentialState;
+    readonly sync: HouseSyncState | null;
+    readonly refusal: {
+        readonly code: string;
+        readonly retryable: boolean;
+    } | null;
+    readonly loss: string | null;
+    readonly analytics: HouseAnalytics;
+    readonly serviceMode: Open<'open' | 'write-halted'> | null;
+    readonly offline: boolean;
+}
+export type HouseNavigationMode = 'push' | 'replace';
+export interface HouseTab {
+    readonly title?: string;
+    readonly icon?: string;
+}
+interface HouseRelease {
+    readonly app_ref: string;
+    readonly release: string;
+}
+export interface HouseSourceTop extends HouseRelease {
+    readonly folders: readonly string[];
+    readonly files: readonly {
+        readonly name: string;
+        readonly size: number;
+    }[];
+    readonly readme: string | null;
+}
+export type HouseSourceFile = {
+    readonly path: string;
+    readonly size: number;
+} & ({
+    readonly text: string;
+} | {
+    readonly base64: string;
+});
+export interface HouseSourceDownload extends HouseRelease {
+    readonly files: readonly HouseSourceFile[];
+}
+export interface HouseExternalRequest {
+    readonly url: string;
+    readonly method?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: string;
+    readonly body_base64?: string;
+    readonly account?: string;
+    readonly slot?: string;
+}
+export type HouseExternalAnswer = {
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string | readonly string[]>>;
+} & ({
+    readonly body: string;
+} | {
+    readonly body_base64: string;
+});
+export interface HouseRefusal {
+    readonly error: {
+        readonly code: string;
+        readonly retryable: boolean;
+    };
+}
+export interface HouseAppMessage {
+    readonly from: string;
+    readonly body: unknown;
+}
+export type HouseInstallation = Open<'accepted' | 'dismissed' | 'manual'>;
+export type HouseNotifications = Open<'on' | 'off' | 'blocked' | 'unavailable'>;
+export interface HouseCeremonyRefused extends Error {
+    readonly name: 'HouseCeremonyRefused';
+    readonly code: Open<'house_ceremony_refused'>;
+    readonly retryable: boolean;
+    readonly path: string | null;
+}
+export interface HouseNavigationRefused extends Error {
+    readonly name: 'HouseNavigationRefused';
+    readonly code: Open<'house_navigation_refused'>;
+    readonly retryable: boolean;
+    readonly address: string | null;
+}
+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;
+}
+export interface HouseBridge {
+    readonly runtime: Promise<HouseRuntime>;
+    address(): string | null;
+    onAddress(listener: (address: string) => void): () => void;
+    push(address: string): Promise<string>;
+    replace(address: string): Promise<string>;
+    ceremony(path: string): Promise<never>;
+    install(): Promise<HouseInstallation>;
+    notifications(on?: boolean): Promise<HouseNotifications>;
+    setBadge(unread: readonly string[]): Promise<void>;
+    setTab(tab: HouseTab): void;
+    sourceTop(app: string, release?: string): Promise<HouseSourceTop | HouseRefusal | null>;
+    sourceDownload(app: string, release?: string): Promise<HouseSourceDownload | HouseRefusal | null>;
+    callExternal(request: HouseExternalRequest): Promise<HouseExternalAnswer | HouseRefusal | null>;
+    readScreenshot(app: string): Promise<Blob | null>;
+    readSiteScreenshot(site: string): Promise<Blob | null>;
+    status(): HouseStatus | null;
+    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;

package/dist/index.js

@@ -0,0 +1 @@
+export const houseBridge = () => globalThis.houseBridge;

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,149 @@
+import { type ValueFacts } from './definition.js';
+import type { Document, VerifiedModel } from './types.js';
+export type ConditionValue = string | number | boolean | {
+    readonly owner: true;
+};
+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;
+};
+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 Condition = DocumentCondition | ItemCondition | CronCondition | DateCondition;
+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 WRITE_DOORS: readonly ['browser', 'agent', 'client'];
+export type WriteDoor = (typeof WRITE_DOORS)[number];
+export type Actor = {
+    readonly user?: string;
+    readonly site?: string;
+    readonly door?: WriteDoor;
+};
+export type DocumentEvent = {
+    readonly before: DocumentFacts | null;
+    readonly after: DocumentFacts | null;
+    readonly changed: readonly string[];
+    readonly by: Actor;
+};
+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>>;
+    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 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 {};

package/dist/mdmodel/definition.d.ts

@@ -0,0 +1,65 @@
+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 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 Definition = {
+    readonly name: string;
+    readonly memberDocument: boolean;
+    readonly frontmatter: ValueFacts;
+    readonly fields: Readonly<Record<string, ValueFacts>>;
+    readonly sections: Readonly<Record<string, SectionSpec>>;
+    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 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): 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 { ApplyResult, BodyResult, FrontmatterResult, Change, Document, Link, LinkOccurrence, ParseResult } from './types.js';
+import { type YamlMap } from './yaml.js';
+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 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 serialize(document: Document): string;
+export declare function fieldStart(document: Document, pointer: string): number | undefined;
+export declare function frontmatter(document: Document): YamlMap | null;