lore

README

Lore Go SDK

About

This repository contains the Go SDK for integrating with Lore.

Lore is an open source version control system that is designed for unprecedented scalability of both data and teams. It is optimized for projects that combine code with large binary assets, including games and entertainment, and caters to the needs of developers and artists alike.

For full Lore documentation, architecture details, and contribution guidelines, visit the main Lore repository.

Install

Stable Release

go get github.com/EpicGames/lore-go@latest

Install the Lore native library

The Go SDK binds against the Lore C library (liblore.so / liblore.dylib / lore.dll). Run fetch-lore-lib once per build to install the matching version next to your application binary:

go run github.com/EpicGames/lore-go/cmd/fetch-lore-lib

• -o <output_dir> — destination directory (defaults to the current directory)
• -os <target_os> and -arch <target_arch> — fetch the library for a different platform (e.g. -os linux -arch amd64 for cross-compilation)

To automate this, add a directive to your main.go so go generate ./... installs the library:

//go:generate go run github.com/EpicGames/lore-go/cmd/fetch-lore-lib

Source priority for fetch-lore-lib:

1. LORE_LIB_PATH — if set, the file at that path is copied. This env var is also honored by the SDK at runtime (point it at a .so / .dylib / .dll file and both fetch-time and runtime use it).
2. Otherwise the library is downloaded from LORE_RELEASE_BASE_URL, falling back to the URL baked into the SDK at build time (see Generate the Go bindings). The URL is constructed as <base>/<versionTag>/<artifactName>.

At runtime the SDK also searches next to the compiled executable, so a go generate-installed library is found automatically.

Minimal example

The default package (github.com/EpicGames/lore-go) exposes the high-level fluent API. A low-level, C-like wrapper around the underlying FFI is also available under github.com/EpicGames/lore-go/native for advanced use cases.

import (
    "fmt"

    "github.com/EpicGames/lore-go"
    "github.com/EpicGames/lore-go/types"
)

lore.LogConfigure(&types.LoreLogConfigFFI{
    File:     true,
    FilePath: "/path/to/log/directory",
    Level:    types.LoreLogLevel_DEBUG,
})

globals := types.LoreGlobalArgsFFI{
    RepositoryPath: "/path/to/local/repository",
}
args := types.LoreRepositoryStatusArgsFFI{
    Staged: true,
    Scan:   true,
}
_, err := lore.RepositoryStatus(&globals, &args).
    Callback(func(event types.LoreEvent) {
        if event.Tag == types.LoreEventTag_REPOSITORY_STATUS_FILE {
            fmt.Println(event.Data)
        }
    }).
    Wait()

For comprehensive examples, see examples/fluent/fluent.go (fluent) and examples/native/native.go (low-level).

Contributing

Set up your dev environment

1. Clone the Lore Go SDK repository:

git clone https://github.com/EpicGames/lore-go

1. (Optional) Create a Python virtual environment for the binding generator:

uv venv .venv
source .venv/bin/activate

1. Install the Python modules used by the binding generator:

uv pip install jinja2 pycparser

Get the Lore library

The SDK binds against the Lore C library. Pick one of the two options below depending on whether you're also modifying the Lore core.

Option A — build the library from Lore source

Use this when you're changing the Lore C/Rust core alongside the Go SDK.

1. Clone Lore's repository and build it:

cargo build --release

Option B — fetch a pre-built Lore library

Use this when you only need to develop the Go SDK against an existing Lore version.

1. Download the header and binaries from the Lore repository release page.

Generate the Go bindings

1. Point LORE_BUILD_PATH at the library directory from the previous section:

export LORE_BUILD_PATH="<path-to>/lore/"

1. (Optional) Set LORE_RELEASE_BASE_URL and LORE_VERSION to bake a default download base URL into cmd/fetch-lore-lib/version.go. End users of the published SDK will use this URL when running fetch-lore-lib without overriding it themselves. If unset, generation falls back to the public Lore release URL.

export LORE_RELEASE_BASE_URL="https://github.com/EpicGames/lore/releases/download"
export LORE_VERSION="0.8.2"

1. Generate the bindings and build the SDK:

uv run python find_lorelib.py
uv run python generator/generate.py
go build -C lore_go

1. Any edits you now make under lore_go/ are picked up by re-running go build. If you change anything under generator/templates/ or pull a new Lore pre-built binary, re-run step 3 to regenerate the bindings.

Run the examples

With the dev environment set up, a Lore library available, and the Go bindings generated, run an example from the repository root:

export LORE_LIB_PATH="lore/lib/lorelib-arm64-apple-darwin.dylib"
go generate -C examples ./...
go build -C examples -o fluent ./fluent
examples/fluent/fluent

To run the low-level native example instead, swap fluent for native.

Run the test suite

go test -C lore_go ./... -v

Documentation

Index

