Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

29.1 KB
Raw Blame
/* Canonical stored-content digest. This module establishes no provenance. */
#include "store/store_graph_digest.h"

#include "foundation/sha256.h"

#include <limits.h>
#include <sqlite3.h>
#include <string.h>

enum {
    GD_NULL = 0,
    GD_INTEGER = 1,
    GD_TEXT = 2,
    GD_BLOB = 3,
    GD_ALLOW_NULL = 1 << GD_NULL,
    GD_ALLOW_INTEGER = 1 << GD_INTEGER,
    GD_ALLOW_TEXT = 1 << GD_TEXT,
    GD_ALLOW_BLOB = 1 << GD_BLOB,
    GD_TABLE_COUNT = 10,
    GD_MAX_COLUMNS = 10,
    GD_COVERAGE_META = 7,
    GD_STORE_META = 8,
    GD_UNRESOLVED_CANDIDATES = 9,
    GD_SCHEMA_DECLARED_TYPE = 2,
    GD_SCHEMA_PRIMARY_KEY = 5,
    GD_SCHEMA_HIDDEN = 6,
    GD_CHUNK_BYTES = 65536
};

typedef struct {
    const char *name;
    unsigned char types;
    unsigned char kind;
    int primary_key;
} gd_column_t;

typedef struct {
    const char *name;
    const gd_column_t *columns;
    int column_count;
    const char *column_query;
    const char *row_query;
} gd_table_t;

#define GD_COLUMNS(a) ((int)(sizeof(a) / sizeof((a)[0])))
#define GD_I GD_ALLOW_INTEGER
#define GD_T GD_ALLOW_TEXT
#define GD_N GD_ALLOW_NULL
#define GD_B GD_ALLOW_BLOB

static const gd_column_t gd_projects[] = {
    {"name", GD_T, 0, 1}, {"indexed_at", GD_T, 0, 0}, {"root_path", GD_T, 0, 0}};
static const gd_column_t gd_file_hashes[] = {{"project", GD_T, 0, 1},
                                             {"rel_path", GD_T, 0, 2},
                                             {"sha256", GD_T, 0, 0},
                                             {"mtime_ns", GD_I, 0, 0},
                                             {"size", GD_I, 0, 0}};
static const gd_column_t gd_nodes[] = {{"id", GD_I, 0, 1},
                                       {"project", GD_T, 0, 0},
                                       {"label", GD_T, 0, 0},
                                       {"name", GD_T, 0, 0},
                                       {"qualified_name", GD_T, 0, 0},
                                       {"file_path", GD_T | GD_N, 0, 0},
                                       {"start_line", GD_I | GD_N, 0, 0},
                                       {"end_line", GD_I | GD_N, 0, 0},
                                       {"properties", GD_T | GD_N, 0, 0}};
static const gd_column_t gd_edges[] = {{"id", GD_I, 0, 1},
                                       {"project", GD_T, 0, 0},
                                       {"source_id", GD_I, 0, 0},
                                       {"target_id", GD_I, 0, 0},
                                       {"type", GD_T, 0, 0},
                                       {"properties", GD_T | GD_N, 0, 0},
                                       {"url_path_gen", GD_T | GD_N, 2, 0},
                                       {"local_name_gen", GD_T | GD_N, 2, 0}};
static const gd_column_t gd_project_summaries[] = {{"project", GD_T, 0, 1},
                                                   {"summary", GD_T, 0, 0},
                                                   {"source_hash", GD_T, 0, 0},
                                                   {"created_at", GD_T, 0, 0},
                                                   {"updated_at", GD_T, 0, 0}};
static const gd_column_t gd_lsp_surface[] = {
    {"project", GD_T, 0, 1},   {"rel_path", GD_T, 0, 2},         {"surface_sha", GD_T, 0, 0},
    {"defs_json", GD_T, 0, 0}, {"ref_bloom", GD_B | GD_N, 0, 0}, {"config_ctx", GD_T, 0, 0}};
