@idleware/ringi 0.4.0 → 0.6.0

package/target/dts/core/agents/sessions/wait.d.ts

@@ -0,0 +1,38 @@
+import type { InboxOptions } from './agent.ts';
+import type { Actor } from '../../hub/usecases/room.ts';
+export declare const wait: (a: Actor, { max, ...options }?: InboxOptions & {
+    max?: number;
+}) => Promise<{
+    inbox: {
+        rest: number;
+        cursors: Record<string, string>;
+        all: import("../../hub/protocol/model.ts").All;
+        msgs: {
+            id: string;
+            from: string;
+            trust: 'asserted' | 'verified';
+            time: number;
+            seq: number;
+            invalid: string | null;
+            subject: string;
+            body: string;
+            to: string[];
+            re: string | null;
+            kind: string | null;
+            state: string | null;
+            assign: string[] | null;
+            roles: Record<string, string> | null;
+            hop: number;
+            bad: string | null;
+            trailers: import("../../hub/protocol/model.ts").Trailers;
+            refused: import("../../hub/protocol/model.ts").Refused[];
+            reId: string | null;
+            hopEff: number;
+            files: import("../../hub/protocol/model.ts").FileRef[];
+        }[];
+    };
+    seconds: number;
+} | {
+    inbox: null;
+    seconds: number;
+}>;

package/target/dts/core/agents/turns/budgets.d.ts

@@ -0,0 +1,5 @@
+import type { Room } from '../../hub/rooms/index.ts';
+import type { All } from '../../hub/protocol/index.ts';
+import type { ReaderState } from '../../hub/history/index.ts';
+import type { Group, Planning, WatchContext } from './types.ts';
+export declare const reserveGroups: (c: WatchContext, R: Room, all: All, groups: Map<string | null, Group>, st: ReaderState) => Planning;

package/target/dts/core/agents/turns/dispatch.d.ts

@@ -0,0 +1,9 @@
+import type { Room } from '../../hub/rooms/index.ts';
+import type { Ended } from '../ports/host.ts';
+import type { Run, WatchContext } from './types.ts';
+type Dispatch = {
+    why?: string;
+    done?: Promise<Ended>;
+};
+export declare const dispatch: (c: WatchContext, R: Room, run: Run) => Dispatch;
+export {};

package/target/dts/core/agents/turns/exhaustion.d.ts

@@ -0,0 +1,11 @@
+import type { Room } from '../../hub/rooms/index.ts';
+import type { All } from '../../hub/protocol/index.ts';
+import type { Group, Planning, Reserve, WatchContext } from './types.ts';
+export declare const reportExhausted: ({ c, R, all, grp, r, p }: {
+    c: WatchContext;
+    R: Room;
+    all: All;
+    grp: Group;
+    r: Reserve;
+    p: Planning;
+}) => void;

package/target/dts/core/agents/turns/grants.d.ts

@@ -0,0 +1,4 @@
+import type { Room } from '../../hub/rooms/index.ts';
+import type { All } from '../../hub/protocol/index.ts';
+import type { Group, Reserve, WatchContext } from './types.ts';
+export declare const reserveGrant: (c: WatchContext, R: Room, all: All, grp: Group) => Reserve;

package/target/dts/core/agents/turns/index.d.ts

@@ -0,0 +1,4 @@
+import type { WatchOptions } from './types.ts';
+export type { Room } from '../../hub/rooms/index.ts';
+export type { WatchOptions } from './types.ts';
+export declare const watch: (w: WatchOptions, log?: (line: string) => void) => Promise<number>;

package/target/dts/core/agents/turns/limits.d.ts

@@ -0,0 +1,2 @@
+import type { WatchOptions } from './types.ts';
+export declare const validateWatch: (w: WatchOptions) => void;

package/target/dts/core/agents/turns/messages.d.ts

@@ -0,0 +1,10 @@
+import type { Room } from '../../hub/rooms/index.ts';
+import type { All, Logs, Message } from '../../hub/protocol/index.ts';
+import type { ReaderState } from '../../hub/history/index.ts';
+import type { Group, WatchContext } from './types.ts';
+export declare const collectMessages: (c: WatchContext, R: Room, logs: Logs, st: ReaderState, all: All) => {
+    retry: Message[];
+    cursors: Record<string, string>;
+    go: Message[];
+};
+export declare const groupMessages: (R: Room, all: All, go: Message[]) => Map<string | null, Group>;

package/target/dts/core/agents/turns/pings.d.ts