• Variables
• func GlobalCallback(eventType types.LoreEventTag, callback types.LoreEventCallback) func()
• func LogConfigure(logConfig *types.LoreLogConfigFFI) (int32, error)
• func SetThreadLimit(count uintptr) (int32, error)
• func Shutdown() (int32, error)
• func Version() (string, error)
• type LoreCall
  • func AuthClear(globals *types.LoreGlobalArgsFFI, args *types.LoreAuthClearArgsFFI) *LoreCall[types.LoreAuthClearArgsFFI]
  • func AuthList(globals *types.LoreGlobalArgsFFI, args *types.LoreAuthListArgsFFI) *LoreCall[types.LoreAuthListArgsFFI]
  • func AuthLocalUserInfo(globals *types.LoreGlobalArgsFFI, args *types.LoreAuthLocalUserInfoArgsFFI) *LoreCall[types.LoreAuthLocalUserInfoArgsFFI]
  • func AuthLoginInteractive(globals *types.LoreGlobalArgsFFI, args *types.LoreAuthLoginInteractiveArgsFFI) *LoreCall[types.LoreAuthLoginInteractiveArgsFFI]
  • func AuthLoginWithToken(globals *types.LoreGlobalArgsFFI, args *types.LoreAuthLoginWithTokenArgsFFI) *LoreCall[types.LoreAuthLoginWithTokenArgsFFI]
  • func AuthLogout(globals *types.LoreGlobalArgsFFI, args *types.LoreAuthLogoutArgsFFI) *LoreCall[types.LoreAuthLogoutArgsFFI]
  • func AuthUserInfo(globals *types.LoreGlobalArgsFFI, args *types.LoreAuthUserInfoArgsFFI) *LoreCall[types.LoreAuthUserInfoArgsFFI]
  • func BranchArchive(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchArchiveArgsFFI) *LoreCall[types.LoreBranchArchiveArgsFFI]
  • func BranchCreate(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchCreateArgsFFI) *LoreCall[types.LoreBranchCreateArgsFFI]
  • func BranchDiff(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchDiffArgsFFI) *LoreCall[types.LoreBranchDiffArgsFFI]
  • func BranchInfo(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchInfoArgsFFI) *LoreCall[types.LoreBranchInfoArgsFFI]
  • func BranchList(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchListArgsFFI) *LoreCall[types.LoreBranchListArgsFFI]
  • func BranchMergeAbort(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchMergeAbortArgsFFI) *LoreCall[types.LoreBranchMergeAbortArgsFFI]
  • func BranchMergeInto(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchMergeIntoArgsFFI) *LoreCall[types.LoreBranchMergeIntoArgsFFI]
  • func BranchMergeResolve(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchMergeResolveArgsFFI) *LoreCall[types.LoreBranchMergeResolveArgsFFI]
  • func BranchMergeResolveMine(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreBranchMergeResolveMineArgsFFI]
  • func BranchMergeResolveTheirs(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreBranchMergeResolveTheirsArgsFFI]
  • func BranchMergeRestart(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchMergeRestartArgsFFI) *LoreCall[types.LoreBranchMergeRestartArgsFFI]
  • func BranchMergeStart(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchMergeStartArgsFFI) *LoreCall[types.LoreBranchMergeStartArgsFFI]
  • func BranchMergeUnresolve(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchMergeUnresolveArgsFFI) *LoreCall[types.LoreBranchMergeUnresolveArgsFFI]
  • func BranchMetadataClear(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchMetadataClearArgsFFI) *LoreCall[types.LoreBranchMetadataClearArgsFFI]
  • func BranchMetadataGet(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchMetadataGetArgsFFI) *LoreCall[types.LoreBranchMetadataGetArgsFFI]
  • func BranchMetadataSet(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchMetadataSetArgsFFI) *LoreCall[types.LoreBranchMetadataSetArgsFFI]
  • func BranchProtect(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchProtectArgsFFI) *LoreCall[types.LoreBranchProtectArgsFFI]
  • func BranchPush(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchPushArgsFFI) *LoreCall[types.LoreBranchPushArgsFFI]
  • func BranchReset(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchResetArgsFFI) *LoreCall[types.LoreBranchResetArgsFFI]
  • func BranchSwitch(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchSwitchArgsFFI) *LoreCall[types.LoreBranchSwitchArgsFFI]
  • func BranchUnprotect(globals *types.LoreGlobalArgsFFI, args *types.LoreBranchUnprotectArgsFFI) *LoreCall[types.LoreBranchUnprotectArgsFFI]
  • func FileDependencyAdd(globals *types.LoreGlobalArgsFFI, args *types.LoreFileDependencyAddArgsFFI) *LoreCall[types.LoreFileDependencyAddArgsFFI]
  • func FileDependencyList(globals *types.LoreGlobalArgsFFI, args *types.LoreFileDependencyListArgsFFI) *LoreCall[types.LoreFileDependencyListArgsFFI]
  • func FileDependencyRemove(globals *types.LoreGlobalArgsFFI, args *types.LoreFileDependencyRemoveArgsFFI) *LoreCall[types.LoreFileDependencyRemoveArgsFFI]
  • func FileDiff(globals *types.LoreGlobalArgsFFI, args *types.LoreFileDiffArgsFFI) *LoreCall[types.LoreFileDiffArgsFFI]
  • func FileDirty(globals *types.LoreGlobalArgsFFI, args *types.LoreFileDirtyArgsFFI) *LoreCall[types.LoreFileDirtyArgsFFI]
  • func FileDirtyCopy(globals *types.LoreGlobalArgsFFI, args *types.LoreFileDirtyCopyArgsFFI) *LoreCall[types.LoreFileDirtyCopyArgsFFI]
  • func FileDirtyMove(globals *types.LoreGlobalArgsFFI, args *types.LoreFileDirtyMoveArgsFFI) *LoreCall[types.LoreFileDirtyMoveArgsFFI]
  • func FileDump(globals *types.LoreGlobalArgsFFI, args *types.LoreFileDumpArgsFFI) *LoreCall[types.LoreFileDumpArgsFFI]
  • func FileHash(globals *types.LoreGlobalArgsFFI, args *types.LoreFileHashArgsFFI) *LoreCall[types.LoreFileHashArgsFFI]
  • func FileHistory(globals *types.LoreGlobalArgsFFI, args *types.LoreFileHistoryArgsFFI) *LoreCall[types.LoreFileHistoryArgsFFI]
  • func FileInfo(globals *types.LoreGlobalArgsFFI, args *types.LoreFileInfoArgsFFI) *LoreCall[types.LoreFileInfoArgsFFI]
  • func FileMetadataClear(globals *types.LoreGlobalArgsFFI, args *types.LoreFileMetadataClearArgsFFI) *LoreCall[types.LoreFileMetadataClearArgsFFI]
  • func FileMetadataGet(globals *types.LoreGlobalArgsFFI, args *types.LoreFileMetadataGetArgsFFI) *LoreCall[types.LoreFileMetadataGetArgsFFI]
  • func FileMetadataList(globals *types.LoreGlobalArgsFFI, args *types.LoreFileMetadataListArgsFFI) *LoreCall[types.LoreFileMetadataListArgsFFI]
  • func FileMetadataSet(globals *types.LoreGlobalArgsFFI, args *types.LoreFileMetadataSetArgsFFI) *LoreCall[types.LoreFileMetadataSetArgsFFI]
  • func FileObliterate(globals *types.LoreGlobalArgsFFI, args *types.LoreFileObliterateArgsFFI) *LoreCall[types.LoreFileObliterateArgsFFI]
  • func FileReset(globals *types.LoreGlobalArgsFFI, args *types.LoreFileResetArgsFFI) *LoreCall[types.LoreFileResetArgsFFI]
  • func FileResetToLastMerged(globals *types.LoreGlobalArgsFFI, args *types.LoreFileResetToLastMergedArgsFFI) *LoreCall[types.LoreFileResetToLastMergedArgsFFI]
  • func FileStage(globals *types.LoreGlobalArgsFFI, args *types.LoreFileStageArgsFFI) *LoreCall[types.LoreFileStageArgsFFI]
  • func FileStageMerge(globals *types.LoreGlobalArgsFFI, args *types.LoreFileStageMergeArgsFFI) *LoreCall[types.LoreFileStageMergeArgsFFI]
  • func FileStageMove(globals *types.LoreGlobalArgsFFI, args *types.LoreFileStageMoveArgsFFI) *LoreCall[types.LoreFileStageMoveArgsFFI]
  • func FileUnstage(globals *types.LoreGlobalArgsFFI, args *types.LoreFileUnstageArgsFFI) *LoreCall[types.LoreFileUnstageArgsFFI]
  • func FileWrite(globals *types.LoreGlobalArgsFFI, args *types.LoreFileWriteArgsFFI) *LoreCall[types.LoreFileWriteArgsFFI]
  • func LayerAdd(globals *types.LoreGlobalArgsFFI, args *types.LoreLayerAddArgsFFI) *LoreCall[types.LoreLayerAddArgsFFI]
  • func LayerList(globals *types.LoreGlobalArgsFFI, args *types.LoreLayerListArgsFFI) *LoreCall[types.LoreLayerListArgsFFI]
  • func LayerRemove(globals *types.LoreGlobalArgsFFI, args *types.LoreLayerRemoveArgsFFI) *LoreCall[types.LoreLayerRemoveArgsFFI]
  • func LinkAdd(globals *types.LoreGlobalArgsFFI, args *types.LoreLinkAddArgsFFI) *LoreCall[types.LoreLinkAddArgsFFI]
  • func LinkList(globals *types.LoreGlobalArgsFFI, args *types.LoreLinkListArgsFFI) *LoreCall[types.LoreLinkListArgsFFI]
  • func LinkRemove(globals *types.LoreGlobalArgsFFI, args *types.LoreLinkRemoveArgsFFI) *LoreCall[types.LoreLinkRemoveArgsFFI]
  • func LinkUpdate(globals *types.LoreGlobalArgsFFI, args *types.LoreLinkUpdateArgsFFI) *LoreCall[types.LoreLinkUpdateArgsFFI]
  • func LockFileAcquire(globals *types.LoreGlobalArgsFFI, args *types.LoreLockFileAcquireArgsFFI) *LoreCall[types.LoreLockFileAcquireArgsFFI]
  • func LockFileQuery(globals *types.LoreGlobalArgsFFI, args *types.LoreLockFileQueryArgsFFI) *LoreCall[types.LoreLockFileQueryArgsFFI]
  • func LockFileRelease(globals *types.LoreGlobalArgsFFI, args *types.LoreLockFileReleaseArgsFFI) *LoreCall[types.LoreLockFileReleaseArgsFFI]
  • func LockFileStatus(globals *types.LoreGlobalArgsFFI, args *types.LoreLockFileStatusArgsFFI) *LoreCall[types.LoreLockFileStatusArgsFFI]
  • func NotificationSubscribe(globals *types.LoreGlobalArgsFFI, args *types.LoreNotificationSubscribeArgsFFI) *LoreCall[types.LoreNotificationSubscribeArgsFFI]
  • func NotificationUnsubscribe(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreNotificationUnsubscribeArgsFFI]
  • func RepositoryClone(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryCloneArgsFFI) *LoreCall[types.LoreRepositoryCloneArgsFFI]
  • func RepositoryConfigGet(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryConfigGetArgsFFI) *LoreCall[types.LoreRepositoryConfigGetArgsFFI]
  • func RepositoryCreate(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryCreateArgsFFI) *LoreCall[types.LoreRepositoryCreateArgsFFI]
  • func RepositoryDump(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryDumpArgsFFI) *LoreCall[types.LoreRepositoryDumpArgsFFI]
  • func RepositoryFlush(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryFlushArgsFFI) *LoreCall[types.LoreRepositoryFlushArgsFFI]
  • func RepositoryGc(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryGcArgsFFI) *LoreCall[types.LoreRepositoryGcArgsFFI]
  • func RepositoryInfo(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryInfoArgsFFI) *LoreCall[types.LoreRepositoryInfoArgsFFI]
  • func RepositoryInstanceList(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreRepositoryInstanceListArgsFFI]
  • func RepositoryInstancePrune(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreRepositoryInstancePruneArgsFFI]
  • func RepositoryList(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryListArgsFFI) *LoreCall[types.LoreRepositoryListArgsFFI]
  • func RepositoryMetadataClear(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreRepositoryMetadataClearArgsFFI]
  • func RepositoryMetadataGet(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryMetadataGetArgsFFI) *LoreCall[types.LoreRepositoryMetadataGetArgsFFI]
  • func RepositoryMetadataSet(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryMetadataSetArgsFFI) *LoreCall[types.LoreRepositoryMetadataSetArgsFFI]
  • func RepositoryRelease(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryReleaseArgsFFI) *LoreCall[types.LoreRepositoryReleaseArgsFFI]
  • func RepositoryStatus(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryStatusArgsFFI) *LoreCall[types.LoreRepositoryStatusArgsFFI]
  • func RepositoryStoreImmutableQuery(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreRepositoryStoreImmutableQueryArgsFFI]
  • func RepositoryUpdatePath(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryUpdatePathArgsFFI) *LoreCall[types.LoreRepositoryUpdatePathArgsFFI]
  • func RepositoryVerifyState(globals *types.LoreGlobalArgsFFI, args *types.LoreRepositoryVerifyStateArgsFFI) *LoreCall[types.LoreRepositoryVerifyStateArgsFFI]
  • func RevisionAmend(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionAmendArgsFFI) *LoreCall[types.LoreRevisionAmendArgsFFI]
  • func RevisionCommit(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionCommitArgsFFI) *LoreCall[types.LoreRevisionCommitArgsFFI]
  • func RevisionDiff(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionDiffArgsFFI) *LoreCall[types.LoreRevisionDiffArgsFFI]
  • func RevisionFind(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionFindArgsFFI) *LoreCall[types.LoreRevisionFindArgsFFI]
  • func RevisionHistory(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionHistoryArgsFFI) *LoreCall[types.LoreRevisionHistoryArgsFFI]
  • func RevisionInfo(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionInfoArgsFFI) *LoreCall[types.LoreRevisionInfoArgsFFI]
  • func RevisionMetadataClear(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionMetadataClearArgsFFI) *LoreCall[types.LoreRevisionMetadataClearArgsFFI]
  • func RevisionMetadataGet(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionMetadataGetArgsFFI) *LoreCall[types.LoreRevisionMetadataGetArgsFFI]
  • func RevisionMetadataList(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionMetadataListArgsFFI) *LoreCall[types.LoreRevisionMetadataListArgsFFI]
  • func RevisionMetadataSet(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionMetadataSetArgsFFI) *LoreCall[types.LoreRevisionMetadataSetArgsFFI]
  • func RevisionRestore(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionRestoreArgsFFI) *LoreCall[types.LoreRevisionRestoreArgsFFI]
  • func RevisionRevert(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionRevertArgsFFI) *LoreCall[types.LoreRevisionRevertArgsFFI]
  • func RevisionRevertAbort(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionRevertAbortArgsFFI) *LoreCall[types.LoreRevisionRevertAbortArgsFFI]
  • func RevisionRevertResolve(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionRevertResolveArgsFFI) *LoreCall[types.LoreRevisionRevertResolveArgsFFI]
  • func RevisionRevertResolveMine(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreRevisionRevertResolveMineArgsFFI]
  • func RevisionRevertResolveTheirs(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreRevisionRevertResolveTheirsArgsFFI]
  • func RevisionRevertRestart(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionRevertRestartArgsFFI) *LoreCall[types.LoreRevisionRevertRestartArgsFFI]
  • func RevisionRevertUnresolve(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreRevisionRevertUnresolveArgsFFI]
  • func RevisionSync(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionSyncArgsFFI) *LoreCall[types.LoreRevisionSyncArgsFFI]
  • func RevisionTreeClose(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionTreeCloseArgsFFI) *LoreCall[types.LoreRevisionTreeCloseArgsFFI]
  • func RevisionTreeInfo(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionTreeInfoArgsFFI) *LoreCall[types.LoreRevisionTreeInfoArgsFFI]
  • func RevisionTreeListChildren(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreRevisionTreeListChildrenArgsFFI]
  • func RevisionTreeLoad(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionTreeLoadArgsFFI) *LoreCall[types.LoreRevisionTreeLoadArgsFFI]
  • func RevisionTreeNodeInfo(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionTreeNodeInfoArgsFFI) *LoreCall[types.LoreRevisionTreeNodeInfoArgsFFI]
  • func RevisionTreeNodePath(globals *types.LoreGlobalArgsFFI, args *types.LoreRevisionTreeNodePathArgsFFI) *LoreCall[types.LoreRevisionTreeNodePathArgsFFI]
  • func RevisionTreeResolvePath(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreRevisionTreeResolvePathArgsFFI]
  • func ServiceStart(globals *types.LoreGlobalArgsFFI, args *types.LoreServiceStartArgsFFI) *LoreCall[types.LoreServiceStartArgsFFI]
  • func ServiceStop(globals *types.LoreGlobalArgsFFI, args *types.LoreServiceStopArgsFFI) *LoreCall[types.LoreServiceStopArgsFFI]
  • func SharedStoreCreate(globals *types.LoreGlobalArgsFFI, args *types.LoreSharedStoreCreateArgsFFI) *LoreCall[types.LoreSharedStoreCreateArgsFFI]
  • func SharedStoreInfo(globals *types.LoreGlobalArgsFFI, args *types.LoreSharedStoreInfoArgsFFI) *LoreCall[types.LoreSharedStoreInfoArgsFFI]
  • func SharedStoreSetUseAutomatically(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreSharedStoreSetUseAutomaticallyArgsFFI]
  • func StorageClose(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageCloseArgsFFI) *LoreCall[types.LoreStorageCloseArgsFFI]
  • func StorageCopy(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageCopyArgsFFI) *LoreCall[types.LoreStorageCopyArgsFFI]
  • func StorageFlush(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageFlushArgsFFI) *LoreCall[types.LoreStorageFlushArgsFFI]
  • func StorageGet(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageGetArgsFFI) *LoreCall[types.LoreStorageGetArgsFFI]
  • func StorageGetFile(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageGetFileArgsFFI) *LoreCall[types.LoreStorageGetFileArgsFFI]
  • func StorageGetMetadata(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageGetMetadataArgsFFI) *LoreCall[types.LoreStorageGetMetadataArgsFFI]
  • func StorageMutableCompareAndSwap(globals *types.LoreGlobalArgsFFI, ...) *LoreCall[types.LoreStorageMutableCompareAndSwapArgsFFI]
  • func StorageMutableList(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageMutableListArgsFFI) *LoreCall[types.LoreStorageMutableListArgsFFI]
  • func StorageMutableLoad(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageMutableLoadArgsFFI) *LoreCall[types.LoreStorageMutableLoadArgsFFI]
  • func StorageMutableStore(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageMutableStoreArgsFFI) *LoreCall[types.LoreStorageMutableStoreArgsFFI]
  • func StorageObliterate(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageObliterateArgsFFI) *LoreCall[types.LoreStorageObliterateArgsFFI]
  • func StorageOpen(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageOpenArgsFFI) *LoreCall[types.LoreStorageOpenArgsFFI]
  • func StoragePut(globals *types.LoreGlobalArgsFFI, args *types.LoreStoragePutArgsFFI) *LoreCall[types.LoreStoragePutArgsFFI]
  • func StoragePutFile(globals *types.LoreGlobalArgsFFI, args *types.LoreStoragePutFileArgsFFI) *LoreCall[types.LoreStoragePutFileArgsFFI]
  • func StorageUpload(globals *types.LoreGlobalArgsFFI, args *types.LoreStorageUploadArgsFFI) *LoreCall[types.LoreStorageUploadArgsFFI]
  • func (c *LoreCall[TArgs]) AsyncIter() (<-chan types.LoreEvent, <-chan error)
  • func (c *LoreCall[TArgs]) Callback(fn types.LoreEventCallback) *LoreCall[TArgs]
  • func (c *LoreCall[TArgs]) Collect() ([]types.LoreEvent, error)
  • func (c *LoreCall[TArgs]) FilterByType(tags ...types.LoreEventTag) *LoreCall[TArgs]
  • func (c *LoreCall[TArgs]) UserContext(ctx uint64) *LoreCall[TArgs]
  • func (c *LoreCall[TArgs]) Wait() (int32, error)
• type LoreCallExecutor
• type LoreError
  • func (e *LoreError) Error() string

Variables

var ErrAlreadyStarted = fmt.Errorf("operation has already started")