static const gd_column_t gd_index_coverage[] = {{"project", GD_T, 0, 1},
                                                {"rel_path", GD_T, 0, 2},
                                                {"kind", GD_T, 0, 3},
                                                {"detail", GD_T | GD_N, 0, 0}};
static const gd_column_t gd_index_coverage_meta[] = {{"project", GD_T, 0, 1},
                                                     {"generation", GD_T, 0, 0},
                                                     {"index_mode", GD_T, 0, 0},
                                                     {"recorded_at", GD_T, 0, 0},
                                                     {"recording_status", GD_T, 0, 0},
                                                     {"ignored_files_stored", GD_I, 0, 0},
                                                     {"ignored_files_total", GD_I, 0, 0},
                                                     {"coverage_version", GD_I, 0, 0},
                                                     {"hash_records_complete", GD_I, 0, 0},
                                                     {"unresolved_calls_complete", GD_I, 0, 0}};
static const gd_column_t gd_store_meta[] = {{"k", GD_T, 0, 1}, {"v", GD_T, 0, 0}};

static const gd_column_t gd_unresolved_candidates[] = {{"project", GD_T, 0, 1},
                                                       {"candidate", GD_T, 0, 2},
                                                       {"rel_path", GD_T, 0, 3},
                                                       {"kind", GD_T, 0, 0}};

/* These descriptors and SQL strings are immutable; all other state is local. */
static const gd_table_t gd_tables[GD_TABLE_COUNT] = {
    {"projects", gd_projects, GD_COLUMNS(gd_projects), "PRAGMA main.table_xinfo('projects');",
     "SELECT name,indexed_at,root_path FROM main.projects ORDER BY CAST(name AS BLOB) ASC;"},
    {"file_hashes", gd_file_hashes, GD_COLUMNS(gd_file_hashes),
     "PRAGMA main.table_xinfo('file_hashes');",
     "SELECT project,rel_path,sha256,mtime_ns,size FROM main.file_hashes "
     "ORDER BY CAST(project AS BLOB) ASC,CAST(rel_path AS BLOB) ASC;"},
    {"nodes", gd_nodes, GD_COLUMNS(gd_nodes), "PRAGMA main.table_xinfo('nodes');",
     "SELECT id,project,label,name,qualified_name,file_path,start_line,end_line,properties "
     "FROM main.nodes ORDER BY id ASC;"},
    {"edges", gd_edges, GD_COLUMNS(gd_edges), "PRAGMA main.table_xinfo('edges');",
     "SELECT id,project,source_id,target_id,type,properties,url_path_gen,local_name_gen "
     "FROM main.edges ORDER BY id ASC;"},
    {"project_summaries", gd_project_summaries, GD_COLUMNS(gd_project_summaries),
     "PRAGMA main.table_xinfo('project_summaries');",
     "SELECT project,summary,source_hash,created_at,updated_at FROM main.project_summaries "
     "ORDER BY CAST(project AS BLOB) ASC;"},
    {"lsp_surface", gd_lsp_surface, GD_COLUMNS(gd_lsp_surface),
     "PRAGMA main.table_xinfo('lsp_surface');",
     "SELECT project,rel_path,surface_sha,defs_json,ref_bloom,config_ctx FROM main.lsp_surface "
     "ORDER BY CAST(project AS BLOB) ASC,CAST(rel_path AS BLOB) ASC;"},
    {"index_coverage", gd_index_coverage, GD_COLUMNS(gd_index_coverage),
     "PRAGMA main.table_xinfo('index_coverage');",
     "SELECT project,rel_path,kind,detail FROM main.index_coverage "
     "ORDER BY CAST(project AS BLOB) ASC,CAST(rel_path AS BLOB) ASC,CAST(kind AS BLOB) ASC;"},
    {"index_coverage_meta", gd_index_coverage_meta, GD_COLUMNS(gd_index_coverage_meta) - 1,
     "PRAGMA main.table_xinfo('index_coverage_meta');",
     "SELECT project,generation,index_mode,recorded_at,recording_status,ignored_files_stored,"
     "ignored_files_total,coverage_version,hash_records_complete FROM main.index_coverage_meta "
     "ORDER BY CAST(project AS BLOB) ASC;"},
    {"store_meta", gd_store_meta, GD_COLUMNS(gd_store_meta),
     "PRAGMA main.table_xinfo('store_meta');",
     "SELECT k,v FROM main.store_meta ORDER BY CAST(k AS BLOB) ASC;"},
    {"index_unresolved_candidates", gd_unresolved_candidates, GD_COLUMNS(gd_unresolved_candidates),
     "PRAGMA main.table_xinfo('index_unresolved_candidates');",
     "SELECT project,candidate,rel_path,kind FROM main.index_unresolved_candidates "
     "ORDER BY CAST(project AS BLOB) ASC,CAST(candidate AS BLOB) ASC,"
     "CAST(rel_path AS BLOB) ASC,CAST(kind AS BLOB) ASC;"}};