@@ -0,0 +1,5 @@
+import type { Room } from '../../hub/rooms/index.ts';
+import type { Logs } from '../../hub/protocol/index.ts';
+import type { ReaderState } from '../../hub/history/index.ts';
+import type { WatchContext } from './types.ts';
+export declare const answerWatchPings: (c: WatchContext, R: Room, logs: Logs, st: ReaderState) => Record<string, string>;

package/target/dts/core/agents/turns/plan.d.ts

@@ -0,0 +1,3 @@
+import type { Room } from '../../hub/rooms/index.ts';
+import type { Plan, WatchContext } from './types.ts';
+export declare const planTurns: (c: WatchContext, R: Room) => Plan;

package/target/dts/core/agents/turns/poll.d.ts

@@ -0,0 +1,8 @@
+import type { Room } from '../../hub/rooms/index.ts';
+import type { WatchContext } from './types.ts';
+type Poll = {
+    done: boolean;
+    R?: Room;
+};
+export declare const pollWatcher: (c: WatchContext) => Poll;
+export {};

package/target/dts/core/agents/turns/results.d.ts

@@ -0,0 +1,3 @@
+import type { Room } from '../../hub/rooms/index.ts';
+import type { Run, WatchContext } from './types.ts';
+export declare const runTurns: (c: WatchContext, R: Room, runs: Run[]) => Promise<number>;

package/target/dts/core/agents/turns/seat.d.ts

@@ -0,0 +1,2 @@
+import type { WatchContext, WatchOptions } from './types.ts';
+export declare const createWatcher: (w: WatchOptions, log: (line: string) => void) => WatchContext;

package/target/dts/core/agents/turns/types.d.ts

@@ -0,0 +1,59 @@
+import type * as D from '../../hub/decisions/index.ts';
+import type { Hub, Room } from '../../hub/rooms/index.ts';
+import type { Message } from '../../hub/protocol/index.ts';
+export type WatchOptions = {
+    seat: string;
+    exec: string;
+    hub?: string;
+    scope?: string;
+    handoff?: boolean;
+    once?: boolean;
+    requireGrant?: boolean;
+    interval?: number;
+    from?: string[];
+    maxHop?: number;
+    maxRuns?: number;
+    window?: number;
+};
+export type WatchContext = {
+    w: WatchOptions;
+    H0: Hub;
+    R0: Room;
+    me: string;
+    raw: string;
+    handle: string;
+    cmd: string;
+    interval: number;
+    allow: Set<string> | null;
+    maxHop: number;
+    maxRuns: number;
+    span: number;
+    runSeq: number;
+    log: (line: string) => void;
+};
+export type Group = {
+    grant: string | null;
+    msgs: Message[];
+    task: Message | null;
+};
+export type Run = Group & {
+    run?: string;
+    timeout: number | null;
+};
+export type Reserve = {
+    why?: string;
+    lost?: boolean;
+    wait?: boolean;
+    exhausted?: boolean;
+    gr?: D.Grant;
+    run?: string;
+};
+export type Plan = {
+    runs: Run[];
+    hold: boolean;
+    lost: boolean;
+};
+export type Planning = Plan & {
+    ownRuns: number[];
+    exhausted: Record<string, boolean>;
+};

package/target/dts/core/hub/decisions/budget.d.ts

@@ -0,0 +1,15 @@
+export declare const ROOT = "operator";
+export type Budget = {
+    runs: number;
+    'run-seconds': number;
+    concurrency: number;
+};
+export type Authority = {
+    decide?: Record<string, Partial<Budget>>;
+};
+export type AuthorityAt = (control: string | null) => Authority | null;
+export declare const ids: (v: string | null) => string[];
+export declare const parseBudget: (s: string | null | undefined) => Budget | null | undefined;
+export declare const budgetText: (b: Budget) => string;
+export declare const parseDue: (s: string) => string;
+export declare const mayDecide: (authority: Authority | null, decider: string, proposer: string, budget: Budget | null) => boolean;

package/target/dts/core/hub/decisions/check.d.ts

@@ -0,0 +1,6 @@
+import type { Parsed } from '../protocol/index.ts';
+export declare const STAMPS: string[];
+export declare const DECISIONS: string[];
+type Ref = (s: string) => boolean;
+export declare const check: (m: Parsed, isRef: Ref) => string | null;
+export {};

package/target/dts/core/hub/decisions/index.d.ts