ErrAlreadyStarted is returned when Wait() or Collect() is called on a LoreCall that has already started.

var ErrCallbackSet = fmt.Errorf("Collect() or AsyncIter() cannot be used with Callback(); use Wait() instead")

ErrCallbackSet is returned when Collect() or AsyncIter() is called on a LoreCall that has a callback set.

Functions

func GlobalCallback

func GlobalCallback(eventType types.LoreEventTag, callback types.LoreEventCallback) func()

GlobalCallback registers a global callback handler for events with the given type. The callback will be invoked for all Lore operations that emit events of this type, regardless of which terminating method (Wait, Collect, AsyncIter) is used. Multiple callbacks can be registered for the same event type. Returns a cleanup function that unregisters the callback when called.

Example usage:

cleanup := lore.GlobalCallback(types.LoreEventTag_LOG, func(event *types.LoreEventFFI, userContext uint64) {
    if data, ok := event.GetData().(*types.LoreLogEventDataFFI); ok {
        log.Printf("[Lore] %s", data.Message.String())
    }
})
defer cleanup()

func LogConfigure

func LogConfigure(logConfig *types.LoreLogConfigFFI) (int32, error)

LogConfigure configures Lore logging.

func SetThreadLimit

func SetThreadLimit(count uintptr) (int32, error)

SetThreadLimit limits the total number of threads Lore sizes its pools for. Must be called before the first Lore operation. Returns 0 if the limit was applied, or 1 if it had already been set (or the runtime was already running) — the latter is not treated as an error.

func Shutdown

func Shutdown() (int32, error)

Shutdown shuts down the Lore library.

func Version

func Version() (string, error)

Version returns the Lore library version string.

Types

type LoreCall

type LoreCall[TArgs any] struct {
	// contains filtered or unexported fields
}

LoreCall is a cold handle for a Lore operation. It does not execute until a terminating method like Wait() is called.

func AuthClear

func AuthClear(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreAuthClearArgsFFI,
) *LoreCall[types.LoreAuthClearArgsFFI]

Clear all stored authentication data.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func AuthList

func AuthList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreAuthListArgsFFI,
) *LoreCall[types.LoreAuthListArgsFFI]

List all stored authentication identities.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Auth Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_AUTH_IDENTITY` | `lore_auth_identity_event_data_t` | Emitted once per stored identity |

func AuthLocalUserInfo

func AuthLocalUserInfo(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreAuthLocalUserInfoArgsFFI,
) *LoreCall[types.LoreAuthLocalUserInfoArgsFFI]

Resolve user identities to display names from locally stored JWT tokens.

Does not contact the auth service. Decodes cached JWT tokens to extract display names. For user IDs without a local token, returns the raw user ID. For remote resolution with proper authorization, use `lore_auth_user_info` which queries the remote authentication service.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Auth Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_AUTH_USER_INFO` | `lore_auth_user_info_event_data_t` | Emitted with the resolved user id and display name |

func AuthLoginInteractive

func AuthLoginInteractive(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreAuthLoginInteractiveArgsFFI,
) *LoreCall[types.LoreAuthLoginInteractiveArgsFFI]

Authenticate interactively via a browser-based login flow.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Auth Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_AUTH_URL` | `lore_auth_url_event_data_t` | Emitted with the login URL when no_browser mode is requested | | `LORE_EVENT_AUTH_USER_INFO` | `lore_auth_user_info_event_data_t` | Emitted with user id and display name after successful interactive authentication |

func AuthLoginWithToken

func AuthLoginWithToken(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreAuthLoginWithTokenArgsFFI,
) *LoreCall[types.LoreAuthLoginWithTokenArgsFFI]

Authenticate using an existing bearer token.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Auth Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_AUTH_USER_INFO` | `lore_auth_user_info_event_data_t` | Emitted with user id and display name after successful token authentication |

func AuthLogout

func AuthLogout(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreAuthLogoutArgsFFI,
) *LoreCall[types.LoreAuthLogoutArgsFFI]

Remove stored authentication and authorization tokens.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func AuthUserInfo

func AuthUserInfo(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreAuthUserInfoArgsFFI,
) *LoreCall[types.LoreAuthUserInfoArgsFFI]

Resolve user IDs to display names using the remote authentication service.

Requires an authenticated connection.

When no user IDs are provided, returns the current user's identity using locally cached tokens (equivalent to `lore_auth_local_user_info`).

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Auth Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_AUTH_USER_INFO` | `lore_auth_user_info_event_data_t` | Emitted with user id and display name for each resolved user |

func BranchArchive

func BranchArchive(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchArchiveArgsFFI,
) *LoreCall[types.LoreBranchArchiveArgsFFI]

Archive a branch in the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_ARCHIVE` | `lore_branch_archive_event_data_t` | Emitted when the branch has been successfully archived |

func BranchCreate

func BranchCreate(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchCreateArgsFFI,
) *LoreCall[types.LoreBranchCreateArgsFFI]

Create a new branch in the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_CREATE` | `lore_branch_create_event_data_t` | Emitted when the branch has been successfully created, includes branch name and id |

func BranchDiff

func BranchDiff(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchDiffArgsFFI,
) *LoreCall[types.LoreBranchDiffArgsFFI]

Show the changes and conflicts between two branches.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_DIFF_BEGIN` | `lore_branch_diff_begin_event_data_t` | Emitted before diff results begin streaming | | `LORE_EVENT_BRANCH_DIFF_CHANGE_BEGIN` | `lore_branch_diff_change_begin_event_data_t` | Emitted before the list of changed files begins | | `LORE_EVENT_BRANCH_DIFF_CHANGE` | `lore_branch_diff_change_event_data_t` | Emitted for each changed file between the two branches | | `LORE_EVENT_BRANCH_DIFF_CHANGE_END` | `lore_branch_diff_change_end_event_data_t` | Emitted after all changed files have been reported | | `LORE_EVENT_BRANCH_DIFF_CONFLICT_BEGIN` | `lore_branch_diff_conflict_begin_event_data_t` | Emitted before the list of conflicting files begins | | `LORE_EVENT_BRANCH_DIFF_CONFLICT` | `lore_branch_diff_conflict_event_data_t` | Emitted for each file that has a conflict between the two branches | | `LORE_EVENT_BRANCH_DIFF_CONFLICT_END` | `lore_branch_diff_conflict_end_event_data_t` | Emitted after all conflict files have been reported | | `LORE_EVENT_BRANCH_DIFF_END` | `lore_branch_diff_end_event_data_t` | Emitted after all diff results have been streamed |

func BranchInfo

func BranchInfo(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchInfoArgsFFI,
) *LoreCall[types.LoreBranchInfoArgsFFI]

Retrieve metadata about a specific branch.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_INFO` | `lore_branch_info_event_data_t` | Emitted with branch metadata (name, id, category, protection status, etc.) |

func BranchList

func BranchList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchListArgsFFI,
) *LoreCall[types.LoreBranchListArgsFFI]

List all branches in the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_LIST_BEGIN` | `lore_branch_list_begin_event_data_t` | Emitted before branch list entries begin streaming | | `LORE_EVENT_BRANCH_LIST_ENTRY` | `lore_branch_list_entry_event_data_t` | Emitted for each branch in the repository | | `LORE_EVENT_BRANCH_LIST_END` | `lore_branch_list_end_event_data_t` | Emitted after all branch entries have been streamed |

func BranchMergeAbort

func BranchMergeAbort(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMergeAbortArgsFFI,
) *LoreCall[types.LoreBranchMergeAbortArgsFFI]

Abort an in-progress branch merge and restore the pre-merge state.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_MERGE_ABORT_BEGIN` | `lore_branch_merge_abort_begin_event_data_t` | Emitted when aborting a branch merge, includes staged and current revision hashes | | `LORE_EVENT_BRANCH_MERGE_ABORT_END` | `lore_branch_merge_abort_end_event_data_t` | Emitted after the merge abort has been completed | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during file realization while reverting merge changes |

func BranchMergeInto

func BranchMergeInto(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMergeIntoArgsFFI,
) *LoreCall[types.LoreBranchMergeIntoArgsFFI]

Merge the current branch into a target branch.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_MERGE_INTO_FILE_BEGIN` | `lore_branch_merge_into_file_begin_event_data_t` | Emitted when starting to merge files into the target branch | | `LORE_EVENT_BRANCH_MERGE_INTO_FILE` | `lore_branch_merge_into_file_event_data_t` | Emitted for each file being merged into the target branch | | `LORE_EVENT_BRANCH_MERGE_INTO_FILE_END` | `lore_branch_merge_into_file_end_event_data_t` | Emitted after all files have been merged | | `LORE_EVENT_BRANCH_MERGE_INTO_FRAGMENT_BEGIN` | `lore_branch_merge_into_fragment_begin_event_data_t` | Emitted when starting fragment transfer for a file | | `LORE_EVENT_BRANCH_MERGE_INTO_FRAGMENT_PROGRESS` | `lore_branch_merge_into_fragment_progress_event_data_t` | Emitted periodically during fragment transfer | | `LORE_EVENT_BRANCH_MERGE_INTO_FRAGMENT_END` | `lore_branch_merge_into_fragment_end_event_data_t` | Emitted when fragment transfer for a file completes | | `LORE_EVENT_BRANCH_MERGE_INTO_REVISION` | `lore_branch_merge_into_revision_event_data_t` | Emitted with the resulting revision after the merge into is complete | | `LORE_EVENT_BRANCH_MERGE_INTO_SYNC_BEGIN` | `lore_branch_merge_into_sync_begin_event_data_t` | Emitted when starting to apply the changes on the target state | | `LORE_EVENT_BRANCH_MERGE_INTO_SYNC_END` | `lore_branch_merge_into_sync_end_event_data_t` | Emitted after applying the changes on the target state is complete | | `LORE_EVENT_REVISION_COMMIT_BEGIN` | `lore_revision_commit_begin_event_data_t` | Emitted when auto-commit starts (if no conflicts) | | `LORE_EVENT_REVISION_COMMIT_PROGRESS` | `lore_revision_commit_progress_event_data_t` | Emitted periodically during auto-commit file processing | | `LORE_EVENT_REVISION_COMMIT_END` | `lore_revision_commit_end_event_data_t` | Emitted when auto-commit file processing completes | | `LORE_EVENT_REVISION_COMMIT_REVISION` | `lore_revision_commit_revision_event_data_t` | Emitted with the committed revision details | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during changes realization | | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for each metadata entry of the committed revision | | `LORE_EVENT_FRAGMENT_WRITE` | `lore_fragment_write_event_data_t` | Emitted for each file fragment written or deduplicated during commit |

func BranchMergeResolve

func BranchMergeResolve(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMergeResolveArgsFFI,
) *LoreCall[types.LoreBranchMergeResolveArgsFFI]

Mark conflicting files in a merge as resolved.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_MERGE_RESOLVE_FILE` | `lore_branch_merge_resolve_file_event_data_t` | Emitted for each file that was marked as resolved | | `LORE_EVENT_BRANCH_MERGE_RESOLVE_REVISION` | `lore_branch_merge_resolve_revision_event_data_t` | Emitted with the updated staged revision after resolve completes |

func BranchMergeResolveMine

func BranchMergeResolveMine(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMergeResolveMineArgsFFI,
) *LoreCall[types.LoreBranchMergeResolveMineArgsFFI]

Resolve a merge conflict by accepting the "mine" version of each conflicting file.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_MERGE_RESOLVE_FILE` | `lore_branch_merge_resolve_file_event_data_t` | Emitted for each file resolved by keeping "mine" | | `LORE_EVENT_BRANCH_MERGE_RESOLVE_REVISION` | `lore_branch_merge_resolve_revision_event_data_t` | Emitted with the updated staged revision |

func BranchMergeResolveTheirs

func BranchMergeResolveTheirs(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMergeResolveTheirsArgsFFI,
) *LoreCall[types.LoreBranchMergeResolveTheirsArgsFFI]

Resolve a merge conflict by accepting the "theirs" version of each conflicting file.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_MERGE_RESOLVE_FILE` | `lore_branch_merge_resolve_file_event_data_t` | Emitted for each file resolved by keeping "theirs" | | `LORE_EVENT_BRANCH_MERGE_RESOLVE_REVISION` | `lore_branch_merge_resolve_revision_event_data_t` | Emitted with the updated staged revision |

func BranchMergeRestart

func BranchMergeRestart(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMergeRestartArgsFFI,
) *LoreCall[types.LoreBranchMergeRestartArgsFFI]

Restart an in-progress merge, re-materializing conflicted files.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_MERGE_CONFLICT_FILE` | `lore_branch_merge_conflict_file_event_data_t` | Emitted for each file with a remaining merge conflict | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during file realization during restart | | `LORE_EVENT_REVISION_SYNC_FILE` | `lore_revision_sync_file_event_data_t` | Emitted for each file re-materialized during restart |