/* Preserve the legacy canonical stream; newer metadata binds the independent
 * capture completeness column as well. Both schemas are checked exactly. */
static const gd_table_t gd_coverage_meta_current = {
    "index_coverage_meta", gd_index_coverage_meta, GD_COLUMNS(gd_index_coverage_meta),
    "PRAGMA main.table_xinfo('index_coverage_meta');",
    "SELECT project,generation,index_mode,recorded_at,recording_status,ignored_files_stored,"
    "ignored_files_total,coverage_version,hash_records_complete,unresolved_calls_complete "
    "FROM main.index_coverage_meta ORDER BY CAST(project AS BLOB) ASC;"};

#undef GD_B
#undef GD_N
#undef GD_T
#undef GD_I
#undef GD_COLUMNS

typedef struct {
    cbm_store_read_scope_t *scope;
    sqlite3 *db;
    sqlite3_stmt *stmt;
    cbm_sha256_ctx sha;
    cbm_store_graph_digest_limits_t limits;
    cbm_store_graph_digest_status_t status;
    uint64_t rows;
    uint64_t bytes;
    bool have_uid;
    bool have_counter;
    bool have_unresolved_completeness;
} gd_context_t;

static const gd_table_t *gd_table(const gd_context_t *g, int index) {
    return index == GD_COVERAGE_META && g->have_unresolved_completeness ? &gd_coverage_meta_current
                                                                        : &gd_tables[index];
}

typedef struct {
    const unsigned char *data;
    size_t length;
} gd_text_t;

static bool gd_fail(gd_context_t *g, cbm_store_graph_digest_status_t status) {
    if (g->status == CBM_STORE_GRAPH_DIGEST_OK) {
        g->status = status;
        if (g->scope) {
            (void)cbm_store_read_scope_fail(g->scope, status == CBM_STORE_GRAPH_DIGEST_CANCELLED
                                                          ? CBM_STORE_CANCELLED
                                                          : CBM_STORE_ERR);
        }
    }
    return false;
}

static bool gd_check(gd_context_t *g) {
    if (g->scope) {
        int status = cbm_store_read_scope_check(g->scope);
        if (status != CBM_STORE_OK) {
            return gd_fail(g, status == CBM_STORE_CANCELLED ? CBM_STORE_GRAPH_DIGEST_CANCELLED
                                                            : CBM_STORE_GRAPH_DIGEST_ERROR);
        }
    }
    return g->status == CBM_STORE_GRAPH_DIGEST_OK;
}

static void gd_sql_failure(gd_context_t *g, int rc) {
    if (rc == SQLITE_INTERRUPT) {
        (void)gd_check(g); /* Only a D5-latched cancellation earns CANCELLED. */
    }
    (void)gd_fail(g, CBM_STORE_GRAPH_DIGEST_ERROR);
}

static bool gd_prepare(gd_context_t *g, const char *sql) {
    if (!gd_check(g)) {
        return false;
    }
    if (g->stmt) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_ERROR);
    }
    int rc = sqlite3_prepare_v2(g->db, sql, -1, &g->stmt, NULL);
    if (rc != SQLITE_OK) {
        gd_sql_failure(g, rc);
    }
    return gd_check(g);
}