@@ -0,0 +1,5 @@
+export declare const CAPABILITY = "decisions/1";
+export * from './budget.ts';
+export * from './check.ts';
+export * from './proposal.ts';
+export * from './usage.ts';

package/target/dts/core/hub/decisions/proposal.d.ts

@@ -0,0 +1,38 @@
+import type { All, Message } from '../protocol/index.ts';
+import type { AuthorityAt, Budget } from './budget.ts';
+export type Grant = {
+    id: string;
+    budget: Budget;
+    proposal: Message;
+    revoked: boolean;
+};
+export type Proposal = {
+    proposal: Message;
+    decider: string;
+    reviewers: string[];
+    budget: Budget | null;
+    due: number | null;
+    stamps: Record<string, {
+        stamp: string;
+        id: string;
+        reason: string;
+    }>;
+    missing: string[];
+    decision: {
+        decision: string;
+        id: string;
+        by: string;
+        time: number;
+    } | null;
+    revoked: {
+        id: string;
+        by: string;
+        time: number;
+    } | null;
+    superseded: Message | null;
+    state: string;
+    grant: Grant | null;
+};
+export declare const proposalOf: (all: All, p: Message, authorityAt: AuthorityAt, now?: number) => Proposal;
+export declare const proposals: (all: All, authorityAt: AuthorityAt) => Proposal[];
+export declare const grantOf: (all: All, authorityAt: AuthorityAt, id: string) => Grant | null;

package/target/dts/core/hub/decisions/usage.d.ts

@@ -0,0 +1,12 @@
+import type { All, Message } from '../protocol/index.ts';
+import type { AuthorityAt } from './budget.ts';
+import type { Grant } from './proposal.ts';
+export type Usage = {
+    runs: number;
+    open: number;
+    uncertain: number;
+    seconds: number;
+    left: number;
+};
+export declare const counted: (all: All, authorityAt: AuthorityAt, m: Message) => boolean;
+export declare const usageOf: (all: All, grant: Grant, now?: number) => Usage;

package/target/dts/{runtime/reader.d.ts → core/hub/history/index.d.ts}

@@ -1,29 +1,35 @@
-import type { Room } from '../hub/index.ts';
+import type { Room } from '../rooms/index.ts';
 import type { All, Logs } from '../protocol/index.ts';