func BranchMergeStart

func BranchMergeStart(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMergeStartArgsFFI,
) *LoreCall[types.LoreBranchMergeStartArgsFFI]

Start a merge from another branch into the current branch.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_MERGE_START_BEGIN` | `lore_branch_merge_start_begin_event_data_t` | Emitted when merge begins, includes source branch and revision info | | `LORE_EVENT_BRANCH_MERGE_START_END` | `lore_branch_merge_start_end_event_data_t` | Emitted when merge operation completes, includes sync stats and conflict flag | | `LORE_EVENT_BRANCH_MERGE_CONFLICT_FILE` | `lore_branch_merge_conflict_file_event_data_t` | Emitted for each file with an unresolved merge conflict | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during the apply_diff phase of the merge | | `LORE_EVENT_REVISION_SYNC_FILE` | `lore_revision_sync_file_event_data_t` | Emitted for each file modified during merge realization | | `LORE_EVENT_FILE_STAGE_FILE` | `lore_file_stage_file_event_data_t` | Emitted for each file staged for deletion during merge realization | | `LORE_EVENT_REVISION_COMMIT_BEGIN` | `lore_revision_commit_begin_event_data_t` | Emitted when auto-commit starts (no conflicts, no_commit=false) | | `LORE_EVENT_REVISION_COMMIT_PROGRESS` | `lore_revision_commit_progress_event_data_t` | Emitted periodically during auto-commit | | `LORE_EVENT_REVISION_COMMIT_END` | `lore_revision_commit_end_event_data_t` | Emitted when auto-commit file processing completes | | `LORE_EVENT_REVISION_COMMIT_REVISION` | `lore_revision_commit_revision_event_data_t` | Emitted with the committed revision details | | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for each metadata entry of the committed revision | | `LORE_EVENT_FRAGMENT_WRITE` | `lore_fragment_write_event_data_t` | Emitted for each fragment written during auto-commit |

func BranchMergeUnresolve

func BranchMergeUnresolve(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMergeUnresolveArgsFFI,
) *LoreCall[types.LoreBranchMergeUnresolveArgsFFI]

Mark conflicting files in a merge as unresolved.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_MERGE_UNRESOLVE_FILE` | `lore_branch_merge_unresolve_file_event_data_t` | Emitted for each file that was marked as unresolved | | `LORE_EVENT_BRANCH_MERGE_UNRESOLVE_REVISION` | `lore_branch_merge_unresolve_revision_event_data_t` | Emitted with the updated staged revision after unresolve completes |

func BranchMetadataClear

func BranchMetadataClear(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMetadataClearArgsFFI,
) *LoreCall[types.LoreBranchMetadataClearArgsFFI]

Clear branch metadata keys.

func BranchMetadataGet

func BranchMetadataGet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMetadataGetArgsFFI,
) *LoreCall[types.LoreBranchMetadataGetArgsFFI]

Retrieve branch metadata.

func BranchMetadataSet

func BranchMetadataSet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchMetadataSetArgsFFI,
) *LoreCall[types.LoreBranchMetadataSetArgsFFI]

Set branch metadata key-value pairs.

func BranchProtect

func BranchProtect(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchProtectArgsFFI,
) *LoreCall[types.LoreBranchProtectArgsFFI]

Enable write protection on a branch to prevent direct commits.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_PROTECT` | `lore_branch_protect_event_data_t` | Emitted when the branch has been successfully protected |

func BranchPush

func BranchPush(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchPushArgsFFI,
) *LoreCall[types.LoreBranchPushArgsFFI]

Push local branch commits to the remote repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_PUSH` | `lore_branch_push_event_data_t` | Emitted when push begins, includes branch name and revision info | | `LORE_EVENT_BRANCH_PUSH_BRANCH_CREATE_BEGIN` | `lore_branch_push_branch_create_begin_event_data_t` | Emitted when creating the remote branch (first push) | | `LORE_EVENT_BRANCH_PUSH_BRANCH_CREATE_END` | `lore_branch_push_branch_create_end_event_data_t` | Emitted when remote branch creation completes | | `LORE_EVENT_BRANCH_PUSH_REVISION_UPDATE_BEGIN` | `lore_branch_push_revision_update_begin_event_data_t` | Emitted when updating a revision on the remote | | `LORE_EVENT_BRANCH_PUSH_REVISION_UPDATE_END` | `lore_branch_push_revision_update_end_event_data_t` | Emitted when a revision update completes | | `LORE_EVENT_BRANCH_PUSH_FRAGMENT_BEGIN` | `lore_branch_push_fragment_begin_event_data_t` | Emitted when uploading fragment data begins | | `LORE_EVENT_BRANCH_PUSH_FRAGMENT_PROGRESS` | `lore_branch_push_fragment_progress_event_data_t` | Emitted periodically during fragment upload | | `LORE_EVENT_BRANCH_PUSH_FRAGMENT_END` | `lore_branch_push_fragment_end_event_data_t` | Emitted when fragment upload completes | | `LORE_EVENT_BRANCH_PUSH_REVISION_PUSH_BEGIN` | `lore_branch_push_revision_push_begin_event_data_t` | Emitted when pushing a revision to the remote begins | | `LORE_EVENT_BRANCH_PUSH_REVISION_PUSH_UPDATE` | `lore_branch_push_revision_push_update_event_data_t` | Emitted with progress updates during revision push | | `LORE_EVENT_BRANCH_PUSH_REVISION_PUSH_END` | `lore_branch_push_revision_push_end_event_data_t` | Emitted when revision push completes |

func BranchReset

func BranchReset(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchResetArgsFFI,
) *LoreCall[types.LoreBranchResetArgsFFI]

Reset the current branch to a specific revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_RESET` | `lore_branch_reset_event_data_t` | Emitted when the branch has been reset to the target revision |

func BranchSwitch

func BranchSwitch(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchSwitchArgsFFI,
) *LoreCall[types.LoreBranchSwitchArgsFFI]

Switch to a different branch and update the working directory.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_SWITCH_BEGIN` | `lore_branch_switch_begin_event_data_t` | Emitted when branch switch starts | | `LORE_EVENT_BRANCH_SWITCH_END` | `lore_branch_switch_end_event_data_t` | Emitted when branch switch completes successfully | | `LORE_EVENT_REVISION_SYNC_TARGET` | `lore_revision_sync_target_event_data_t` | Emitted with target revision info after resolving the switch target | | `LORE_EVENT_REVISION_SYNC_FILE` | `lore_revision_sync_file_event_data_t` | Emitted for each file modified/added/deleted during switch | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted periodically during file realization | | `LORE_EVENT_REVISION_SYNC_REVISION` | `lore_revision_sync_revision_event_data_t` | Emitted with the resulting revision after switch | | `LORE_EVENT_FILTER_EXCLUDE` | `lore_filter_exclude_event_data_t` | Emitted for each path excluded by view or ignore filters | | `LORE_EVENT_REVISION_RESOLVE` | `lore_revision_resolve_event_data_t` | Emitted when resolving a partial revision reference |

func BranchUnprotect

func BranchUnprotect(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreBranchUnprotectArgsFFI,
) *LoreCall[types.LoreBranchUnprotectArgsFFI]

Remove write protection from a branch.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Branch Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_BRANCH_UNPROTECT` | `lore_branch_unprotect_event_data_t` | Emitted when the branch has been successfully unprotected |

func FileDependencyAdd

func FileDependencyAdd(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileDependencyAddArgsFFI,
) *LoreCall[types.LoreFileDependencyAddArgsFFI]

Adds dependency relationships between files.

Events

## Standard Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Dependency Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_DEPENDENCY_ADD_BEGIN` | `lore_file_dependency_add_begin_event_data_t` | Start of operation | | `LORE_EVENT_FILE_DEPENDENCY_ADD_ENTRY` | `lore_file_dependency_add_entry_event_data_t` | Each dependency added | | `LORE_EVENT_FILE_DEPENDENCY_ADD_END` | `lore_file_dependency_add_end_event_data_t` | Operation complete |

func FileDependencyList

func FileDependencyList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileDependencyListArgsFFI,
) *LoreCall[types.LoreFileDependencyListArgsFFI]

Queries dependency information for files.

Events

## Standard Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Dependency Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_DEPENDENCY_LIST_BEGIN` | `lore_file_dependency_list_begin_event_data_t` | Start of listing | | `LORE_EVENT_FILE_DEPENDENCY_LIST_FILE` | `lore_file_dependency_list_file_event_data_t` | Start of entries for one file | | `LORE_EVENT_FILE_DEPENDENCY_LIST_ENTRY` | `lore_file_dependency_list_entry_event_data_t` | One dependency entry | | `LORE_EVENT_FILE_DEPENDENCY_LIST_FILE_END` | `lore_file_dependency_list_file_end_event_data_t` | End of entries for one file | | `LORE_EVENT_FILE_DEPENDENCY_LIST_END` | `lore_file_dependency_list_end_event_data_t` | End of listing |

func FileDependencyRemove

func FileDependencyRemove(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileDependencyRemoveArgsFFI,
) *LoreCall[types.LoreFileDependencyRemoveArgsFFI]

Removes dependency relationships between files.

Events

## Standard Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Dependency Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_DEPENDENCY_REMOVE_BEGIN` | `lore_file_dependency_remove_begin_event_data_t` | Start of operation | | `LORE_EVENT_FILE_DEPENDENCY_REMOVE_ENTRY` | `lore_file_dependency_remove_entry_event_data_t` | Each dependency removed | | `LORE_EVENT_FILE_DEPENDENCY_REMOVE_END` | `lore_file_dependency_remove_end_event_data_t` | Operation complete |

func FileDiff

func FileDiff(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileDiffArgsFFI,
) *LoreCall[types.LoreFileDiffArgsFFI]

Show which files differ between two revisions.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_DIFF` | `lore_file_diff_event_data_t` | Emitted for each file that differs between the two revisions |

func FileDirty

func FileDirty(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileDirtyArgsFFI,
) *LoreCall[types.LoreFileDirtyArgsFFI]

Mark files as dirty in the staged state without staging their content.

Action is determined by checking filesystem existence and current revision state (modify, add, delete, or revert-add). Respects ignore and view filters.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_PATH_IGNORE` | `lore_path_ignore_event_data_t` | Emitted for each input path that could not be resolved to a repository-relative path | | `LORE_EVENT_FILTER_EXCLUDE` | `lore_filter_exclude_event_data_t` | Emitted for each path excluded by view or ignore filters |

func FileDirtyCopy

func FileDirtyCopy(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileDirtyCopyArgsFFI,
) *LoreCall[types.LoreFileDirtyCopyArgsFFI]

Mark a file as dirty-copied from one path to another in the staged state.

Creates a new destination node flagged `DirtyCopy`; the source node is unchanged. No filesystem access is performed.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func FileDirtyMove

func FileDirtyMove(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileDirtyMoveArgsFFI,
) *LoreCall[types.LoreFileDirtyMoveArgsFFI]

Mark a file as dirty-moved from one path to another in the staged state.

Updates the source node's parent/name and flags it with `DirtyMove`, propagating `Dirty` to both the old and new parent directories. For directories, the move is propagated recursively to children. No filesystem access is performed.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func FileDump

func FileDump(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileDumpArgsFFI,
) *LoreCall[types.LoreFileDumpArgsFFI]

Retrieve the binary content of a file at a specific revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_DUMP` | `lore_file_dump_event_data_t` | Emitted with binary content of the requested file |

func FileHash

func FileHash(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileHashArgsFFI,
) *LoreCall[types.LoreFileHashArgsFFI]

Compute the hash of a local file for comparison with repository content.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_HASH` | `lore_file_hash_event_data_t` | Emitted with the computed hash and size of the specified file |

func FileHistory

func FileHistory(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileHistoryArgsFFI,
) *LoreCall[types.LoreFileHistoryArgsFFI]

Retrieve the revision history for a specific file.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_HISTORY` | `lore_file_history_event_data_t` | Emitted for each revision in which the file was modified |

func FileInfo

func FileInfo(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileInfoArgsFFI,
) *LoreCall[types.LoreFileInfoArgsFFI]

Retrieve metadata for one or more files in the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_INFO` | `lore_file_info_event_data_t` | Emitted for each file with its metadata (size, hash, staged status, etc.) |

func FileMetadataClear

func FileMetadataClear(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileMetadataClearArgsFFI,
) *LoreCall[types.LoreFileMetadataClearArgsFFI]