static int gd_step(gd_context_t *g) {
    if (!gd_check(g)) {
        return SQLITE_ERROR;
    }
    int rc = sqlite3_step(g->stmt);
    if (rc != SQLITE_ROW && rc != SQLITE_DONE) {
        gd_sql_failure(g, rc);
    }
    return gd_check(g) ? rc : SQLITE_ERROR;
}

/* Destruction is unconditional, including after the scope has been poisoned. */
static bool gd_finalize(gd_context_t *g) {
    if (g->stmt) {
        (void)gd_check(g);
        sqlite3_stmt *stmt = g->stmt;
        g->stmt = NULL;
        int rc = sqlite3_finalize(stmt);
        if (rc != SQLITE_OK) {
            gd_sql_failure(g, rc);
        }
        (void)gd_check(g);
    }
    return g->status == CBM_STORE_GRAPH_DIGEST_OK;
}

static bool gd_bind_name(gd_context_t *g, const char *name) {
    int rc = sqlite3_bind_text(g->stmt, 1, name, -1, SQLITE_STATIC);
    if (rc != SQLITE_OK) {
        gd_sql_failure(g, rc);
    }
    return g->status == CBM_STORE_GRAPH_DIGEST_OK;
}

/* No conversion is allowed to erase the distinction between TEXT and BLOB. */
static bool gd_read_text(gd_context_t *g, int column, gd_text_t *out) {
    if (sqlite3_column_type(g->stmt, column) != SQLITE_TEXT) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    const unsigned char *data = sqlite3_column_text(g->stmt, column);
    int length = sqlite3_column_bytes(g->stmt, column);
    if (!data || length < 0 || sqlite3_errcode(g->db) == SQLITE_NOMEM) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_ERROR);
    }
    out->data = data;
    out->length = (size_t)length;
    return true;
}

static bool gd_text_eq(gd_text_t text, const char *literal) {
    size_t length = strlen(literal); /* Only internal constant strings. */
    return text.length == length && memcmp(text.data, literal, length) == 0;
}

static bool gd_text_ascii_eq(gd_text_t text, const char *literal) {
    size_t length = strlen(literal);
    if (text.length != length) {
        return false;
    }
    for (size_t i = 0; i < length; i++) {
        unsigned char c = text.data[i];
        unsigned char d = (unsigned char)literal[i];
        if (c >= 'A' && c <= 'Z') {
            c = (unsigned char)(c + ('a' - 'A'));
        }
        if (d >= 'A' && d <= 'Z') {
            d = (unsigned char)(d + ('a' - 'A'));
        }
        if (c != d) {
            return false;
        }
    }
    return true;
}

static int gd_table_index(gd_text_t name) {
    for (int i = 0; i < GD_TABLE_COUNT; i++) {
        if (gd_text_ascii_eq(name, gd_tables[i].name)) {
            return i;
        }
    }
    return -1;
}

static bool gd_bytes(gd_context_t *g, const void *data, size_t length) {
    if (!gd_check(g)) {
        return false;
    }
    uint64_t count = (uint64_t)length;
    if ((size_t)count != length || count > g->limits.max_framed_bytes - g->bytes) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_LIMIT);
    }
    if (length && !data) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_ERROR);
    }
    const unsigned char *p = data;
    while (length) {
        size_t chunk = length > GD_CHUNK_BYTES ? GD_CHUNK_BYTES : length;
        if (!gd_check(g)) {
            return false;
        }
        cbm_sha256_update(&g->sha, p, chunk);
        g->bytes += (uint64_t)chunk;
        if (!gd_check(g)) {
            return false;
        }
        p += chunk;
        length -= chunk;
    }
    return true;
}

static bool gd_u8(gd_context_t *g, unsigned char value) {
    return gd_bytes(g, &value, 1);
}

