Class ME

constructor

• new ME(seed?: string, options?: MEOptions): ME

  Parameters

  • Optionalseed: string
  • options: MEOptions = {}

  Returns ME

_ownerScope

_currentCallerScope

memories

• get memories(): Memory[]

  Public redacted memory log. This never exposes internal forensic fields such as effectiveSecret.

  Returns Memory[]

encryptedBranches

• get encryptedBranches(): EncryptedBranchPlane

  Returns EncryptedBranchPlane

• set encryptedBranches(value: EncryptedBranchPlane): void

  Parameters

  • value: EncryptedBranchPlane

  Returns void

inspect

• inspect(opts?: { last?: number }): MEInspectResult

  Inspect the current runtime state. Returned memories are always public/redacted.

  Parameters

  • Optionalopts: { last?: number }

  Returns MEInspectResult

explain

• explain(path: string): MEExplainResult

  Explain how a semantic path is derived. Useful for debugging pointers, operators, and derived values.

  Parameters

  • path: string

  Returns MEExplainResult

execute

• execute(rawTarget: string | MeTargetAst, body?: any): any

  Execute a raw target string or parsed target AST without going through proxy property access. Useful for tooling, explicit runtime dispatch, and tests.

  Parameters

  • rawTarget: string | MeTargetAst
  • Optionalbody: any

  Returns any

searchExact

• searchExact(
      scopePath: string | SemanticPath,
      query: ArrayLike<number>,
      options?: MESearchExactOptions,
  ): MESearchExactResult

  Exact vector search over a collection-scoped secret branch backed by chunked columnar storage. This is the correctness baseline used before approximate indexes such as IVF.

  Parameters

  • scopePath: string | SemanticPath
  • query: ArrayLike<number>
  • options: MESearchExactOptions = {}

  Returns MESearchExactResult

buildVectorIndex

• buildVectorIndex(
      scopePath: string | SemanticPath,
      options?: MEVectorIndexBuildOptions,
  ): MEVectorIndexBuildResult

  Build an approximate IVF sidecar for a collection-scoped secret vector corpus. The sidecar lives outside the kernel log and is intended to reduce chunk decrypts during search.

  Parameters

  • scopePath: string | SemanticPath
  • options: MEVectorIndexBuildOptions = {}

  Returns MEVectorIndexBuildResult

searchVector

• searchVector(
      scopePath: string | SemanticPath,
      query: ArrayLike<number>,
      options?: MEVectorSearchOptions,
  ): MEVectorSearchResult

  Approximate vector search backed by the IVF sidecar. Uses centroids for coarse routing and exact scan only on the selected candidate chunks.

  Parameters

  • scopePath: string | SemanticPath
  • query: ArrayLike<number>
  • options: MEVectorSearchOptions = {}

  Returns MEVectorSearchResult

exportSnapshot

• exportSnapshot(): MESnapshot

  Export a portable public snapshot. Snapshot memories are redacted and omit internal forensic fields.

  Returns MESnapshot

hydrate

• hydrate(snapshot: MESnapshotInput): void

  Hydrate the runtime from a snapshot payload. This is the primary restore API for bringing a saved kernel back to life in memory.

  Parameters

  • snapshot: MESnapshotInput

  Returns void

importSnapshot

• importSnapshot(snapshot: MESnapshotInput): void

  Import a snapshot into the current runtime. Accepts both redacted public snapshots and legacy/internal payloads. Prefer hydrate() in user-facing code.

  Parameters

  • snapshot: MESnapshotInput

  Returns void

rehydrate

• rehydrate(snapshot: MESnapshotInput): void

  Rehydrate the runtime from a snapshot payload. Backward-compatible alias for hydrate().

  Parameters

  • snapshot: MESnapshotInput

  Returns void

replayMemories

• replayMemories(memories: ReplayMemoryInput[]): void

  Replay a memory log into the current runtime. Accepts both public Memory[] and legacy/internal memory payloads.

  Parameters

  • memories: ReplayMemoryInput[]

  Returns void

learn

• learn(memory: unknown): void

  Ingest a single memory-like payload into the runtime. Useful for tools that already operate at the memory-log layer.

  Parameters

  • memory: unknown

  Returns void

prove

• prove(input: MEProofInput): Promise<MEProofResult>

  Derive a branch-scoped proof for the current active expression. This signs a canonical payload with an Ed25519 key deterministically derived from the root seed and active branch expression.

  Parameters

  • input: MEProofInput

  Returns Promise<MEProofResult>

setRecomputeMode

• setRecomputeMode(mode: "eager" | "lazy"): this

  Control whether derivations recompute eagerly or lazily.

  Parameters

  • mode: "eager" | "lazy"

  Returns this

getRecomputeMode

• getRecomputeMode(): "eager" | "lazy"

  Read the current derivation recompute mode.

  Returns "eager" | "lazy"

as

• as(scope: string | null): ME

  Parameters

  • scope: string | null

  Returns ME

withScope

• withScope<T>(scope: string | null, fn: () => T): T

  Type Parameters

  • T

  Parameters

  • scope: string | null
  • fn: () => T

  Returns T