Clear all metadata from a file.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_METADATA_CLEAR_FILE` | `lore_metadata_clear_file_event_data_t` | Emitted when metadata has been cleared for the file |

func FileMetadataGet

func FileMetadataGet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileMetadataGetArgsFFI,
) *LoreCall[types.LoreFileMetadataGetArgsFFI]

Get a specific metadata key/value pair from a file.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for the requested metadata key/value pair |

func FileMetadataList

func FileMetadataList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileMetadataListArgsFFI,
) *LoreCall[types.LoreFileMetadataListArgsFFI]

List all metadata key/value pairs associated with a file.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for each metadata key/value pair associated with the file |

func FileMetadataSet

func FileMetadataSet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileMetadataSetArgsFFI,
) *LoreCall[types.LoreFileMetadataSetArgsFFI]

Set a metadata key/value pair on a file.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func FileObliterate

func FileObliterate(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileObliterateArgsFFI,
) *LoreCall[types.LoreFileObliterateArgsFFI]

Permanently remove a file and all its history from the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_OBLITERATE` | `lore_file_obliterate_event_data_t` | Emitted for each file permanently removed from repository history |

func FileReset

func FileReset(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileResetArgsFFI,
) *LoreCall[types.LoreFileResetArgsFFI]

Reset files to the state recorded in the current or target revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_RESET_BEGIN` | `lore_file_reset_begin_event_data_t` | Emitted when reset starts, includes path count | | `LORE_EVENT_FILE_RESET_PROGRESS` | `lore_file_reset_progress_event_data_t` | Emitted periodically during file reset with progress counts | | `LORE_EVENT_FILE_RESET_END` | `lore_file_reset_end_event_data_t` | Emitted when reset completes | | `LORE_EVENT_FILE_RESET_FILE` | `lore_file_reset_file_event_data_t` | Emitted for each file that was reset | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during file realization | | `LORE_EVENT_REVISION_SYNC_FILE` | `lore_revision_sync_file_event_data_t` | Emitted for each file materialized | | `LORE_EVENT_FILTER_EXCLUDE` | `lore_filter_exclude_event_data_t` | Emitted for each path excluded by filters |

func FileResetToLastMerged

func FileResetToLastMerged(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileResetToLastMergedArgsFFI,
) *LoreCall[types.LoreFileResetToLastMergedArgsFFI]

Reset files to their state at the last merged revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_RESET_BEGIN` | `lore_file_reset_begin_event_data_t` | Emitted when reset starts | | `LORE_EVENT_FILE_RESET_PROGRESS` | `lore_file_reset_progress_event_data_t` | Emitted periodically during file reset | | `LORE_EVENT_FILE_RESET_END` | `lore_file_reset_end_event_data_t` | Emitted when reset completes | | `LORE_EVENT_FILE_RESET_FILE` | `lore_file_reset_file_event_data_t` | Emitted for each file that was reset | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during file realization | | `LORE_EVENT_REVISION_SYNC_FILE` | `lore_revision_sync_file_event_data_t` | Emitted for each file materialized |

func FileStage

func FileStage(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileStageArgsFFI,
) *LoreCall[types.LoreFileStageArgsFFI]

Stage files for the next commit.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_STAGE_BEGIN` | `lore_file_stage_begin_event_data_t` | Emitted when staging begins, includes path count | | `LORE_EVENT_FILE_STAGE_PROGRESS` | `lore_file_stage_progress_event_data_t` | Emitted periodically during staging with file counts | | `LORE_EVENT_FILE_STAGE_END` | `lore_file_stage_end_event_data_t` | Emitted when staging completes | | `LORE_EVENT_FILE_STAGE_REVISION` | `lore_file_stage_revision_event_data_t` | Emitted with the resulting staged revision | | `LORE_EVENT_FILE_STAGE_FILE` | `lore_file_stage_file_event_data_t` | Emitted for each file staged or staged for deletion | | `LORE_EVENT_FILTER_EXCLUDE` | `lore_filter_exclude_event_data_t` | Emitted for each path excluded by filters |

func FileStageMerge

func FileStageMerge(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileStageMergeArgsFFI,
) *LoreCall[types.LoreFileStageMergeArgsFFI]

Stage files for a merge commit, recording resolved merge content.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_STAGE_BEGIN` | `lore_file_stage_begin_event_data_t` | Emitted when merge-staging begins | | `LORE_EVENT_FILE_STAGE_PROGRESS` | `lore_file_stage_progress_event_data_t` | Emitted periodically during merge-staging | | `LORE_EVENT_FILE_STAGE_REVISION` | `lore_file_stage_revision_event_data_t` | Emitted with the resulting staged revision | | `LORE_EVENT_FILE_STAGE_FILE` | `lore_file_stage_file_event_data_t` | Emitted for each file staged |

func FileStageMove

func FileStageMove(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileStageMoveArgsFFI,
) *LoreCall[types.LoreFileStageMoveArgsFFI]

Stage a file move (rename) operation for commit.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_STAGE_BEGIN` | `lore_file_stage_begin_event_data_t` | Emitted when move staging begins | | `LORE_EVENT_FILE_STAGE_END` | `lore_file_stage_end_event_data_t` | Emitted when move staging completes | | `LORE_EVENT_FILE_STAGE_REVISION` | `lore_file_stage_revision_event_data_t` | Emitted with the resulting staged revision | | `LORE_EVENT_FILE_STAGE_FILE` | `lore_file_stage_file_event_data_t` | Emitted for each file staged (deletion of original and new path) |

func FileUnstage

func FileUnstage(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileUnstageArgsFFI,
) *LoreCall[types.LoreFileUnstageArgsFFI]

Remove files from the staging area without discarding local changes.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_UNSTAGE_BEGIN` | `lore_file_unstage_begin_event_data_t` | Emitted when unstage begins, includes path count | | `LORE_EVENT_FILE_UNSTAGE_PROGRESS` | `lore_file_unstage_progress_event_data_t` | Emitted periodically during unstaging | | `LORE_EVENT_FILE_UNSTAGE_END` | `lore_file_unstage_end_event_data_t` | Emitted when unstaging completes | | `LORE_EVENT_FILE_UNSTAGE_REVISION` | `lore_file_unstage_revision_event_data_t` | Emitted with the resulting staged revision | | `LORE_EVENT_FILE_UNSTAGE_FILE` | `lore_file_unstage_file_event_data_t` | Emitted for each file that was unstaged |

func FileWrite

func FileWrite(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreFileWriteArgsFFI,
) *LoreCall[types.LoreFileWriteArgsFFI]

Write binary content to a file in the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## File Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_FILE_WRITE` | `lore_file_write_event_data_t` | Emitted when the file has been successfully written to the repository |

func LayerAdd

func LayerAdd(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLayerAddArgsFFI,
) *LoreCall[types.LoreLayerAddArgsFFI]

Add a new layer to the repository configuration.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Layer Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LAYER_ADD` | `lore_layer_add_event_data_t` | Emitted when a layer has been successfully added |

func LayerList

func LayerList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLayerListArgsFFI,
) *LoreCall[types.LoreLayerListArgsFFI]

List all layers configured in the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Layer Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LAYER_ENTRY` | `lore_layer_entry_event_data_t` | Emitted for each layer configured in the repository |

func LayerRemove

func LayerRemove(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLayerRemoveArgsFFI,
) *LoreCall[types.LoreLayerRemoveArgsFFI]

Remove a layer from the repository configuration.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func LinkAdd

func LinkAdd(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLinkAddArgsFFI,
) *LoreCall[types.LoreLinkAddArgsFFI]

Add a link to another repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Link Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REPOSITORY_CLONE_BEGIN` | `lore_repository_clone_begin_event_data_t` | Emitted when cloning a linked repository begins | | `LORE_EVENT_REPOSITORY_CLONE_END` | `lore_repository_clone_end_event_data_t` | Emitted when cloning a linked repository completes | | `LORE_EVENT_LINK_CHANGE` | `lore_link_change_event_data_t` | Emitted when the link has been added and saved |

func LinkList

func LinkList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLinkListArgsFFI,
) *LoreCall[types.LoreLinkListArgsFFI]

List all repository links configured in the current repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Link Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LINK_ENTRY` | `lore_link_entry_event_data_t` | Emitted for each linked repository |

func LinkRemove

func LinkRemove(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLinkRemoveArgsFFI,
) *LoreCall[types.LoreLinkRemoveArgsFFI]

Remove a link to another repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Link Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LINK_CHANGE` | `lore_link_change_event_data_t` | Emitted when the link has been removed |

func LinkUpdate

func LinkUpdate(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLinkUpdateArgsFFI,
) *LoreCall[types.LoreLinkUpdateArgsFFI]

Update properties of an existing repository link.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Link Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LINK_CHANGE` | `lore_link_change_event_data_t` | Emitted when a link property is updated or finalized |

func LockFileAcquire

func LockFileAcquire(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLockFileAcquireArgsFFI,
) *LoreCall[types.LoreLockFileAcquireArgsFFI]

Acquire exclusive locks on one or more files in the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Lock Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOCK_FILE_ACQUIRE` | `lore_lock_file_acquire_event_data_t` | Emitted for each file for which a lock was successfully acquired | | `LORE_EVENT_LOCK_FILE_ACQUIRE_IGNORE` | `lore_lock_file_acquire_ignore_event_data_t` | Emitted for each file for which a lock was ignored (already owned) |

func LockFileQuery

func LockFileQuery(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLockFileQueryArgsFFI,
) *LoreCall[types.LoreLockFileQueryArgsFFI]

Query which files are currently locked, optionally filtered by user or path.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Lock Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOCK_FILE_QUERY_BEGIN` | `lore_lock_file_query_begin_event_data_t` | Emitted before query results begin streaming | | `LORE_EVENT_LOCK_FILE_QUERY` | `lore_lock_file_query_event_data_t` | Emitted for each file matching the query |

func LockFileRelease

func LockFileRelease(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLockFileReleaseArgsFFI,
) *LoreCall[types.LoreLockFileReleaseArgsFFI]

Release file locks previously acquired by this client.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Lock Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOCK_FILE_RELEASE` | `lore_lock_file_release_event_data_t` | Emitted for each file lock successfully released | | `LORE_EVENT_LOCK_FILE_RELEASE_NOT_FOUND` | `lore_lock_file_release_not_found_event_data_t` | Emitted for each file whose lock was not found |

func LockFileStatus

func LockFileStatus(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreLockFileStatusArgsFFI,
) *LoreCall[types.LoreLockFileStatusArgsFFI]

Get the lock status of files in the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Lock Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOCK_FILE_STATUS_BEGIN` | `lore_lock_file_status_begin_event_data_t` | Emitted before lock status results begin streaming | | `LORE_EVENT_LOCK_FILE_STATUS` | `lore_lock_file_status_event_data_t` | Emitted for each locked file with owner and lock details |

func NotificationSubscribe

func NotificationSubscribe(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreNotificationSubscribeArgsFFI,
) *LoreCall[types.LoreNotificationSubscribeArgsFFI]

Subscribe to repository notifications.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Notification Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_NOTIFICATION_SUBSCRIBED` | `lore_notification_subscribed_event_data_t` | Emitted when successfully subscribed to repository notifications | | `LORE_EVENT_NOTIFICATION_BRANCH_CREATED` | `lore_notification_branch_created_event_data_t` | Emitted when a branch is created in the repository (push notification) | | `LORE_EVENT_NOTIFICATION_BRANCH_DELETED` | `lore_notification_branch_deleted_event_data_t` | Emitted when a branch is deleted in the repository (push notification) | | `LORE_EVENT_NOTIFICATION_BRANCH_PUSHED` | `lore_notification_branch_pushed_event_data_t` | Emitted when a branch is pushed to (push notification) | | `LORE_EVENT_NOTIFICATION_RESOURCE_LOCKED` | `lore_notification_resource_locked_event_data_t` | Emitted when a resource is locked (push notification) | | `LORE_EVENT_NOTIFICATION_RESOURCE_UNLOCKED` | `lore_notification_resource_unlocked_event_data_t` | Emitted when a resource is unlocked (push notification) |

func NotificationUnsubscribe

func NotificationUnsubscribe(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreNotificationUnsubscribeArgsFFI,
) *LoreCall[types.LoreNotificationUnsubscribeArgsFFI]

Unsubscribe from repository notifications.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Notification Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_NOTIFICATION_UNSUBSCRIBED` | `lore_notification_unsubscribed_event_data_t` | Emitted when successfully unsubscribed from repository notifications |

func RepositoryClone

func RepositoryClone(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryCloneArgsFFI,
) *LoreCall[types.LoreRepositoryCloneArgsFFI]