static void gd_pack_u64(uint64_t value, unsigned char bytes[8]) {
    for (unsigned int i = 0; i < 8; i++) {
        bytes[7 - i] = (unsigned char)(value >> (8 * i));
    }
}

static bool gd_u32(gd_context_t *g, uint32_t value) {
    unsigned char bytes[4];
    for (unsigned int i = 0; i < 4; i++) {
        bytes[3 - i] = (unsigned char)(value >> (8 * i));
    }
    return gd_bytes(g, bytes, sizeof(bytes));
}

static bool gd_u64(gd_context_t *g, uint64_t value) {
    unsigned char bytes[8];
    gd_pack_u64(value, bytes);
    return gd_bytes(g, bytes, sizeof(bytes));
}

static bool gd_value(gd_context_t *g, unsigned char tag, const void *data, size_t length) {
    uint64_t count = (uint64_t)length;
    if ((size_t)count != length) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_LIMIT);
    }
    return gd_u8(g, tag) && gd_u64(g, count) && gd_bytes(g, data, length);
}

static bool gd_literal(gd_context_t *g, const char *literal) {
    return gd_value(g, GD_TEXT, literal, strlen(literal));
}

static bool gd_encoding(gd_context_t *g) {
    if (!gd_prepare(g, "PRAGMA main.encoding;")) {
        return false;
    }
    if (sqlite3_column_count(g->stmt) != 1 || gd_step(g) != SQLITE_ROW) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    gd_text_t encoding;
    if (!gd_read_text(g, 0, &encoding)) {
        return false;
    }
    if (!gd_text_eq(encoding, "UTF-8") || gd_step(g) != SQLITE_DONE) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    return gd_finalize(g);
}

static bool gd_table_kinds(gd_context_t *g, bool present[GD_TABLE_COUNT]) {
    if (!gd_prepare(g, "PRAGMA main.table_list;")) {
        return false;
    }
    /* Unsupported PRAGMAs may return DONE without an error or columns. */
    if (sqlite3_column_count(g->stmt) < 3) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    int rc;
    while ((rc = gd_step(g)) == SQLITE_ROW) {
        gd_text_t schema, name, type;
        if (!gd_read_text(g, 0, &schema) || !gd_read_text(g, 1, &name) ||
            !gd_read_text(g, 2, &type)) {
            return false;
        }
        if (!gd_text_eq(schema, "main")) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
        int index = gd_table_index(name);
        if (index >= 0) {
            if (present[index] || !gd_text_eq(name, gd_tables[index].name) ||
                !gd_text_eq(type, "table")) {
                return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
            }
            present[index] = true;
        }
    }
    if (rc != SQLITE_DONE || !gd_finalize(g)) {
        return false;
    }
    for (int i = 0; i < GD_STORE_META; i++) {
        if (!present[i]) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
    }
    if (!gd_prepare(g, "SELECT name FROM temp.sqlite_schema WHERE type IN ('table','view');")) {
        return false;
    }
    while ((rc = gd_step(g)) == SQLITE_ROW) {
        gd_text_t name;
        if (!gd_read_text(g, 0, &name)) {
            return false;
        }
        if (gd_table_index(name) >= 0) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
    }
    return rc == SQLITE_DONE && gd_finalize(g);
}

static bool gd_column_schema(gd_context_t *g, const gd_column_t *expected) {
    if (sqlite3_column_type(g->stmt, GD_SCHEMA_PRIMARY_KEY) != SQLITE_INTEGER ||
        sqlite3_column_type(g->stmt, GD_SCHEMA_HIDDEN) != SQLITE_INTEGER ||
        sqlite3_column_int64(g->stmt, GD_SCHEMA_PRIMARY_KEY) != expected->primary_key ||
        sqlite3_column_int64(g->stmt, GD_SCHEMA_HIDDEN) != expected->kind) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    if (expected->primary_key && expected->types == GD_ALLOW_INTEGER) {
        gd_text_t declared_type;
        if (!gd_read_text(g, GD_SCHEMA_DECLARED_TYPE, &declared_type)) {
            return false;
        }
        if (!gd_text_ascii_eq(declared_type, "INTEGER")) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
    }
    return true;
}