-import type { Rev } from '../store/index.ts';
-export type ReaderState = {
+import type { Rev } from '../ports/store.ts';
+export type Accepted = {
     control?: Rev;
     heads?: Record<string, Rev>;
+    signals?: Record<string, string>;
     alarms?: string[];
+};
+export type Delivered = {
     seen?: Record<string, string>;
+};
+export type Turns = {
     watched?: Record<string, string>;
     pending?: string[];
     inflight?: {
         seen: Record<string, string>;
     };
-    heartbeatSeen?: Record<string, string>;
     runs?: number[];
     exhausted?: Record<string, boolean>;
-    signals?: Record<string, string>;
+    heartbeatSeen?: Record<string, string>;
+};
+export type Outgoing = {
     staged?: Staged[];
 };
+export type ReaderState = Accepted & Delivered & Turns & Outgoing;
 export type Staged = {
     path: string;
     blob: string;
     mode: string;
     size: number;
 };
-export declare const readerFile: (R: Room, reader: string) => string;
 export declare const readerLock: <T>(R: Room, reader: string, fn: () => T) => T;
 export declare const loadState: (R: Room, reader: string) => ReaderState;
 export declare const saveState: (R: Room, reader: string, st: ReaderState) => void;

package/target/dts/core/hub/ports/index.d.ts

@@ -0,0 +1,16 @@
+import type { LocalState } from './state.ts';
+import type { Transport } from './store.ts';
+export type { Key, LocalState } from './state.ts';
+export type Build = {
+    version: string;
+    resources: string;
+};
+export type HubPorts = {
+    build: Build;
+    state: LocalState;
+    transports: Record<string, Transport>;
+    store: string;
+};
+export declare const wireHub: (p: HubPorts) => void;
+export declare const hubPorts: () => HubPorts;
+export declare const locked: <T>(name: string, fn: () => T) => T;

package/target/dts/core/hub/ports/state.d.ts

@@ -0,0 +1,12 @@
+export type Key = readonly string[];
+export interface LocalState {
+    readonly root: string;
+    present(): boolean;
+    ensure(): void;
+    locked<T>(name: string, fn: () => T): T;
+    read<T>(key: Key, dflt: T): T;
+    write(key: Key, value: unknown): void;
+    remove(key: Key): void;
+    list(key: Key): string[];
+    place(key: Key): string;
+}

package/target/dts/{store/index.d.ts → core/hub/ports/store.d.ts}

@@ -52,7 +52,7 @@ export type JoinKey = {
     fingerprint: string;
     admitted: boolean;
 };
-export interface Store {
+export interface Log {
     readonly type: string;
     readonly trust: 'asserted' | 'signed';
     isRef(s: string): boolean;
@@ -66,29 +66,55 @@ export interface Store {
     controlFile(room: StoredRoom, name: string, rev?: Rev): string | null;
     createRoom(name: string, who: string, text: string, files: Record<string, string>): Rev;
     updateControl(room: StoredRoom, who: string, text: string, files: Record<string, string>): Rev;
-    archiveRoom(room: StoredRoom, as: string): void;
-    deleteRoom(room: StoredRoom): void;
-    migrateRoom?(name: string): Rev;
-    roster(room: StoredRoom): Roster | null;
     logIds(room: StoredRoom): string[];
     logHead(room: StoredRoom, id: string): Rev | null;
     extends(older: Rev, newer: Rev): boolean;
     messages(room: StoredRoom, id: string, head: Rev): StoredMessage[];
     append(room: StoredRoom, who: string, text: string, entries: Entry[]): Rev;
-    blob(file: string): Rev;
-    alarms?(room: StoredRoom): string[];
-    verifyLog(room: StoredRoom, id: string, head: Rev): string | null;
-    pin(room: StoredRoom, reader: string, id: string, rev: Rev): void;
-    unpin(room: StoredRoom, reader: string, id: string): void;
+}
+export interface Attachments {
+    blob(file: string): {
+        id: Rev;
+        size: number;
+    };
+    retain(room: StoredRoom, who: string, entries: Entry[]): void;
     file(rev: Rev, path: string): Buffer;
     sizes(rev: Rev, paths: string[]): Map<string, number>;
+}
+export interface Signals {
     signal(room: StoredRoom, who: string, target: Rev, name: string): void;
     signals(room: StoredRoom): SignalRecord[];
-    admit?(room: StoredRoom, who: string, key: string): Rev;
-    joinKey?(room: StoredRoom, who: string): JoinKey;
-    forgetLog?(room: StoredRoom, id: string): void;
-    rootKey?(): string;
-    rootRoster?(): string;
+}
+export interface Evidence {
+    pin(room: StoredRoom, reader: string, id: string, rev: Rev): void;
+    unpin(room: StoredRoom, reader: string, id: string): void;
+}
+export interface Administration {
+    archiveRoom(room: StoredRoom, as: string): void;
+    deleteRoom(room: StoredRoom): void;
+}
+export interface Verification {
+    roster(room: StoredRoom): Roster | null;
+    verifyLog(room: StoredRoom, id: string, head: Rev): string | null;
+    alarms?(room: StoredRoom): string[];
+}
+export interface Presence {
+    heartbeat(room: StoredRoom, who: string, target: Rev, text: string): Rev;
+    heartbeats(room: StoredRoom): Array<{
+        agent: string;
+        target: Rev;
+        time: number;
+        text: string;
+    }>;
+}
+export interface Signed {
+    admit(room: StoredRoom, who: string, key: string): Rev;
+    joinKey(room: StoredRoom, who: string): JoinKey;
+    forgetLog(room: StoredRoom, id: string): void;
+    rootKey(): string;
+    rootRoster(): string;
+}
+export interface Store extends Log, Attachments, Signals, Evidence, Administration, Verification, Partial<Presence>, Partial<Signed> {
 }
 export type Descriptor = {
     schema: 'ringi-hub/2';
@@ -102,5 +128,20 @@ export type Descriptor = {
         remote?: string;
     };
 };
-export type StoreFactory = (dir: string, d: Descriptor, home: string) => Store;
-export declare const STORES: Record<string, StoreFactory>;
+export type Genesis = (d: Descriptor) => {
+    files: Record<string, string>;
+    text: string;
+};
+export interface Transport {
+    readonly layout: string;
+    layoutOf?(store: Store): string;
+    open(at: string, d: Descriptor): Store;
+    create(at: string, d: Descriptor, genesis: Genesis): {
+        store: Store;
+        custody: string | null;
+    };
+    attach?(name: string, url: string, pins: {
+        root?: string;
+        genesis?: string;
+    }): void;
+}

package/target/dts/core/hub/protocol/index.d.ts

@@ -0,0 +1,5 @@
+export * from './model.ts';
+export * from './text.ts';
+export * from './threads.ts';
+export * from './order.ts';
+export * from './reading.ts';

package/target/dts/{protocol/index.d.ts → core/hub/protocol/model.d.ts}

@@ -46,28 +46,3 @@ export type Parsed = Pick<Message, 'subject' | 'body' | 'to' | 're' | 'kind' | '
 export declare const one: (m: {
     trailers: Trailers;
 }, k: string) => string | null;
-export declare const decodeText: (buf: Uint8Array) => {
-    text: string;
-    invalid?: undefined;
-} | {
-    invalid: string;
-    text?: undefined;
-};
-export declare const parse: (raw: string, isRef: (s: string) => boolean) => Parsed;
-export declare const compose: (text: string, trailers: Array<[string, string | null | undefined | false]>) => string;
-export declare const checkOutgoing: (text: string, isRef: (s: string) => boolean) => Parsed;
-export declare const link: (logs: Logs) => All;
-export declare const ordered: (list: Message[]) => Message[];
-export declare const chainHas: (all: All, m: Message, top: Message) => boolean;
-export declare const rootOf: (all: All, m: Message) => Message;
-export declare const under: (all: All, top: Message) => Message[];
-export declare const lookup: (all: All, ref: string) => Message;
-export declare const visible: (m: Message, id: string, hidden: Set<string>) => boolean;
-export declare const wakes: (m: Message, id: string, hidden: Set<string>) => boolean;
-export declare const unread: (logs: Logs, id: string, cursors: Record<string, string>, limit: number | undefined, hidden: Set<string>) => {
-    msgs: Message[];
-    rest: number;
-    cursors: {
-        [x: string]: string;
-    };
-};

package/target/dts/core/hub/protocol/order.d.ts

@@ -0,0 +1,2 @@
+import type { Message } from './model.ts';
+export declare const ordered: (list: Message[]) => Message[];

package/target/dts/core/hub/protocol/reading.d.ts

@@ -0,0 +1,8 @@
+import type { Logs, Message } from './model.ts';
+export declare const visible: (m: Message, id: string, hidden: Set<string>) => boolean;
+export declare const wakes: (m: Message, id: string, hidden: Set<string>) => boolean;
+export declare const unread: (logs: Logs, id: string, cursors: Record<string, string>, limit: number | undefined, hidden: Set<string>) => {
+    msgs: Message[];
+    rest: number;
+    cursors: Record<string, string>;
+};

package/target/dts/core/hub/protocol/text.d.ts

@@ -0,0 +1,11 @@
+import type { Parsed } from './model.ts';
+export declare const decodeText: (buf: Uint8Array) => {
+    text: string;
+    invalid?: undefined;
+} | {
+    invalid: string;
+    text?: undefined;
+};
+export declare const parse: (raw: string, isRef: (s: string) => boolean) => Parsed;
+export declare const compose: (text: string, trailers: Array<[string, string | null | undefined | false]>) => string;
+export declare const checkOutgoing: (text: string, isRef: (s: string) => boolean) => Parsed;

package/target/dts/core/hub/protocol/threads.d.ts

@@ -0,0 +1,5 @@
+import type { All, Logs, Message } from './model.ts';
+export declare const link: (logs: Logs) => All;
+export declare const rootOf: (all: All, m: Message) => Message;
+export declare const under: (all: All, top: Message) => Message[];
+export declare const lookup: (all: All, ref: string) => Message;

package/target/dts/core/hub/rooms/compat.d.ts

@@ -0,0 +1,5 @@
+import type { Descriptor, Rev, Store } from '../ports/store.ts';
+import type { Contract } from './index.ts';
+export declare const descriptorRefusal: (d: Descriptor, name: string) => string | null;
+export declare const contractAt: (store: Store, name: string, rev: Rev) => Contract;
+export declare const layoutRefusal: (name: string, shown: string, reads: string) => string | null;

package/target/dts/core/hub/rooms/hubs.d.ts

@@ -0,0 +1,14 @@
+import type { Transport } from '../ports/store.ts';
+import type { Hub } from './index.ts';
+export declare const hubNames: () => string[];
+export declare const readProfileResource: (name: string) => string;
+export declare const transportOf: (name: string, type: string) => Transport;
+export declare const createHub: (name: string, { signed, url }?: {
+    signed?: boolean;
+    url?: string;
+}) => {
+    custody: string | null;
+};
+export declare const openHub: (name: string, { refresh }?: {
+    refresh?: boolean;
+}) => Hub;

package/target/dts/core/hub/rooms/index.d.ts

@@ -0,0 +1,53 @@
+import type * as D from '../decisions/index.ts';
+import type { Profile } from '../work/index.ts';
+import type { Descriptor, Member, Rev, Store, StoredRoom } from '../ports/store.ts';
+export declare const OPERATOR = "operator";
+export declare const HUB_MAJOR = 1;
+export declare const PROTOCOL_MAJOR = 1;
+export declare const CAPS: Set<string>;
+export declare const RESERVED_ROOMS: Set<string>;
+export type Contract = {
+    schema: 'ringi-hub';
+    version: string;
+    protocol: number;
+    trust: 'asserted' | 'signed';
+    capabilities?: string[];
+    store?: string;
+    profile?: string;
+    root?: string;
+    authority: D.Authority;
+};
+export type Hub = {
+    name: string;
+    dir: string;
+    d: Descriptor;
+    store: Store;
+    main: Rev;
+    contract: Contract;
+    signed: boolean;
+};
+export type Room = {
+    hub: Hub;
+    s: StoredRoom;
+    name: string;
+    archived: boolean;
+    head: Rev;
+    genesis: Rev;
+    contractRev: Rev;
+    contract: Contract;
+    authorityAt: D.AuthorityAt;
+    profile: Profile;
+    members: Record<string, Member>;
+    quorum: number | null;
+};
+export declare const start: (R: Pick<Room, 'members' | 'quorum'>) => {
+    quorum: number | null;
+    agents: number;
+    started: boolean;
+};
+export * from './hubs.ts';
+export * from './compat.ts';
+export * from './rooms.ts';
+export * from './messages.ts';
+export * from '../usecases/config.ts';
+export { HIDDEN } from '../protocol/index.ts';

package/target/dts/core/hub/rooms/messages.d.ts

@@ -0,0 +1,8 @@
+import type { FileRef, Message } from '../protocol/index.ts';
+import type { Entry } from '../protocol/files.ts';
+import type { Rev, StoredMessage } from '../ports/store.ts';
+import type { Room } from './index.ts';
+export declare const toMessage: (R: Room, from: string, x: StoredMessage, seq: number) => Message;
+export declare const append: (R: Room, who: string, text: string, entries?: Entry[]) => Rev;
+export declare const withSizes: (R: Room, m: Message) => FileRef[];
+export declare const pongText: (me: string, m: Message, what: string) => string;

package/target/dts/core/hub/rooms/rooms.d.ts

@@ -0,0 +1,10 @@
+import type { Member } from '../ports/store.ts';
+import type { Hub, Room } from './index.ts';
+export declare const roomNames: (H: Hub, archived?: boolean) => string[];
+export declare const openRoom: (H: Hub, name: string | null | undefined, { quiet }?: {
+    quiet?: boolean;
+}) => Room | null;
+export declare const room: (H: Hub, name: string | null | undefined) => Room;
+export declare const ROOM_MD: (name: string) => string;
+export declare const profileText: (H: Hub, name: string) => string | null;
+export declare const controlChange: (R: Room, who: string, subject: string, mutate: (m: Record<string, Member>) => void, extra?: Array<[string, string]>) => void;

package/target/dts/core/hub/signals/check.d.ts

@@ -0,0 +1,3 @@
+import type { All } from '../protocol/index.ts';
+import type { Checked, RoomModel, SignalRecord } from './model.ts';
+export declare const check: (R: RoomModel, all: All, records: SignalRecord[]) => Checked[];

package/target/dts/core/hub/signals/effective.d.ts

@@ -0,0 +1,3 @@
+import type { All, Message } from '../protocol/index.ts';
+import type { RoomModel } from './model.ts';
+export declare const effective: (R: RoomModel, all: All, m: Message) => string[];

package/target/dts/core/hub/signals/index.d.ts

@@ -0,0 +1,5 @@
+export * from './model.ts';
+export * from './marks.ts';
+export * from './effective.ts';
+export * from './check.ts';
+export * from './pins.ts';

package/target/dts/core/hub/signals/marks.d.ts

@@ -0,0 +1,4 @@
+import type { Message } from '../protocol/index.ts';
+import type { Checked, RoomModel } from './model.ts';
+export declare const markWhy: (R: RoomModel, actor: string, m: Message, mark: string) => string | undefined;
+export declare const marksOn: (checked: Checked[]) => Map<string, Record<string, string[]>>;