Clone a remote repository to a local path.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Repository Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REPOSITORY_CLONE_BEGIN` | `lore_repository_clone_begin_event_data_t` | Emitted when clone begins, includes remote URL and target path | | `LORE_EVENT_REPOSITORY_CLONE_PROGRESS` | `lore_repository_clone_progress_event_data_t` | Emitted periodically during clone with progress data | | `LORE_EVENT_REPOSITORY_CLONE_END` | `lore_repository_clone_end_event_data_t` | Emitted when clone completes successfully | | `LORE_EVENT_REVISION_SYNC_TARGET` | `lore_revision_sync_target_event_data_t` | Emitted after resolving the target revision to sync during clone | | `LORE_EVENT_REVISION_SYNC_FILE` | `lore_revision_sync_file_event_data_t` | Emitted for each file written during initial sync | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted periodically during initial file sync | | `LORE_EVENT_REVISION_SYNC_REVISION` | `lore_revision_sync_revision_event_data_t` | Emitted with the resulting revision | | `LORE_EVENT_FILTER_EXCLUDE` | `lore_filter_exclude_event_data_t` | Emitted for each path excluded by view filters | | `LORE_EVENT_FRAGMENT_WRITE` | `lore_fragment_write_event_data_t` | Emitted for each fragment written to the local store |

func RepositoryConfigGet

func RepositoryConfigGet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryConfigGetArgsFFI,
) *LoreCall[types.LoreRepositoryConfigGetArgsFFI]

Read a configuration value of the current repository by key.

func RepositoryCreate

func RepositoryCreate(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryCreateArgsFFI,
) *LoreCall[types.LoreRepositoryCreateArgsFFI]

Create a new Lore repository on the remote server.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Repository Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REPOSITORY_CREATE` | `lore_repository_create_event_data_t` | Emitted when the repository has been successfully created |

func RepositoryDump

func RepositoryDump(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryDumpArgsFFI,
) *LoreCall[types.LoreRepositoryDumpArgsFFI]

Dump the internal state of the repository for diagnostic purposes.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Repository Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REPOSITORY_DUMP_BEGIN` | `lore_repository_dump_begin_event_data_t` | Emitted before dump output begins | | `LORE_EVENT_REPOSITORY_DUMP_END` | `lore_repository_dump_end_event_data_t` | Emitted when dump completes | | `LORE_EVENT_REPOSITORY_STATE_DUMP` | `lore_repository_state_dump_event_data_t` | Emitted with repository state summary | | `LORE_EVENT_REPOSITORY_STATE_DUMP_NODE` | `lore_repository_state_dump_node_event_data_t` | Emitted for each node in the state tree |

func RepositoryFlush

func RepositoryFlush(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryFlushArgsFFI,
) *LoreCall[types.LoreRepositoryFlushArgsFFI]

Flush pending repository state to persistent storage.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func RepositoryGc

func RepositoryGc(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryGcArgsFFI,
) *LoreCall[types.LoreRepositoryGcArgsFFI]

Run garbage collection to reclaim unreferenced storage in the repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func RepositoryInfo

func RepositoryInfo(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryInfoArgsFFI,
) *LoreCall[types.LoreRepositoryInfoArgsFFI]

Retrieve metadata about the current repository.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Repository Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REPOSITORY_DATA` | `lore_repository_data_event_data_t` | Emitted with repository metadata (name, URL, branch info, etc.) |

func RepositoryInstanceList

func RepositoryInstanceList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryInstanceListArgsFFI,
) *LoreCall[types.LoreRepositoryInstanceListArgsFFI]

List the tracked instances of the repository.

func RepositoryInstancePrune

func RepositoryInstancePrune(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryInstancePruneArgsFFI,
) *LoreCall[types.LoreRepositoryInstancePruneArgsFFI]

Remove stale instances of the repository that are no longer present.

func RepositoryList

func RepositoryList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryListArgsFFI,
) *LoreCall[types.LoreRepositoryListArgsFFI]

List all repositories available on the remote server.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Repository Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REPOSITORY_LIST_ENTRY` | `lore_repository_list_entry_event_data_t` | Emitted for each repository found |

func RepositoryMetadataClear

func RepositoryMetadataClear(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryMetadataClearArgsFFI,
) *LoreCall[types.LoreRepositoryMetadataClearArgsFFI]

Clear repository metadata keys. Clears all user-defined keys when none are

given.

func RepositoryMetadataGet

func RepositoryMetadataGet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryMetadataGetArgsFFI,
) *LoreCall[types.LoreRepositoryMetadataGetArgsFFI]

Retrieve repository metadata. Reads a single key, or all entries when no

key is given.

func RepositoryMetadataSet

func RepositoryMetadataSet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryMetadataSetArgsFFI,
) *LoreCall[types.LoreRepositoryMetadataSetArgsFFI]

Set repository metadata key-value pairs.

func RepositoryRelease

func RepositoryRelease(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryReleaseArgsFFI,
) *LoreCall[types.LoreRepositoryReleaseArgsFFI]

Release all cached store references for the given repository path.

Frees in-memory store data and releases file-backed store cache entries. Any active repository contexts for this path remain valid, but once they are dropped the stores will be freed. Subsequent opens will create fresh stores.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func RepositoryStatus

func RepositoryStatus(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryStatusArgsFFI,
) *LoreCall[types.LoreRepositoryStatusArgsFFI]

Show the working directory status, including staged, dirty, and conflicted files.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Repository Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REPOSITORY_STATUS_REVISION` | `lore_repository_status_revision_event_data_t` | Emitted with current and staged revision info | | `LORE_EVENT_REPOSITORY_STATUS_FILE` | `lore_repository_status_file_event_data_t` | Emitted for each file with pending changes, conflict status, or untracked status | | `LORE_EVENT_PATH_IGNORE` | `lore_path_ignore_event_data_t` | Emitted for each path excluded by ignore rules |

func RepositoryStoreImmutableQuery

func RepositoryStoreImmutableQuery(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryStoreImmutableQueryArgsFFI,
) *LoreCall[types.LoreRepositoryStoreImmutableQueryArgsFFI]

Query the repository's immutable fragment store.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Repository Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REPOSITORY_STORE_IMMUTABLE_QUERY` | `lore_repository_store_immutable_query_event_data_t` | Emitted for each fragment entry found in the immutable store |

func RepositoryUpdatePath

func RepositoryUpdatePath(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryUpdatePathArgsFFI,
) *LoreCall[types.LoreRepositoryUpdatePathArgsFFI]

Update the recorded path of the current repository instance to its present

location.

func RepositoryVerifyState

func RepositoryVerifyState(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRepositoryVerifyStateArgsFFI,
) *LoreCall[types.LoreRepositoryVerifyStateArgsFFI]

Verify the integrity of the repository's stored fragments.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Repository Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REPOSITORY_VERIFY_STATE_BEGIN` | `lore_repository_verify_state_begin_event_data_t` | Emitted when verify begins | | `LORE_EVENT_REPOSITORY_VERIFY_STATE_END` | `lore_repository_verify_state_end_event_data_t` | Emitted when verify completes (success or with errors) | | `LORE_EVENT_REPOSITORY_VERIFY_FRAGMENT` | `lore_repository_verify_fragment_event_data_t` | Emitted for each fragment verified in the local store | | `LORE_EVENT_REPOSITORY_VERIFY_FRAGMENT_REMOTE` | `lore_repository_verify_fragment_remote_event_data_t` | Emitted for each fragment verified against the remote store |

func RevisionAmend

func RevisionAmend(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionAmendArgsFFI,
) *LoreCall[types.LoreRevisionAmendArgsFFI]

Amend the most recent revision with updated metadata.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVISION_COMMIT_REVISION` | `lore_revision_commit_revision_event_data_t` | Emitted with the amended revision details | | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for each metadata entry of the amended revision |

func RevisionCommit

func RevisionCommit(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionCommitArgsFFI,
) *LoreCall[types.LoreRevisionCommitArgsFFI]

Commit staged files to create a new revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVISION_COMMIT_BEGIN` | `lore_revision_commit_begin_event_data_t` | Emitted when commit begins fragmenting files | | `LORE_EVENT_REVISION_COMMIT_PROGRESS` | `lore_revision_commit_progress_event_data_t` | Emitted periodically during commit with file processing counts | | `LORE_EVENT_REVISION_COMMIT_END` | `lore_revision_commit_end_event_data_t` | Emitted when commit file processing completes | | `LORE_EVENT_REVISION_COMMIT_REVISION` | `lore_revision_commit_revision_event_data_t` | Emitted with the committed revision details (hash, branch, parents) | | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for each metadata entry of the committed revision | | `LORE_EVENT_FRAGMENT_WRITE` | `lore_fragment_write_event_data_t` | Emitted for each fragment written or deduplicated |

func RevisionDiff

func RevisionDiff(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionDiffArgsFFI,
) *LoreCall[types.LoreRevisionDiffArgsFFI]

Show files that differ between two revisions.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVISION_DIFF_FILE` | `lore_revision_diff_file_event_data_t` | Emitted for each file that differs between the two revisions | | `LORE_EVENT_REVISION_RESOLVE` | `lore_revision_resolve_event_data_t` | Emitted when resolving a partial or numbered revision reference |

func RevisionFind

func RevisionFind(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionFindArgsFFI,
) *LoreCall[types.LoreRevisionFindArgsFFI]

Find a revision by metadata or revision number.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVISION_FIND` | `lore_revision_find_event_data_t` | Emitted when a matching revision is found (exact or partial match) |

func RevisionHistory

func RevisionHistory(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionHistoryArgsFFI,
) *LoreCall[types.LoreRevisionHistoryArgsFFI]

Retrieve the commit history of the current branch.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVISION_HISTORY` | `lore_revision_history_event_data_t` | Emitted once with summary info before entries stream | | `LORE_EVENT_REVISION_HISTORY_ENTRY` | `lore_revision_history_entry_event_data_t` | Emitted for each revision in the history |

func RevisionInfo

func RevisionInfo(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionInfoArgsFFI,
) *LoreCall[types.LoreRevisionInfoArgsFFI]

Retrieve metadata and delta information about a specific revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVISION_INFO` | `lore_revision_info_event_data_t` | Emitted with revision metadata (hash, branch, parents, file count, etc.) | | `LORE_EVENT_REVISION_INFO_DELTA` | `lore_revision_info_delta_event_data_t` | Emitted with delta information between revision and its parent (when delta=true) | | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for each metadata key/value of the revision (when metadata=true) |

func RevisionMetadataClear

func RevisionMetadataClear(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionMetadataClearArgsFFI,
) *LoreCall[types.LoreRevisionMetadataClearArgsFFI]

Clear all metadata from the current revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_METADATA_CLEAR_REVISION` | `lore_metadata_clear_revision_event_data_t` | Emitted when metadata has been cleared for the current revision |

func RevisionMetadataGet

func RevisionMetadataGet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionMetadataGetArgsFFI,
) *LoreCall[types.LoreRevisionMetadataGetArgsFFI]

Get a specific metadata key/value pair from the current revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted with the requested key/value for the revision |

func RevisionMetadataList

func RevisionMetadataList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionMetadataListArgsFFI,
) *LoreCall[types.LoreRevisionMetadataListArgsFFI]

List all metadata key/value pairs associated with the current revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for each metadata key/value associated with the revision |

func RevisionMetadataSet

func RevisionMetadataSet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionMetadataSetArgsFFI,
) *LoreCall[types.LoreRevisionMetadataSetArgsFFI]

Set a metadata key/value pair on the current revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func RevisionRestore

func RevisionRestore(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionRestoreArgsFFI,
) *LoreCall[types.LoreRevisionRestoreArgsFFI]

Restore the working directory to a previously committed revision.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revision Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVISION_RESTORE_FILE_BEGIN` | `lore_revision_restore_file_begin_event_data_t` | Emitted when restore starts processing files | | `LORE_EVENT_REVISION_RESTORE_FILE` | `lore_revision_restore_file_event_data_t` | Emitted for each file being restored | | `LORE_EVENT_REVISION_RESTORE_FILE_END` | `lore_revision_restore_file_end_event_data_t` | Emitted when file processing completes | | `LORE_EVENT_REVISION_RESTORE_FRAGMENT_BEGIN` | `lore_revision_restore_fragment_begin_event_data_t` | Emitted when fragment download begins for a file | | `LORE_EVENT_REVISION_RESTORE_FRAGMENT_PROGRESS` | `lore_revision_restore_fragment_progress_event_data_t` | Emitted periodically during fragment download | | `LORE_EVENT_REVISION_RESTORE_FRAGMENT_END` | `lore_revision_restore_fragment_end_event_data_t` | Emitted when fragment download completes | | `LORE_EVENT_REVISION_RESTORE_REVISION` | `lore_revision_restore_revision_event_data_t` | Emitted with the restored revision details | | `LORE_EVENT_REVISION_RESTORE_SYNC_BEGIN` | `lore_revision_restore_sync_begin_event_data_t` | Emitted when starting to apply the changes on the target state | | `LORE_EVENT_REVISION_RESTORE_SYNC_END` | `lore_revision_restore_sync_end_event_data_t` | Emitted after applying the changes on the target state is complete | | `LORE_EVENT_REVISION_COMMIT_BEGIN` | `lore_revision_commit_begin_event_data_t` | Emitted when auto-commit of restored revision starts | | `LORE_EVENT_REVISION_COMMIT_PROGRESS` | `lore_revision_commit_progress_event_data_t` | Emitted during auto-commit | | `LORE_EVENT_REVISION_COMMIT_END` | `lore_revision_commit_end_event_data_t` | Emitted when auto-commit completes | | `LORE_EVENT_REVISION_COMMIT_REVISION` | `lore_revision_commit_revision_event_data_t` | Emitted with the committed restored revision | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during changes realization | | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for metadata of the restored revision | | `LORE_EVENT_FRAGMENT_WRITE` | `lore_fragment_write_event_data_t` | Emitted for fragments written during restore commit |