static bool gd_columns(gd_context_t *g, const gd_table_t *table) {
    bool seen[GD_MAX_COLUMNS] = {false};
    bool coverage_meta = table == &gd_tables[GD_COVERAGE_META];
    int allowed_columns =
        coverage_meta ? gd_coverage_meta_current.column_count : table->column_count;
    if (!gd_prepare(g, table->column_query)) {
        return false;
    }
    if (sqlite3_column_count(g->stmt) != 7) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    int rc;
    int count = 0;
    while ((rc = gd_step(g)) == SQLITE_ROW) {
        gd_text_t name;
        if (!gd_read_text(g, 1, &name)) {
            return false;
        }
        int column = -1;
        for (int i = 0; i < allowed_columns; i++) {
            if (gd_text_eq(name, table->columns[i].name)) {
                column = i;
                break;
            }
        }
        if (column < 0 || seen[column] || count == allowed_columns ||
            !gd_column_schema(g, &table->columns[column])) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
        seen[column] = true;
        count++;
    }
    if (rc != SQLITE_DONE || count < table->column_count) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    for (int i = 0; i < table->column_count; i++) {
        if (!seen[i]) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
    }
    if (coverage_meta) {
        g->have_unresolved_completeness = seen[table->column_count];
    }
    return gd_finalize(g);
}

static bool gd_project(gd_context_t *g, const unsigned char *project, size_t length) {
    if (!gd_prepare(g, "SELECT 1 FROM main.projects WHERE CAST(name AS BLOB)=?1 LIMIT 2;")) {
        return false;
    }
    int rc = sqlite3_bind_blob(g->stmt, 1, project, (int)length, SQLITE_STATIC);
    if (rc != SQLITE_OK) {
        gd_sql_failure(g, rc);
        return false;
    }
    rc = gd_step(g);
    if (rc == SQLITE_DONE) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_PROJECT_MISSING);
    }
    if (rc != SQLITE_ROW) {
        return false;
    }
    rc = gd_step(g);
    if (rc == SQLITE_ROW) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    return rc == SQLITE_DONE && gd_finalize(g);
}

static bool gd_validate_schema(gd_context_t *g, bool present[GD_TABLE_COUNT],
                               const unsigned char *project, size_t length) {
    if (!gd_encoding(g) || !gd_table_kinds(g, present)) {
        return false;
    }
    for (int i = 0; i < GD_TABLE_COUNT; i++) {
        if (present[i] && !gd_columns(g, &gd_tables[i])) {
            return false;
        }
    }
    return gd_project(g, project, length);
}

static bool gd_table_header(gd_context_t *g, int index, bool present) {
    const gd_table_t *table = gd_table(g, index);
    if (!gd_u8(g, 0x20) || !gd_u32(g, (uint32_t)index) || !gd_literal(g, table->name) ||
        !gd_u32(g, (uint32_t)table->column_count)) {
        return false;
    }
    for (int i = 0; i < table->column_count; i++) {
        const gd_column_t *column = &table->columns[i];
        if (!gd_literal(g, column->name) || !gd_u8(g, column->types) || !gd_u8(g, column->kind)) {
            return false;
        }
    }
    if (!gd_u8(g, present ? 1 : 0)) {
        return false;
    }
    if (!present) {
        return gd_value(g, GD_NULL, NULL, 0);
    }
    if (!gd_prepare(g, "SELECT name,type,sql FROM main.sqlite_schema "
                       "WHERE name=?1 COLLATE NOCASE AND type IN ('table','view');") ||
        !gd_bind_name(g, table->name)) {
        return false;
    }
    if (gd_step(g) != SQLITE_ROW) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    gd_text_t name, type, sql;
    if (!gd_read_text(g, 0, &name) || !gd_read_text(g, 1, &type) || !gd_read_text(g, 2, &sql)) {
        return false;
    }
    if (!gd_text_eq(name, table->name) || !gd_text_eq(type, "table")) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    if (!gd_value(g, GD_TEXT, sql.data, sql.length)) {
        return false;
    }
    if (gd_step(g) != SQLITE_DONE) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    return gd_finalize(g);
}

