import type { FabricMessageSender } from "../protocol.js";
export interface MeshIdentity {
    id: string;
    name: string;
    kind: "main" | "actor" | "agent";
    sessionId?: string;
}
export interface MeshEvent {
    id: string;
    sequence: number;
    topic: string;
    kind: string;
    from: MeshIdentity;
    to?: string;
    text?: string;
    data?: unknown;
    createdAt: number;
    /** Set on events appended through a scoped external grant (`pi-fabric mesh post`). */
    origin?: "external";
    untrusted?: true;
    grantId?: string;
    /** Set on events released from a pending schedule; the event id is the schedule id. */
    scheduled?: {
        dueAt: number;
        key?: string;
    };
    /** Host-stamped authority of the publishing process; absent from older builds and grant posts. */
    sender?: FabricMessageSender;
}
/** Host-internal append request used inside {@link MeshStore.transact}. */
export interface MeshAppendInput {
    id?: string;
    topic: string;
    kind?: string;
    from: MeshIdentity;
    to?: string;
    text?: string;
    data?: unknown;
    origin?: "external";
    untrusted?: true;
    grantId?: string;
    scheduled?: {
        dueAt: number;
        key?: string;
    };
    sender?: FabricMessageSender;
    /** A tighter per-event byte ceiling than the store's own. */
    maxEventBytes?: number;
}
/** A pending scheduled event; released into its topic log once due. */
export interface MeshSchedule {
    id: string;
    key?: string;
    topic: string;
    kind: string;
    from: MeshIdentity;
    to?: string;
    text?: string;
    data?: unknown;
    dueAt: number;
    createdAt: number;
    /** Stamped when scheduled; carried onto the released event. */
    sender?: FabricMessageSender;
}
export interface MeshTailResult {
    events: MeshEvent[];
    nextOffset: number;
}
export interface MeshStateEntry {
    key: string;
    value: unknown;
    version: number;
    updatedAt: number;
    updatedBy: MeshIdentity;
}
export interface MeshStoreOptions {
    maxEventLogBytes?: number;
    retainedEventLogBytes?: number;
    maxStateBytes?: number;
    maxStateTombstones?: number;
    lockTimeoutMs?: number;
    staleLockMs?: number;
    /**
     * `"fsync"` flushes every committed write (event append, state, sequence,
     * schedules, grants, compaction) to stable storage before the call returns.
     */
    durability?: MeshDurability;
}
export type MeshDurability = "default" | "fsync";
export declare const validateMeshTopic: (topic: string) => void;
export declare const MESH_MAX_PENDING_SCHEDULES = 1000;
export declare const MESH_MAX_SCHEDULE_AHEAD_MS: number;
export declare class MeshStore {
    #private;
    readonly root: string;
    readonly maxEventBytes: number;
    readonly maxReadEvents: number;
    /** Whether committed writes are flushed to stable storage before returning. */
    readonly durable: boolean;
    constructor(root: string, maxEventBytes: number, maxReadEvents: number, options?: MeshStoreOptions);
    publish(input: {
        topic: string;
        kind?: string;
        from: MeshIdentity;
        to?: string;
        text?: string;
        data?: unknown;
        /** Host-only: publish on behalf of another authority (an actor's scope). */
        sender?: FabricMessageSender;
    }): Promise<MeshEvent>;
    /**
     * Host-internal: runs `operation` under the mesh lock with an append
     * capability, for side stores (grants) that must commit with an event.
     */
    transact<T>(operation: (append: (input: MeshAppendInput) => MeshEvent) => T): Promise<T>;
    /**
     * Stores a pending event released into `topic` once `dueAt` passes. A `key`
     * replaces any pending schedule with that key in the same locked write, so
     * concurrent publishers never leave two schedules for one key.
     */
    schedule(input: {
        topic: string;
        kind?: string;
        from: MeshIdentity;
        to?: string;
        text?: string;
        data?: unknown;
        dueAt: number;
        key?: string;
    }, now?: number): Promise<MeshSchedule>;
    /** Removes the pending schedule with `key`, if any. */
    unschedule(key: string): Promise<{
        removed: boolean;
    }>;
    /** Pending schedules by due time; a due one stays listed until a releaser appends it. */
    scheduled(input?: {
        topic?: string;
        limit?: number;
    }): MeshSchedule[];
    /** Earliest pending due time, read without the lock (one stat when unchanged). */
    nextScheduleDueAt(): number | undefined;
    /**
     * Appends every due schedule to its topic and removes it, under the mesh
     * lock, so concurrent releasers (monitors, resident hosts, CLI posts) append
     * each schedule once. The lock is taken only when something is due.
     */
    releaseDueSchedules(now?: number): Promise<MeshEvent[]>;
    read(input?: {
        after?: number;
        topic?: string;
        to?: string;
        limit?: number;
    }): MeshEvent[];
    latestSequence(): number;
    latestOffset(): number;
    tail(cursor: number, limit?: number): MeshTailResult;
    get(key: string): MeshStateEntry | undefined;
    list(prefix?: string, limit?: number): MeshStateEntry[];
    /** Internal project-state scan for host-managed indexes that must reconcile every key. */
    listAll(prefix?: string): MeshStateEntry[];
    put(input: {
        key: string;
        value: unknown;
        identity: MeshIdentity;
        ifVersion?: number;
    }): Promise<MeshStateEntry>;
    /** The internal guard observes a detached snapshot under the mutation lock. */
    delete(input: {
        key: string;
        ifVersion?: number;
    }, guard?: (entries: readonly MeshStateEntry[]) => boolean): Promise<{
        deleted: boolean;
        version?: number;
    }>;
}
//# sourceMappingURL=store.d.ts.map