@world-engines/ladybug-bridge 0.1.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,704 @@
+import { type Connection, type Database } from "@ladybugdb/wasm-core";
+export { canonicalLadybugRelationId, createViewAccessPolicySubject, derivedGraphViewAccessPolicy, deriveViewAccessPolicySubjectId, deriveViewAccessPolicySubjectIdForTarget, isViewReadable, isViewWritable, resolveEdgeViewAccessMode, resolveOverlayLeafViewAccessMode, resolveViewAccessMode, sealViewAccessPolicy, validateViewAccessPolicy, viewAccessPolicyAddressForTarget, VIEW_ACCESS_POLICY_DENY_ROOT, VIEW_ACCESS_POLICY_ROOT_SUBJECT_ID, VIEW_ACCESS_POLICY_SCHEMA_VERSION, } from "./view-access-policy.js";
+export type { AttributeOwnerKind, CanonicalWalLeafChange, EffectiveViewAccessMode, OverlayLeafAccessInput, OverlayLeafProvenance, TypedLadybugTarget, ViewAccessAttributeOwnerAddress, ViewAccessMode, ViewAccessPolicyAddress, ViewAccessPolicySnapshot, DerivedGraphViewAccessPolicy, ViewAccessPolicySubject, ViewAccessPolicySubjectKind, ViewAccessPolicyTarget, ViewAccessResolution, } from "./view-access-policy.js";
+export type LadybugVariant = {
+    setWorkerPath?: (workerPath: string) => void;
+    init: () => Promise<void>;
+    getVersion: () => Promise<string>;
+    Database: new (databasePath?: string) => Database;
+    Connection: new (database: Database) => Connection;
+};
+export type EntityRow = {
+    readonly id: string;
+    readonly kind: string;
+    readonly props: unknown;
+};
+export type RecallCandidateRecord = {
+    readonly entity: EntityRow;
+    readonly embedding: readonly number[];
+    readonly messageId: string;
+    readonly turnId: string;
+    readonly recordedRevision: number;
+    readonly writeRevision: number;
+};
+export type AnalyzerArmStatus = "ready" | "unavailable" | "reindex-needed" | "failed";
+export type AnalyzerTokenProjection = Readonly<{
+    readonly original: string;
+    readonly normalized: string;
+    readonly stem: string;
+    readonly start: number;
+    readonly end: number;
+}>;
+export type AnalyzerRelationSignalProjection = Readonly<{
+    readonly kind: "negation" | "completion" | "modality" | "relation";
+    readonly normalized: string;
+    readonly tokenIndexes: readonly number[];
+    readonly version: string;
+    readonly canonical?: string;
+}>;
+/**
+ * 单个实体的版本化分析器旁路投影。规范实体属性保持不变；
+ * 该投影是实体全文检索分支唯一索引的文本。
+ */
+export type EntityAnalyzerProjection = Readonly<{
+    readonly contractVersion: number;
+    readonly analyzerId: string;
+    readonly analyzerVersion: string;
+    readonly lexicalStatus: Exclude<AnalyzerArmStatus, "reindex-needed">;
+    readonly relationalStatus: Exclude<AnalyzerArmStatus, "reindex-needed">;
+    readonly lexicalText: string;
+    readonly tokens: readonly AnalyzerTokenProjection[];
+    readonly relationSignals: readonly AnalyzerRelationSignalProjection[];
+}>;
+export type EntityAnalyzerProjectionReadback = Readonly<{
+    readonly entityId: string;
+    readonly lexicalStatus: AnalyzerArmStatus;
+    readonly relationalStatus: AnalyzerArmStatus;
+    readonly lexicalArm: Readonly<{
+        readonly status: AnalyzerArmStatus;
+        readonly analyzerVersion: string | null;
+    }>;
+    readonly relationalArm: Readonly<{
+        readonly status: AnalyzerArmStatus;
+        readonly analyzerVersion: string | null;
+    }>;
+    readonly projection: EntityAnalyzerProjection | null;
+}>;
+export type RelationRow = {
+    readonly src: string;
+    readonly dst: string;
+    readonly kind: string;
+    readonly props: unknown;
+};
+export type BulkEntityRow = {
+    readonly id: string;
+    readonly kind: string;
+    readonly props: unknown;
+    readonly embedding: readonly number[] | null;
+    readonly messageId: string;
+    readonly turnId: string;
+    readonly analyzerProjection?: EntityAnalyzerProjection;
+};
+export type BulkRelationRow = {
+    readonly src: string;
+    readonly dst: string;
+    readonly kind: string;
+    readonly props: unknown;
+    readonly messageId: string;
+    readonly turnId: string;
+};
+export type RollbackResult = {
+    readonly deletedEntities: number;
+    readonly deletedRelations: number;
+};
+export type LadybugDiagnostics = {
+    readonly entityCount: number;
+    readonly relationCount: number;
+    readonly embeddedEntityCount: number;
+    readonly vectorIndexedEntityCount: number;
+    readonly ftsIndexedEntityCount: number;
+    readonly vectorIndexBuilt: boolean;
+    readonly ftsIndexBuilt: boolean;
+};
+export type TranscriptMessageRole = "user" | "assistant";
+export type TranscriptMessageStatus = "streaming" | "done" | "failed" | "aborted" | "tombstoned";
+export type TranscriptScope = {
+    readonly scenarioId: string;
+    readonly saveId: string;
+    readonly worldlineId: string;
+};
+export type TranscriptMessageRecord = TranscriptScope & {
+    readonly messageId: string;
+    readonly turnId: string;
+    readonly role: TranscriptMessageRole;
+    readonly content: string;
+    readonly status: TranscriptMessageStatus;
+    readonly createdAtMs: number;
+    readonly updatedAtMs: number;
+    /**
+     * The first committed conversation-ledger sequence for this message inside
+     * this exact scenario/save/worldline scope. Later edit/tombstone ledger
+     * events must retain this immutable identity rather than supplying their
+     * newer event sequence.
+     */
+    readonly sourceLedgerSeq: number;
+};
+export type TranscriptMessageInput = Omit<TranscriptMessageRecord, keyof TranscriptScope>;
+export type TranscriptScopedAccess = {
+    readonly scope: TranscriptScope;
+};
+export type TranscriptJournalIdentity = {
+    /** Save-scoped Runtime2 journal idempotency key. */
+    readonly idempotencyKey: string;
+    /** Hash of the sealed Runtime2 transaction payload. */
+    readonly payloadSha256: string;
+    /** Exact durable journal phase authorizing this transcript mutation. */
+    readonly phase: string;
+    readonly phaseRevision: number;
+};
+export type TranscriptPendingJournalAuthority = {
+    readonly identity: TranscriptJournalIdentity;
+    /** Digest of the exact ordered transcript records plus suffix sealed by the journal. */
+    readonly mutationPayloadSha256: string;
+    /**
+     * Exact union of pre- and post-mutation message ids sealed by the pending
+     * journal. This permits suffix removal plus replacement upserts without
+     * granting authority over unrelated rows.
+     */
+    readonly authorizedMutationMessageIds: readonly string[];
+    /** Exact upsert cohort and immutable first-ledger identities sealed by the journal. */
+    readonly requiredUpserts: readonly Readonly<{
+        readonly messageId: string;
+        readonly sourceLedgerSeq: number;
+    }>[];
+    /** Exact suffix operation sealed by the journal, or null when none is authorized. */
+    readonly suffix: TranscriptSuffixMutationSpec | null;
+};
+export type TranscriptAuthorityRequest = TranscriptScopedAccess & {
+    readonly operation: "mutation" | "recall";
+    readonly journal: TranscriptJournalIdentity | null;
+};
+export type TranscriptReachabilitySnapshot = TranscriptScope & {
+    /** Domain-separated digest/version of the host-owned active worldline lineage. */
+    readonly lineageDigest: string;
+    /** Exact active reachable user/assistant message IDs for this scope. */
+    readonly activeReachableMessageIds: readonly string[];
+    /**
+     * Host-owned pending Runtime2 journal. Ordinary recall is rejected whenever
+     * this is non-null. Mutations require an exact identity match.
+     */
+    readonly pendingJournal: TranscriptPendingJournalAuthority | null;
+};
+export type TranscriptReachabilityResolver = (request: Readonly<TranscriptAuthorityRequest>) => Promise<TranscriptReachabilitySnapshot>;
+export type TranscriptMutationAccess = TranscriptScopedAccess & {
+    readonly journal: TranscriptJournalIdentity;
+};
+export type TranscriptUpsertRequest = TranscriptMutationAccess & {
+    readonly message: TranscriptMessageInput;
+};
+export type TranscriptUpsertBatchRequest = TranscriptMutationAccess & {
+    readonly messages: readonly TranscriptMessageInput[];
+};
+export type TranscriptRecallRequest = TranscriptScopedAccess & {
+    readonly query: string;
+    readonly topK: number;
+};
+export type TranscriptRecallHit = TranscriptMessageRecord & {
+    readonly score: number;
+};
+export type TranscriptSuffixMutationSpec = {
+    /** Mutates records with sourceLedgerSeq strictly greater than this pivot. */
+    readonly afterSourceLedgerSeq: number;
+    readonly mode: "tombstone" | "delete";
+    readonly updatedAtMs: number;
+};
+export type TranscriptSuffixMutation = TranscriptMutationAccess & TranscriptSuffixMutationSpec;
+export type TranscriptMutationBatchRequest = TranscriptMutationAccess & {
+    readonly messages: readonly TranscriptMessageInput[];
+    readonly suffix?: TranscriptSuffixMutationSpec;
+};
+export type TranscriptMutationReceipt = {
+    readonly journal: TranscriptJournalIdentity;
+    readonly lineageDigest: string;
+    readonly mutationPayloadSha256: string;
+    readonly activeReachableMessageIds: readonly string[];
+    readonly upsertedMessageIds: readonly string[];
+    readonly upserts: readonly Readonly<{
+        readonly messageId: string;
+        readonly sourceLedgerSeq: number;
+    }>[];
+    readonly suffix: TranscriptSuffixMutationSpec | null;
+    readonly suffixMode: TranscriptSuffixMutationSpec["mode"] | null;
+    readonly suffixAffectedMessageIds: readonly string[];
+    readonly receiptSha256: string;
+};
+export type TranscriptMutationBatchResult = {
+    readonly messages: readonly TranscriptMessageRecord[];
+    readonly receipt: TranscriptMutationReceipt;
+};
+export type TranscriptSuffixMutationResult = {
+    readonly mode: TranscriptSuffixMutation["mode"];
+    readonly affectedMessageIds: readonly string[];
+    readonly receipt: TranscriptMutationReceipt;
+};
+declare const WORLD_MEMORY_HOST_AUTHORITY_TYPE: unique symbol;
+/**
+ * Unserializable per-bridge capability held by the trusted top-window host.
+ * Author views, business graph callers and external LLMs must never receive it.
+ */
+export type WorldMemoryHostAuthority = Readonly<{
+    readonly [WORLD_MEMORY_HOST_AUTHORITY_TYPE]: "world-memory-host-authority";
+}>;
+export declare function createWorldMemoryHostAuthority(): WorldMemoryHostAuthority;
+export type MemoryAuthorityClass = "world_fact" | "observation" | "experience" | "summary";
+export type MemoryDerivedKind = "observation" | "experience" | "summary";
+export type MemoryEpisode = {
+    readonly id: string;
+    readonly sourceMessageIds: readonly string[];
+    readonly turnBundleId: string;
+    readonly synopsis: string;
+    readonly embedding: readonly number[];
+    readonly sourceDigest: string;
+    readonly worldTimeFrom: number;
+    readonly worldTimeTo: number | null;
+    readonly recordedWriteSeq: number;
+    readonly reachability: string;
+    readonly model: string;
+    readonly provider: string;
+    readonly attemptId: string;
+    readonly schemaVersion: number;
+};
+export type MemoryClaimRoot = {
+    readonly id: string;
+    readonly subjectKind: string;
+    readonly entityId: string | null;
+    readonly attrPath: string | null;
+    readonly relationKey: string | null;
+    readonly currentClaimId: string | null;
+    readonly latestRevision: number;
+    readonly schemaVersion: number;
+};
+export type MemoryClaim = {
+    readonly id: string;
+    readonly rootId: string;
+    readonly authorityClass: "world_fact";
+    readonly status: string;
+    /** Strict canonical JSON, verified before persistence. */
+    readonly canonicalValue: string;
+    readonly canonicalValueSha256: string;
+    readonly confidence: number;
+    readonly recordedFromWriteSeq: number;
+    readonly recordedToWriteSeq: number | null;
+    readonly validFromWorldSeconds: number;
+    readonly validToWorldSeconds: number | null;
+    readonly sourceDigest: string;
+    readonly sourceEpisodeIds: readonly string[];
+    readonly sourceMessageIds: readonly string[];
+    readonly revision: number;
+    readonly schemaVersion: number;
+};
+type MemoryDerivedFields = {
+    readonly id: string;
+    readonly text: string;
+    readonly embedding: readonly number[];
+    readonly status: string;
+    readonly sourceDigest: string;
+    readonly coverageIds: readonly string[];
+    readonly summarizedThroughOpId: string | null;
+    readonly validFromWorldSeconds: number;
+    readonly validToWorldSeconds: number | null;
+    readonly recordedWriteSeq: number;
+    readonly model: string;
+    readonly provider: string;
+    readonly promptVersion: string;
+    readonly tokenizerVersion: string;
+    readonly schemaVersion: number;
+};
+export type MemoryDerived = Readonly<MemoryDerivedFields & ({
+    readonly derivedKind: "observation";
+    readonly authorityClass: "observation";
+} | {
+    readonly derivedKind: "experience";
+    readonly authorityClass: "experience";
+} | {
+    readonly derivedKind: "summary";
+    readonly authorityClass: "summary";
+})>;
+export type MemoryRelationKind = "WmEpisodeSupportsClaim" | "WmClaimSupersedesClaim" | "WmClaimContradictsClaim" | "WmDerivedFromEpisode" | "WmDerivedFromClaim" | "WmEpisodeMentionsEntity" | "WmDerivedMentionsEntity" | "WmClaimAboutEntity";
+export type MemoryRelation = {
+    readonly kind: MemoryRelationKind;
+    readonly sourceId: string;
+    readonly targetId: string;
+};
+export type MemoryVectorSearchHit = {
+    readonly id: string;
+    readonly distance: number;
+};
+export type MemoryFullTextSearchHit = {
+    readonly id: string;
+    readonly score: number;
+};
+export type MemoryClosure = {
+    readonly episodeIds?: readonly string[];
+    readonly claimRootIds?: readonly string[];
+    readonly claimIds?: readonly string[];
+    readonly derivedIds?: readonly string[];
+};
+export type MemoryClosureDeleteResult = {
+    readonly deletedEpisodes: number;
+    readonly deletedClaimRoots: number;
+    readonly deletedClaims: number;
+    readonly deletedDerived: number;
+};
+/** Narrow capability surface used by the trusted WorldMemory host module. */
+export type WorldMemoryHostAdapter = Readonly<{
+    upsertMemoryEpisode(row: MemoryEpisode): Promise<void>;
+    upsertMemoryClaimRoot(row: MemoryClaimRoot): Promise<void>;
+    upsertMemoryClaim(row: MemoryClaim): Promise<void>;
+    upsertMemoryDerived(row: MemoryDerived): Promise<void>;
+    upsertMemoryRelation(row: MemoryRelation): Promise<void>;
+    getClaimRoot(id: string): Promise<MemoryClaimRoot | null>;
+    getClaimsByRoot(rootId: string): Promise<MemoryClaim[]>;
+    resolveClaimsForEntities(entityIds: readonly string[]): Promise<MemoryClaim[]>;
+    vectorSearchEpisodes(query: readonly number[], topK: number, config?: QueryConfig): Promise<MemoryVectorSearchHit[]>;
+    fullTextSearchEpisodes(query: string, topK: number, config?: QueryConfig): Promise<MemoryFullTextSearchHit[]>;
+    vectorSearchDerived(query: readonly number[], topK: number, config?: QueryConfig): Promise<MemoryVectorSearchHit[]>;
+    fullTextSearchDerived(query: string, topK: number, config?: QueryConfig): Promise<MemoryFullTextSearchHit[]>;
+    deleteMemoryClosure(closure: MemoryClosure): Promise<MemoryClosureDeleteResult>;
+    snapshotWorldMemory(): Promise<WorldMemorySnapshot>;
+    captureWorldMemoryView(): Promise<WorldMemoryView>;
+    worldMemoryStateDigest(): Promise<string>;
+    stateIdentity(): Promise<Readonly<{
+        physicalStateSha256: string;
+        writeSequence: number;
+    }>>;
+    restoreWorldMemorySnapshot(snapshot: WorldMemorySnapshot): Promise<void>;
+}>;
+export type WorldMemorySnapshot = {
+    readonly episodes: readonly MemoryEpisode[];
+    readonly claimRoots: readonly MemoryClaimRoot[];
+    readonly claims: readonly MemoryClaim[];
+    readonly derived: readonly MemoryDerived[];
+    readonly relations: readonly MemoryRelation[];
+    readonly episodeVectorIndexBuilt: boolean;
+    readonly episodeFtsIndexBuilt: boolean;
+    readonly derivedVectorIndexBuilt: boolean;
+    readonly derivedFtsIndexBuilt: boolean;
+};
+export type WorldMemoryView = Readonly<{
+    readonly snapshot: WorldMemorySnapshot;
+    readonly identity: Readonly<{
+        readonly snapshotSha256: string;
+        readonly revision: number;
+    }>;
+}>;
+export type NeighborRow = {
+    readonly id: string;
+    readonly kind: string;
+    readonly edgeKind: string;
+    readonly depth: number;
+};
+export type VectorHit = {
+    readonly id: string;
+    readonly distance: number;
+};
+export type GraphRagSeed = {
+    readonly id: string;
+    readonly distance: number;
+};
+export type NodeProvenance = {
+    readonly seedId: string;
+    readonly hop: number;
+};
+export type GraphRagNode = {
+    readonly entity: EntityRow;
+    readonly provenance: readonly NodeProvenance[];
+};
+export type GraphRagResult = {
+    readonly seeds: readonly GraphRagSeed[];
+    readonly nodes: readonly GraphRagNode[];
+    readonly edges: readonly RelationRow[];
+};
+export declare const STRUCTURED_TRIGGER_LOCK_REASON_LOCKED_UNTIL: "locked_until";
+export declare const STRUCTURED_TRIGGER_LOCK_REASON_ENTER_WHEN: "enter_when";
+export type StructuredTriggerLockReason = typeof STRUCTURED_TRIGGER_LOCK_REASON_LOCKED_UNTIL | typeof STRUCTURED_TRIGGER_LOCK_REASON_ENTER_WHEN;
+export type StructuredTriggerLock = {
+    readonly trigger_id: string;
+    readonly reason: StructuredTriggerLockReason | string;
+};
+export type StructuredObjectValue = {
+    readonly type: "object";
+    readonly inner_keys: readonly string[];
+    readonly expandable: boolean;
+};
+export type StructuredValue = StructuredObjectValue | unknown;
+export type StructuredEntry = {
+    readonly key: string;
+    readonly value: StructuredValue;
+    readonly expandable: boolean;
+    readonly trigger_lock?: StructuredTriggerLock;
+};
+export type RecallStructured = {
+    readonly entities: readonly StructuredEntry[];
+};
+export declare function isStructuredObjectValue(v: unknown): v is StructuredObjectValue;
+export type LadybugBridgeOptions = {
+    readonly dim: number;
+    readonly workerPath?: string;
+    /** Trusted host authority. Transcript APIs fail closed when it is absent. */
+    readonly resolveTranscriptReachability?: TranscriptReachabilityResolver;
+    /** Exact object-identity capability required to obtain the WorldMemory adapter. */
+    readonly worldMemoryHostAuthority?: WorldMemoryHostAuthority;
+};
+/**
+ * Structural capability passed only to the trusted Rust/WASM runtime.
+ * It exposes the graph methods consumed by `LadybugStore`, while keeping
+ * WorldMemory raw tables behind `WorldMemoryHostAdapter`.
+ */
+export type LadybugWasmRuntimeAdapter = Readonly<Pick<LadybugBridge, "allEntities" | "allRelations" | "attrHistoryCheck" | "beginTransaction" | "bulkUpsertEntities" | "bulkUpsertRelations" | "close" | "commitTransaction" | "createFtsIndex" | "createVectorIndex" | "deleteEntity" | "deleteRelation" | "diagnostics" | "dropFtsIndex" | "dropVectorIndex" | "entityCount" | "findByKind" | "fullTextSearch" | "getById" | "hasEmbedding" | "hasFtsIndex" | "hasVectorIndex" | "init" | "latchClear" | "latchCommitBatch" | "latchLoad" | "latchRollback" | "neighbors" | "pruneAttrHistory" | "query" | "queryAttrHistory" | "recallAndExpand" | "recallCandidateRecord" | "relationCount" | "rollbackAfterMessage" | "rollbackAttrHistoryAfterMessage" | "rollbackTransaction" | "stateDigest" | "upsertAttrHistory" | "upsertEntity" | "upsertRelation" | "vectorSearch"> & {
+    worldMemoryStateDigest(): Promise<string>;
+    restoreWorldMemorySnapshotInTransaction(snapshot: WorldMemorySnapshot): Promise<void>;
+}>;
+export type IndexConfig = {
+    readonly metric?: string;
+    readonly mu?: number;
+    readonly ml?: number;
+    readonly efc?: number;
+    readonly cache_embeddings?: boolean;
+    readonly stemmer?: string;
+    readonly tokenizer?: string;
+    readonly stopwords?: string;
+};
+export type QueryConfig = {
+    readonly efs?: number;
+    readonly bm25_k1?: number;
+    readonly bm25_b?: number;
+    readonly conjunctive?: boolean;
+};
+export type NeighborsOptions = {
+    readonly entityKinds?: readonly string[];
+    readonly relationKinds?: readonly string[];
+};
+export declare const WM_EPISODE_VECTOR_INDEX = "WM_EPISODE_VECTOR_INDEX";
+export declare const WM_EPISODE_FTS_INDEX = "WM_EPISODE_FTS_INDEX";
+export declare const WM_DERIVED_VECTOR_INDEX = "WM_DERIVED_VECTOR_INDEX";
+export declare const WM_DERIVED_FTS_INDEX = "WM_DERIVED_FTS_INDEX";
+export declare const SNAPSHOT_PROVENANCE_MESSAGE_ID = "__initial_snapshot__";
+export type LatchState = "open" | "closed" | "dead";
+export type LatchSource = "deterministic" | "judge";
+export type LeafLatchRow = {
+    readonly scenario_id: string;
+    readonly leaf_id: string;
+    readonly state: LatchState;
+    readonly first_fired_at_ms: number;
+    readonly last_evaluated_at_ms: number;
+    readonly fire_count: number;
+    readonly source: LatchSource;
+    readonly confidence: number;
+};
+export type AttrHistoryRow = {
+    readonly attrHistoryId: string;
+    readonly entityId: string;
+    readonly attrPath: string;
+    readonly oldValueText: string | null;
+    readonly newValueText: string;
+    readonly replacedAtMessageId: string;
+    readonly replacedAtTurnId: string;
+    readonly replacedAtWriteSeq: number;
+    readonly superseded: boolean;
+};
+export type AttrHistoryCheckResult = {
+    readonly superseded: boolean;
+    readonly supersededByMessageId?: string;
+};
+/**
+ * Produces the host journal's canonical digest for one ordered transcript
+ * mutation. The bridge recomputes the same digest before touching Ladybug.
+ */
+export declare function computeTranscriptMutationPayloadSha256(input: Pick<TranscriptMutationBatchRequest, "scope" | "messages" | "suffix">): Promise<string>;
+export declare class LadybugBridge {
+    private readonly dim;
+    private readonly variant;
+    private db;
+    private conn;
+    private ready;
+    private vectorIndexBuilt;
+    private ftsIndexBuilt;
+    private vectorIndexedEntityCount;
+    private ftsIndexedEntityCount;
+    private memoryEpisodeVectorIndexBuilt;
+    private memoryEpisodeFtsIndexBuilt;
+    private memoryDerivedVectorIndexBuilt;
+    private memoryDerivedFtsIndexBuilt;
+    private transcriptFtsBuilt;
+    private transcriptQueue;
+    private transcriptOperationReservations;
+    private transcriptOperationActive;
+    private graphRollbackInProgress;
+    private initializing;
+    private closing;
+    private readonly transcriptReachabilityResolver;
+    private readonly worldMemoryHostAuthority;
+    private worldMemoryQueue;
+    private worldMemoryOperationReservations;
+    private worldMemoryRevision;
+    private _writeSeq;
+    private tx;
+    private assertWorldMemoryHostAuthority;
+    createWorldMemoryHostAdapter(authority: WorldMemoryHostAuthority): WorldMemoryHostAdapter;
+    createWasmRuntimeAdapter(authority: WorldMemoryHostAuthority): LadybugWasmRuntimeAdapter;
+    private nextSeq;
+    private withWorldMemoryHostLock;
+    private advanceWorldMemoryRevision;
+    private captureWorldMemoryView;
+    private worldMemorySnapshotSha256;
+    private captureStateIdentity;
+    private withTranscriptLock;
+    private withTranscriptOperationIsolation;
+    private resolveTranscriptAuthority;
+    private assertTranscriptReachabilityCoverage;
+    isInTransaction(): boolean;
+    beginTransaction(): void;
+    commitTransaction(): void;
+    rollbackTransaction(): Promise<void>;
+    withTransaction<T>(fn: () => Promise<T>): Promise<T>;
+    private applyUndoOp;
+    private restoreAttrHistoryRowsDuringRollback;
+    private restoreLatchRowsDuringRollback;
+    private snapshotEntity;
+    private snapshotEntityAnalyzerProjection;
+    private snapshotRelation;
+    private recordEntityUndoBeforeWrite;
+    private recordRelationUndoBeforeWrite;
+    private recordEntityUndoBeforeDelete;
+    private recordRelationUndoBeforeDelete;
+    private recordAttrHistoryUndo;
+    private recordAllAttrHistoryUndo;
+    private recordLatchScenarioUndo;
+    private recordRollbackAfterMessageUndo;
+    constructor(options: LadybugBridgeOptions, variant?: LadybugVariant);
+    init(): Promise<void>;
+    private requireConnUnchecked;
+    private requireConn;
+    private queryDuringRollback;
+    private runDuringRollback;
+    private assertStatementCannotAddressWorldMemory;
+    private assertBusinessStatementCannotAddressWorldMemory;
+    private queryForWasmRuntime;
+    private queryInternal;
+    private runInternal;
+    query(statement: string): Promise<Record<string, unknown>[]>;
+    run(statement: string, params: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+    private queryWorldMemory;
+    private runWorldMemory;
+    /**
+     * Redacted full-state CAS used by the Runtime 2 transaction barrier. Raw
+     * rows never cross the bridge; only a domain-separated digest is returned.
+     */
+    stateDigest(): Promise<string>;
+    recallCandidateRecord(id: string): Promise<RecallCandidateRecord | null>;
+    private createSchema;
+    private createWorldMemorySchema;
+    private executeWorldMemoryQuery;
+    private ensureWorldMemoryIndexes;
+    private dropMemoryEpisodeIndexes;
+    private dropMemoryDerivedIndexes;
+    private rebuildMemoryEpisodeIndexes;
+    private rebuildMemoryDerivedIndexes;
+    private toMemoryEpisode;
+    private toMemoryClaimRoot;
+    private toMemoryClaim;
+    private toMemoryDerived;
+    private listMemoryEpisodes;
+    private listMemoryClaimRoots;
+    private memoryClaimProjection;
+    private listMemoryClaims;
+    private listMemoryDerived;
+    private listMemoryRelations;
+    private snapshotWorldMemory;
+    private recordWorldMemoryUndo;
+    private recordWorldMemoryUndoIfTransaction;
+    private normalizeMemoryEpisode;
+    private normalizeMemoryClaimRoot;
+    private normalizeMemoryClaim;
+    private normalizeMemoryDerived;
+    private normalizeMemoryRelation;
+    private normalizeWorldMemorySnapshot;
+    private executeWorldMemoryRun;
+    private writeMemoryEpisode;
+    private writeMemoryClaimRoot;
+    private writeMemoryClaim;
+    private writeMemoryDerived;
+    private writeMemoryRelation;
+    private assertWorldMemoryExternalEntityReferences;
+    private replaceWorldMemorySnapshot;
+    private restoreWorldMemorySnapshot;
+    private restoreWorldMemorySnapshotInTransaction;
+    private restoreWorldMemorySnapshotFromHost;
+    private upsertMemoryEpisode;
+    private upsertMemoryClaimRoot;
+    private upsertMemoryClaim;
+    private upsertMemoryDerived;
+    private upsertMemoryRelation;
+    private getClaimRoot;
+    private getClaimsByRoot;
+    private resolveClaimsForEntities;
+    private vectorSearchEpisodes;
+    private fullTextSearchEpisodes;
+    private vectorSearchDerived;
+    private fullTextSearchDerived;
+    private deleteMemoryClosure;
+    private transcriptPk;
+    private toTranscriptMessage;
+    private writeTranscriptRecord;
+    private readTranscriptByPk;
+    private listTranscriptScope;
+    private restoreTranscriptScope;
+    private invalidateTranscriptFtsIndex;
+    private ensureTranscriptFtsIndex;
+    upsertTranscriptMessage(request: TranscriptUpsertRequest): Promise<TranscriptMessageRecord>;
+    upsertTranscriptMessages(request: TranscriptUpsertBatchRequest): Promise<TranscriptMutationBatchResult>;
+    /**
+     * Applies the pending journal's suffix operation and replacement/upsert cohort
+     * under one bridge lock. A failure restores the exact pre-operation scope;
+     * process loss restores the last SAV-backed in-memory database checkpoint.
+     */
+    mutateTranscriptMessagesBatch(request: TranscriptMutationBatchRequest): Promise<TranscriptMutationBatchResult>;
+    recallTranscriptMessages(request: TranscriptRecallRequest): Promise<TranscriptRecallHit[]>;
+    mutateTranscriptSuffix(input: TranscriptSuffixMutation): Promise<TranscriptSuffixMutationResult>;
+    private latchPk;
+    latchLoad(scenarioId: string): Promise<LeafLatchRow[]>;
+    latchCommitBatch(scenarioId: string, rows: ReadonlyArray<LeafLatchRow>): Promise<number>;
+    latchClear(scenarioId: string): Promise<void>;
+    latchRollback(scenarioId: string, leafIds: ReadonlyArray<string>): Promise<void>;
+    upsertAttrHistory(rows: ReadonlyArray<AttrHistoryRow>): Promise<void>;
+    queryAttrHistory(entityId: string, attrPath: string): Promise<AttrHistoryRow[]>;
+    attrHistoryCheck(entityId: string, attrPath: string, valueText: string): Promise<AttrHistoryCheckResult>;
+    pruneAttrHistory(entityId: string, attrPath: string, maxRetain?: number): Promise<number>;
+    rollbackAttrHistoryAfterMessage(messageId: string): Promise<number>;
+    attrHistoryCount(): Promise<number>;
+    private assertMaxRetain;
+    private toAttrHistory;
+    createVectorIndex(config?: IndexConfig): Promise<void>;
+    dropVectorIndex(): Promise<void>;
+    createFtsIndex(config?: IndexConfig): Promise<void>;
+    private buildVectorIndexArgs;
+    private buildFtsIndexArgs;
+    dropFtsIndex(): Promise<void>;
+    hasVectorIndex(): boolean;
+    hasFtsIndex(): boolean;
+    /**
+     * 只读运行时诊断。只返回数量与索引状态，不跨 wasm 边界暴露实体 props/embedding 明文。
+     * `vectorIndexedEntityCount` 只在本 bridge 成功完成 CREATE_VECTOR_INDEX 后计数，
+     * 因而可用于提交屏障确认 HNSW 已覆盖当前全部 embedding 行。
+     */
+    diagnostics(): Promise<LadybugDiagnostics>;
+    upsertEntity(id: string, kind: string, props: unknown, embedding: readonly number[] | null, messageId?: string, turnId?: string, analyzerProjection?: EntityAnalyzerProjection): Promise<void>;
+    private replaceEntityAnalyzerProjection;
+    getEntityAnalyzerProjection(entityId: string): Promise<EntityAnalyzerProjectionReadback>;
+    bulkUpsertEntities(entries: ReadonlyArray<BulkEntityRow>): Promise<void>;
+    bulkUpsertRelations(entries: ReadonlyArray<BulkRelationRow>): Promise<void>;
+    upsertRelation(src: string, dst: string, kind: string, props: unknown, messageId?: string, turnId?: string): Promise<void>;
+    deleteEntity(id: string): Promise<void>;
+    rollbackAfterMessage(messageId: string): Promise<RollbackResult>;
+    deleteRelation(src: string, dst: string): Promise<void>;
+    getById(id: string): Promise<EntityRow | null>;
+    findByKind(kind: string): Promise<EntityRow[]>;
+    allEntities(): Promise<EntityRow[]>;
+    allRelations(): Promise<RelationRow[]>;
+    neighbors(id: string, depth: number, options?: NeighborsOptions): Promise<NeighborRow[]>;
+    vectorSearch(query: readonly number[], topK: number, config?: QueryConfig): Promise<VectorHit[]>;
+    fullTextSearch(query: string, topK: number, config?: QueryConfig): Promise<string[]>;
+    recallAndExpand(query: readonly number[], topK: number, depth: number, config?: QueryConfig): Promise<GraphRagResult>;
+    private buildFtsQueryArgs;
+    private recallCypher;
+    private rebuildGraphRag;
+    private toStringList;
+    private toEntity;
+    private toRelation;
+    private toNeighbor;
+    entityCount(): Promise<number>;
+    relationCount(): Promise<number>;
+    hasEmbedding(id: string): Promise<boolean>;
+    close(): Promise<void>;
+}