static bool gd_generation(gd_context_t *g) {
    gd_text_t key, value;
    if (!gd_read_text(g, 0, &key) || !gd_read_text(g, 1, &value)) {
        return false;
    }
    if (gd_text_eq(key, "db_uid")) {
        if (g->have_uid || value.length != 16) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
        for (size_t i = 0; i < value.length; i++) {
            unsigned char c = value.data[i];
            if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'))) {
                return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
            }
        }
        g->have_uid = true;
    } else if (gd_text_eq(key, "mutation_gen")) {
        if (g->have_counter || value.length == 0 || value.length > 20 ||
            (value.length > 1 && value.data[0] == '0')) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
        uint64_t number = 0;
        for (size_t i = 0; i < value.length; i++) {
            unsigned char c = value.data[i];
            if (c < '0' || c > '9') {
                return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
            }
            uint64_t digit = (uint64_t)(c - '0');
            if (number > (UINT64_MAX - digit) / 10) {
                return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
            }
            number = number * 10 + digit;
        }
        g->have_counter = true;
    }
    return true;
}

static bool gd_column_value(gd_context_t *g, int index, const gd_column_t *column) {
    int sql_type = sqlite3_column_type(g->stmt, index);
    unsigned char tag;
    switch (sql_type) {
    case SQLITE_NULL:
        tag = GD_NULL;
        break;
    case SQLITE_INTEGER:
        tag = GD_INTEGER;
        break;
    case SQLITE_TEXT:
        tag = GD_TEXT;
        break;
    case SQLITE_BLOB:
        tag = GD_BLOB;
        break;
    default:
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    if (!(column->types & (1u << tag))) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
    }
    if (tag == GD_NULL) {
        return gd_value(g, tag, NULL, 0);
    }
    if (tag == GD_INTEGER) {
        unsigned char bytes[8];
        gd_pack_u64((uint64_t)sqlite3_column_int64(g->stmt, index), bytes);
        return gd_value(g, tag, bytes, sizeof(bytes));
    }
    if (tag == GD_TEXT) {
        gd_text_t value;
        return gd_read_text(g, index, &value) && gd_value(g, tag, value.data, value.length);
    }
    const void *blob = sqlite3_column_blob(g->stmt, index);
    int length = sqlite3_column_bytes(g->stmt, index);
    if (length < 0 || (length && !blob) || sqlite3_errcode(g->db) == SQLITE_NOMEM) {
        return gd_fail(g, CBM_STORE_GRAPH_DIGEST_ERROR);
    }
    return gd_value(g, tag, blob, (size_t)length);
}

static bool gd_table_rows(gd_context_t *g, int index, bool present) {
    uint64_t rows = 0;
    const gd_table_t *table = gd_table(g, index);
    if (present) {
        if (!gd_prepare(g, table->row_query)) {
            return false;
        }
        if (sqlite3_column_count(g->stmt) != table->column_count) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
        int rc;
        while ((rc = gd_step(g)) == SQLITE_ROW) {
            if (!gd_check(g)) {
                return false;
            }
            if (g->rows == g->limits.max_rows || g->rows == UINT64_MAX || rows == UINT64_MAX) {
                return gd_fail(g, CBM_STORE_GRAPH_DIGEST_LIMIT);
            }
            if (index == GD_STORE_META && !gd_generation(g)) {
                return false;
            }
            if (!gd_u8(g, 0x21) || !gd_u32(g, (uint32_t)table->column_count)) {
                return false;
            }
            for (int i = 0; i < table->column_count; i++) {
                if (!gd_column_value(g, i, &table->columns[i])) {
                    return false;
                }
            }
            rows++;
            g->rows++;
        }
        if (rc != SQLITE_DONE || !gd_finalize(g)) {
            return false;
        }
        if (index == GD_STORE_META && (!g->have_uid || !g->have_counter)) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_SCHEMA);
        }
    }
    return gd_u8(g, 0x22) && gd_u64(g, rows);
}