func RevisionRevert

func RevisionRevert(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionRevertArgsFFI,
) *LoreCall[types.LoreRevisionRevertArgsFFI]

Revert a revision, applying its inverse changes to the working tree.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revert Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVERT_START_BEGIN` | `lore_revert_start_begin_event_data_t` | Emitted when revert begins, includes target revision info | | `LORE_EVENT_REVERT_START_END` | `lore_revert_start_end_event_data_t` | Emitted when revert completes, includes conflict flag | | `LORE_EVENT_REVERT_CONFLICT_FILE` | `lore_revert_conflict_file_event_data_t` | Emitted for each file with an unresolved revert conflict | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during apply_diff phase | | `LORE_EVENT_REVISION_SYNC_FILE` | `lore_revision_sync_file_event_data_t` | Emitted for each file modified during revert realization | | `LORE_EVENT_FILE_STAGE_FILE` | `lore_file_stage_file_event_data_t` | Emitted for each file staged for deletion during revert | | `LORE_EVENT_REVISION_COMMIT_BEGIN` | `lore_revision_commit_begin_event_data_t` | Emitted when auto-commit starts (no conflicts) | | `LORE_EVENT_REVISION_COMMIT_PROGRESS` | `lore_revision_commit_progress_event_data_t` | Emitted during auto-commit | | `LORE_EVENT_REVISION_COMMIT_END` | `lore_revision_commit_end_event_data_t` | Emitted when auto-commit completes | | `LORE_EVENT_REVISION_COMMIT_REVISION` | `lore_revision_commit_revision_event_data_t` | Emitted with the committed revert revision | | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for metadata of the auto-commit | | `LORE_EVENT_FRAGMENT_WRITE` | `lore_fragment_write_event_data_t` | Emitted for fragments written during auto-commit |

func RevisionRevertAbort

func RevisionRevertAbort(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionRevertAbortArgsFFI,
) *LoreCall[types.LoreRevisionRevertAbortArgsFFI]

Abort an in-progress revert operation and restore the previous state.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revert Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVERT_ABORT_BEGIN` | `lore_revert_abort_begin_event_data_t` | Emitted when revert abort begins | | `LORE_EVENT_REVERT_ABORT_END` | `lore_revert_abort_end_event_data_t` | Emitted when revert abort completes | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during file realization while reverting |

func RevisionRevertResolve

func RevisionRevertResolve(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionRevertResolveArgsFFI,
) *LoreCall[types.LoreRevisionRevertResolveArgsFFI]

Resolve a revert conflict by marking conflicting files as resolved.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revert Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVERT_RESOLVE_FILE` | `lore_revert_resolve_file_event_data_t` | Emitted for each file marked as resolved | | `LORE_EVENT_REVERT_RESOLVE_REVISION` | `lore_revert_resolve_revision_event_data_t` | Emitted with the updated staged revision |

func RevisionRevertResolveMine

func RevisionRevertResolveMine(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionRevertResolveMineArgsFFI,
) *LoreCall[types.LoreRevisionRevertResolveMineArgsFFI]

Resolve a revert conflict by accepting the "mine" version of each conflicting file.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revert Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVERT_RESOLVE_FILE` | `lore_revert_resolve_file_event_data_t` | Emitted for each file resolved by keeping "mine" | | `LORE_EVENT_REVERT_RESOLVE_REVISION` | `lore_revert_resolve_revision_event_data_t` | Emitted with the updated staged revision |

func RevisionRevertResolveTheirs

func RevisionRevertResolveTheirs(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionRevertResolveTheirsArgsFFI,
) *LoreCall[types.LoreRevisionRevertResolveTheirsArgsFFI]

Resolve a revert conflict by accepting the "theirs" version of each conflicting file.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revert Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVERT_RESOLVE_FILE` | `lore_revert_resolve_file_event_data_t` | Emitted for each file resolved by keeping "theirs" | | `LORE_EVENT_REVERT_RESOLVE_REVISION` | `lore_revert_resolve_revision_event_data_t` | Emitted with the updated staged revision |

func RevisionRevertRestart

func RevisionRevertRestart(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionRevertRestartArgsFFI,
) *LoreCall[types.LoreRevisionRevertRestartArgsFFI]

Restart a revert operation, re-materializing files with conflicts.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revert Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVERT_CONFLICT_FILE` | `lore_revert_conflict_file_event_data_t` | Emitted for each file with a remaining revert conflict | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted during file realization | | `LORE_EVENT_REVISION_SYNC_FILE` | `lore_revision_sync_file_event_data_t` | Emitted for each file re-materialized |

func RevisionRevertUnresolve

func RevisionRevertUnresolve(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionRevertUnresolveArgsFFI,
) *LoreCall[types.LoreRevisionRevertUnresolveArgsFFI]

Mark conflicting files in a revert operation as unresolved.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Revert Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVERT_UNRESOLVE_FILE` | `lore_revert_unresolve_file_event_data_t` | Emitted for each file marked as unresolved | | `LORE_EVENT_REVERT_UNRESOLVE_REVISION` | `lore_revert_unresolve_revision_event_data_t` | Emitted with the updated staged revision |

func RevisionSync

func RevisionSync(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionSyncArgsFFI,
) *LoreCall[types.LoreRevisionSyncArgsFFI]

Synchronize the working directory to a target revision, optionally merging divergent branches.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Sync Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_REVISION_SYNC_TARGET` | `lore_revision_sync_target_event_data_t` | Emitted once after resolving the target revision with source/target revision info, branch, and remote URL | | `LORE_EVENT_REVISION_SYNC_FILE` | `lore_revision_sync_file_event_data_t` | Emitted for each file deleted, modified, added, or merged during sync | | `LORE_EVENT_REVISION_SYNC_PROGRESS` | `lore_revision_sync_progress_event_data_t` | Emitted periodically during file realization and once at completion with cumulative update/delete/automerge/conflict counts | | `LORE_EVENT_REVISION_SYNC_REVISION` | `lore_revision_sync_revision_event_data_t` | Emitted once at the end with the resulting revision, branch, and merge/conflict flags | | `LORE_EVENT_REVISION_RESOLVE` | `lore_revision_resolve_event_data_t` | Emitted when resolving a partial or numbered revision reference | | `LORE_EVENT_FILTER_EXCLUDE` | `lore_filter_exclude_event_data_t` | Emitted for each path excluded by view or ignore filters | | `LORE_EVENT_BRANCH_MERGE_START_BEGIN` | `lore_branch_merge_start_begin_event_data_t` | Emitted when an auto-merge is initiated (diverged branches) | | `LORE_EVENT_BRANCH_MERGE_START_END` | `lore_branch_merge_start_end_event_data_t` | Emitted when the auto-merge operation completes | | `LORE_EVENT_BRANCH_MERGE_CONFLICT_FILE` | `lore_branch_merge_conflict_file_event_data_t` | Emitted for each file with an unresolved merge conflict | | `LORE_EVENT_REVISION_COMMIT_BEGIN` | `lore_revision_commit_begin_event_data_t` | Emitted when auto-merge auto-commits (no conflicts) | | `LORE_EVENT_REVISION_COMMIT_PROGRESS` | `lore_revision_commit_progress_event_data_t` | Emitted during auto-commit | | `LORE_EVENT_REVISION_COMMIT_END` | `lore_revision_commit_end_event_data_t` | Emitted when auto-commit completes | | `LORE_EVENT_REVISION_COMMIT_REVISION` | `lore_revision_commit_revision_event_data_t` | Emitted with the committed merge revision | | `LORE_EVENT_METADATA` | `lore_metadata_event_data_t` | Emitted for metadata of the auto-merge commit | | `LORE_EVENT_FRAGMENT_WRITE` | `lore_fragment_write_event_data_t` | Emitted for each fragment written during auto-merge commit | | `LORE_EVENT_FILE_STAGE_FILE` | `lore_file_stage_file_event_data_t` | Emitted for each file staged for deletion during merge realization |

func RevisionTreeClose

func RevisionTreeClose(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionTreeCloseArgsFFI,
) *LoreCall[types.LoreRevisionTreeCloseArgsFFI]

Release a memory-based revision tree handle.

Subsequent calls against the same handle return `InvalidArguments`. The call blocks until every in-flight op on the handle has paired its decrement.

| Terminal event | Payload | Notes | |---------------------------------------------|-----------------------------------------------|----------------------------------------------------| | `LORE_EVENT_REVISION_TREE_CLOSE_COMPLETE` | `lore_revision_tree_close_complete_event_data_t` | Emitted on success carrying the caller id |

func RevisionTreeInfo

func RevisionTreeInfo(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionTreeInfoArgsFFI,
) *LoreCall[types.LoreRevisionTreeInfoArgsFFI]

Fetch the loaded revision's record-level metadata (parents, creation

timestamp, author identity, metadata key count). Revision-scoped — no node id.

| Terminal event | Payload | Notes | |------------------------------------|----------------------------------------|---------------------------------------------------------| | `LORE_EVENT_REVISION_TREE_INFO` | `lore_revision_tree_info_event_data_t` | Carries the revision record metadata for the handle |

func RevisionTreeListChildren

func RevisionTreeListChildren(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionTreeListChildrenArgsFFI,
) *LoreCall[types.LoreRevisionTreeListChildrenArgsFFI]

Stream the children of a directory node in a loaded revision tree.

| Terminal event | Payload | Notes | |--------------------------------------|----------------------------------------|----------------------------------------------------------------| | `LORE_EVENT_REVISION_TREE_CHILD` | `lore_revision_tree_child_event_data_t` | One per child; an empty directory emits none before `Complete` |

func RevisionTreeLoad

func RevisionTreeLoad(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionTreeLoadArgsFFI,
) *LoreCall[types.LoreRevisionTreeLoadArgsFFI]

Open a memory-based revision tree handle on the given

`(store, repository, revision_hash)` tuple. `revision_hash == 0` opens an empty tree suitable for committing an initial revision.

| Terminal event | Payload | Notes | |--------------------------------------|----------------------------------------|----------------------------------------------------| | `LORE_EVENT_REVISION_TREE_LOADED` | `lore_revision_tree_loaded_event_data_t` | Emitted on success carrying the opened handle id |

func RevisionTreeNodeInfo

func RevisionTreeNodeInfo(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionTreeNodeInfoArgsFFI,
) *LoreCall[types.LoreRevisionTreeNodeInfoArgsFFI]

Fetch the per-node record for a single node id in a loaded revision tree.

| Terminal event | Payload | Notes | |-----------------------------------------|---------------------------------------------|----------------------------------------------------------------| | `LORE_EVENT_REVISION_TREE_NODE_INFO` | `lore_revision_tree_node_info_event_data_t` | Carries the node record, uniform across every node id (revision metadata: `lore_revision_tree_info`) |

func RevisionTreeNodePath

func RevisionTreeNodePath(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionTreeNodePathArgsFFI,
) *LoreCall[types.LoreRevisionTreeNodePathArgsFFI]

Reconstruct the full UTF-8 path for a node id by walking parent pointers,

relative to the handle's own tree root.

| Terminal event | Payload | Notes | |--------------------------------------|---------------------------------------------|--------------------------------------------------------| | `LORE_EVENT_REVISION_TREE_NODE_PATH` | `lore_revision_tree_node_path_event_data_t` | Carries the path; the root resolves to the empty path |

func RevisionTreeResolvePath

func RevisionTreeResolvePath(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreRevisionTreeResolvePathArgsFFI,
) *LoreCall[types.LoreRevisionTreeResolvePathArgsFFI]

Resolve a UTF-8 path against a loaded revision tree to a node id. An empty