static bool gd_stream_tables(gd_context_t *g, const bool present[GD_TABLE_COUNT]) {
    for (int i = 0; i < GD_TABLE_COUNT; i++) {
        /* A store without the candidate table streams the same tables as
         * version 1; only the version word differs. */
        if (i == GD_UNRESOLVED_CANDIDATES && !present[i]) {
            continue;
        }
        if (!gd_table_header(g, i, present[i]) || !gd_table_rows(g, i, present[i])) {
            return false;
        }
    }
    return true;
}

static bool gd_project_argument(gd_context_t *g, const unsigned char *project, size_t length) {
    while (length) {
        size_t chunk = length > GD_CHUNK_BYTES ? GD_CHUNK_BYTES : length;
        if (!gd_check(g)) {
            return false;
        }
        if (memchr(project, 0, chunk)) {
            return gd_fail(g, CBM_STORE_GRAPH_DIGEST_INVALID);
        }
        if (!gd_check(g)) {
            return false;
        }
        project += chunk;
        length -= chunk;
    }
    return true;
}

cbm_store_graph_digest_status_t cbm_store_graph_digest(
    cbm_store_read_scope_t *scope, const unsigned char *project, size_t project_len,
    const cbm_store_graph_digest_limits_t *limits, cbm_store_graph_digest_t *out) {
    if (out) {
        memset(out, 0, sizeof(*out));
    }
    gd_context_t g = {0};
    cbm_store_graph_digest_t result;
    memset(&result, 0, sizeof(result));
    bool complete = false;
    g.scope = scope;
    if (scope && !gd_check(&g)) {
        return g.status;
    }
    if (!scope || !project || !project_len || project_len > INT_MAX || !limits || !out ||
        !limits->max_rows || !limits->max_framed_bytes ||
        limits->max_framed_bytes > UINT64_MAX / 8) {
        (void)gd_fail(&g, CBM_STORE_GRAPH_DIGEST_INVALID);
        return g.status;
    }
    if (!gd_project_argument(&g, project, project_len)) {
        return g.status;
    }
    g.limits = *limits;
    cbm_store_t *store = cbm_store_read_scope_store(scope);
    g.db = store ? cbm_store_get_db(store) : NULL;
    if (!g.db) {
        (void)gd_fail(&g, CBM_STORE_GRAPH_DIGEST_ERROR);
        return g.status;
    }
    bool present[GD_TABLE_COUNT] = {false};
    if (!gd_validate_schema(&g, present, project, project_len)) {
        goto done;
    }
    cbm_sha256_init(&g.sha);
    static const unsigned char domain[] = "cbm-store-graph-digest";
    if (!gd_bytes(&g, domain, sizeof(domain)) || !gd_u32(&g, CBM_STORE_GRAPH_DIGEST_VERSION) ||
        !gd_u8(&g, 0x10) || !gd_value(&g, GD_TEXT, project, project_len)) {
        goto done;
    }
    if (!gd_stream_tables(&g, present)) {
        goto done;
    }
    if (!gd_u8(&g, 0x7f) || !gd_u64(&g, g.rows) || !gd_check(&g)) {
        goto done;
    }
    result.version = CBM_STORE_GRAPH_DIGEST_VERSION;
    result.rows = g.rows;
    result.framed_bytes = g.bytes;
    cbm_sha256_final(&g.sha, result.sha256);
    complete = gd_check(&g);

done:
    (void)gd_finalize(&g);
    if (!complete && g.status == CBM_STORE_GRAPH_DIGEST_OK) {
        (void)gd_fail(&g, CBM_STORE_GRAPH_DIGEST_ERROR);
    }
    if (complete && gd_check(&g)) {
        memcpy(out, &result, sizeof(*out));
    } else {
        memset(out, 0, sizeof(*out));
    }
    return g.status;
}