path resolves to the root node.

| Terminal event | Payload | Notes | |------------------------------------------------------|-----------------------------------------------------|-------------------------------------------------------------| | `LORE_EVENT_REVISION_TREE_RESOLVE_PATH_COMPLETE` | `lore_revision_tree_resolve_path_complete_event_data_t` | Carries the resolved node id and the per-call outcome |

func ServiceStart

func ServiceStart(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreServiceStartArgsFFI,
) *LoreCall[types.LoreServiceStartArgsFFI]

Start the Lore background service.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func ServiceStop

func ServiceStop(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreServiceStopArgsFFI,
) *LoreCall[types.LoreServiceStopArgsFFI]

Stop the Lore background service.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func SharedStoreCreate

func SharedStoreCreate(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreSharedStoreCreateArgsFFI,
) *LoreCall[types.LoreSharedStoreCreateArgsFFI]

Create a new shared store at the specified path.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Shared Store Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_SHARED_STORE_CREATE` | `lore_shared_store_create_event_data_t` | Emitted on success after the shared store is created, carrying the path of the newly created store |

func SharedStoreInfo

func SharedStoreInfo(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreSharedStoreInfoArgsFFI,
) *LoreCall[types.LoreSharedStoreInfoArgsFFI]

Retrieve the path of the configured default shared store.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

## Shared Store Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_SHARED_STORE_INFO` | `lore_shared_store_info_event_data_t` | Emitted on success carrying the path of the configured default shared store |

func SharedStoreSetUseAutomatically

func SharedStoreSetUseAutomatically(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreSharedStoreSetUseAutomaticallyArgsFFI,
) *LoreCall[types.LoreSharedStoreSetUseAutomaticallyArgsFFI]

Set whether to automatically use the shared store.

Events

Events are delivered via the callback as `lore_event_t`. Use the `tag` field to identify the event type.

## Standard Events

These events are emitted by all interface functions:

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_LOG` | `lore_log_event_data_t` | Diagnostic messages throughout execution | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | Always emitted at the end; `status` is `0` on success or the error code on failure | | `LORE_EVENT_END` | `lore_end_event_data_t` | Always emitted after `COMPLETE` to signal callback termination |

func StorageClose

func StorageClose(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageCloseArgsFFI,
) *LoreCall[types.LoreStorageCloseArgsFFI]

Release a content-addressed storage handle.

Subsequent calls against the same handle return `InvalidArguments`. Close does not block on the flush it spawns — `Complete` fires after the in-flight counter drains, not after the flush finishes.

func StorageCopy

func StorageCopy(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageCopyArgsFFI,
) *LoreCall[types.LoreStorageCopyArgsFFI]

Copy content from one partition to another within the same store.

Same-partition source/target rejects with `INVALID_ARGUMENTS`. The item's content hash is preserved; only the source address is carried in the per-item event.

func StorageFlush

func StorageFlush(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageFlushArgsFFI,
) *LoreCall[types.LoreStorageFlushArgsFFI]

Flush pending writes through the handle's stores.

On disk-backed stores this performs an fsync honoring `globals.sync_data`. On in-memory stores the underlying flush is a no-op and the call still completes with `status: 0`.

func StorageGet

func StorageGet(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageGetArgsFFI,
) *LoreCall[types.LoreStorageGetArgsFFI]

Read one or more content-addressed buffers.

Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_STORAGE_GET_HEADER` | `lore_storage_get_header_event_data_t` | Size of the item's reassembled content, emitted before any DATA events | | `LORE_EVENT_STORAGE_GET_DATA` | `lore_storage_get_data_event_data_t` | Payload bytes — valid only during the callback invocation | | `LORE_EVENT_STORAGE_GET_ITEM_COMPLETE` | `lore_storage_get_item_complete_event_data_t` | Terminal per-item event | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | `status` is `0` iff every item succeeded, else the error code |

func StorageGetFile

func StorageGetFile(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageGetFileArgsFFI,
) *LoreCall[types.LoreStorageGetFileArgsFFI]

Write content-addressed payloads to filesystem paths.

Each item emits `LORE_EVENT_STORAGE_GET_ITEM_COMPLETE`. No HEADER or DATA events are produced — the payload is written straight to disk. On partial-write failure the library leaves whatever state the failure produced; cleanup is the caller's responsibility.

func StorageGetMetadata

func StorageGetMetadata(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageGetMetadataArgsFFI,
) *LoreCall[types.LoreStorageGetMetadataArgsFFI]

Fetch fragment metadata for one or more `(partition, address)` pairs without paying the

payload bytes. Each item's terminal event carries the resolved `Fragment` (`flags`, `size_payload`, `size_content`); on miss `error_code == ADDRESS_NOT_FOUND`.

Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_STORAGE_GET_METADATA_ITEM_COMPLETE` | `lore_storage_get_metadata_item_complete_event_data_t` | Per-item terminal event | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | `status` is `0` iff every item succeeded, else the error code |

func StorageMutableCompareAndSwap

func StorageMutableCompareAndSwap(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageMutableCompareAndSwapArgsFFI,
) *LoreCall[types.LoreStorageMutableCompareAndSwapArgsFFI]

Conditionally swap one or more mutable key values. Each item updates the key to `value` when

its current value matches `expected`, and reports the value the key held before the swap.

Each item acts on the local mutable store by default, or the remote mutable store when `globals.remote` is set (or the handle was opened remote-bound), over the shared storage session.

Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_STORAGE_MUTABLE_COMPARE_AND_SWAP_ITEM_COMPLETE` | `lore_storage_mutable_compare_and_swap_item_complete_event_data_t` | Per-item terminal event carrying `previous`; the swap took effect when `previous == expected` | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | `status: 0` iff every item succeeded |

func StorageMutableList

func StorageMutableList(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageMutableListArgsFFI,
) *LoreCall[types.LoreStorageMutableListArgsFFI]

List the mutable key-value pairs of a given type for one or more partitions.

Acts on the local mutable store only; a remote-targeted call (`globals.remote`, or a remote-bound handle) is rejected with `INVALID_ARGUMENTS`. A zero/default partition lists every partition the caller can access.

Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_STORAGE_MUTABLE_LIST_ENTRY` | `lore_storage_mutable_list_entry_event_data_t` | One `(key, value)` pair, emitted before the item's terminal event | | `LORE_EVENT_STORAGE_MUTABLE_LIST_ITEM_COMPLETE` | `lore_storage_mutable_list_item_complete_event_data_t` | Per-item terminal event | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | `status: 0` iff every item succeeded |

func StorageMutableLoad

func StorageMutableLoad(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageMutableLoadArgsFFI,
) *LoreCall[types.LoreStorageMutableLoadArgsFFI]

Read one or more mutable key values.

Each item acts on the local mutable store by default, or the remote mutable store when `globals.remote` is set (or the handle was opened remote-bound), over the shared storage session.

Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_STORAGE_MUTABLE_LOAD_ITEM_COMPLETE` | `lore_storage_mutable_load_item_complete_event_data_t` | Per-item terminal event carrying the value; `error_code == ADDRESS_NOT_FOUND` on a miss | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | `status: 0` iff every item succeeded |

func StorageMutableStore

func StorageMutableStore(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageMutableStoreArgsFFI,
) *LoreCall[types.LoreStorageMutableStoreArgsFFI]

Write one or more mutable key-value pairs. Storing the null value removes the key.

Each item acts on the local mutable store by default, or the remote mutable store when `globals.remote` is set (or the handle was opened remote-bound), over the shared storage session.

Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_STORAGE_MUTABLE_STORE_ITEM_COMPLETE` | `lore_storage_mutable_store_item_complete_event_data_t` | Per-item terminal event | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | `status: 0` iff every item succeeded |

func StorageObliterate

func StorageObliterate(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageObliterateArgsFFI,
) *LoreCall[types.LoreStorageObliterateArgsFFI]

Delete one or more `(partition, address)` entries from the store.

Idempotent on absent items; emits one `OBLITERATE_ITEM_COMPLETE` event per item carrying `local_success` / `remote_success` / `error_code`.

func StorageOpen

func StorageOpen(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageOpenArgsFFI,
) *LoreCall[types.LoreStorageOpenArgsFFI]

Open a content-addressed storage handle.

Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_STORAGE_OPENED` | `lore_storage_opened_event_data_t` | Emitted on success carrying the opened handle id | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | `status` is `0` on success or the error code on failure |

func StoragePut

func StoragePut(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStoragePutArgsFFI,
) *LoreCall[types.LoreStoragePutArgsFFI]

Store one or more content-addressed buffers.

Events

| Tag | Data Type | Description | |-----|-----------|-------------| | `LORE_EVENT_STORAGE_PUT_ITEM_COMPLETE` | `lore_storage_put_item_complete_event_data_t` | Emitted once per input item — success or failure | | `LORE_EVENT_ERROR` | `lore_error_event_data_t` | Emitted for a non-fatal error during the operation | | `LORE_EVENT_COMPLETE` | `lore_complete_event_data_t` | `status` is `0` iff every item succeeded, else the error code |

func StoragePutFile

func StoragePutFile(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStoragePutFileArgsFFI,
) *LoreCall[types.LoreStoragePutFileArgsFFI]

Read one or more files into the content-addressed store.

Each item emits `LORE_EVENT_STORAGE_PUT_ITEM_COMPLETE` carrying the computed address. Empty files short-circuit to the zero-hash address without opening for read.

func StorageUpload

func StorageUpload(
	globals *types.LoreGlobalArgsFFI,
	args *types.LoreStorageUploadArgsFFI,
) *LoreCall[types.LoreStorageUploadArgsFFI]

Push locally-stored, not-yet-durable content to the remote store.

Whole-call pre-dispatch fails when the handle has no remote, when `globals.offline=1`, or when `globals.local=1`. Per-item: `partition == 0` → `INVALID_ARGUMENTS`; zero hash and already-durable both succeed with `already_durable=1` and no remote call; missing local payload → `ADDRESS_NOT_FOUND`. Otherwise the bytes are uploaded and the local entry is updated with `PayloadStoredDurable` set.

func (*LoreCall[TArgs]) AsyncIter

func (c *LoreCall[TArgs]) AsyncIter() (<-chan types.LoreEvent, <-chan error)

AsyncIter executes the Lore operation and returns channels for async iteration. Returns an event channel and an error channel. Events are cloned to Go memory and remain valid after the call completes. If FilterByType was called, only matching events are sent to the channel. The event channel is closed when the operation completes. The error channel receives the final error (or nil) and is then closed. Cannot be used together with Callback() - returns ErrCallbackSet if a callback is set.

Example usage:

events, errCh := lore.RevisionHistory(globals, args).
    FilterByType(types.LoreEventTag_REVISION_HISTORY_ENTRY).
    AsyncIter()
for event := range events {
    // process event
}
if err := <-errCh; err != nil {
    // handle error
}

func (*LoreCall[TArgs]) Callback

func (c *LoreCall[TArgs]) Callback(fn types.LoreEventCallback) *LoreCall[TArgs]

Callback sets the event handler for this operation. Returns the same handle for method chaining.

func (*LoreCall[TArgs]) Collect

func (c *LoreCall[TArgs]) Collect() ([]types.LoreEvent, error)

Collect executes the Lore operation and collects all events into a slice. Returns the collected events and an error if the operation failed. Events are cloned to Go memory and remain valid after the call completes. If FilterByType was called, only matching events are collected. Cannot be used together with Callback() - returns ErrCallbackSet if a callback is set.

func (*LoreCall[TArgs]) FilterByType

func (c *LoreCall[TArgs]) FilterByType(tags ...types.LoreEventTag) *LoreCall[TArgs]

FilterByType sets which event types should be passed to the callback. Only events with tags in the provided list will trigger the callback. If no filter is set, all events are passed to the callback. Returns the same handle for method chaining.

func (*LoreCall[TArgs]) UserContext

func (c *LoreCall[TArgs]) UserContext(ctx uint64) *LoreCall[TArgs]

UserContext sets a user-provided context value that will be passed to the callback. Returns the same handle for method chaining.

func (*LoreCall[TArgs]) Wait

func (c *LoreCall[TArgs]) Wait() (int32, error)

Wait executes the Lore operation and blocks until completion. Returns the return code and an error if the return code was non-zero.

type LoreCallExecutor

type LoreCallExecutor[TArgs any] func(
	globals *types.LoreGlobalArgsFFI,
	args *TArgs,
	config *types.LoreEventCallbackConfig,
) (int32, error)

LoreCallExecutor is the function type that executes a Lore operation.

type LoreError

type LoreError struct {
	ReturnCode int32
	Messages   []string
}

LoreError represents an error from a Lore operation with a non-zero return code.

func (*LoreError) Error

func (e *LoreError) Error() string