@fadhilp/stateql 0.8.1 → 0.10.0

package/dist/src/redis.js

@@ -0,0 +1,395 @@
+import { createClient, RESP_TYPES, WatchError } from "@redis/client";
+import { AdapterExecutionError, AdapterWriteError } from "./adapters.js";
+import { hash, toJsonSafe } from "./util.js";
+const MAX_ARGUMENTS = 100;
+const MAX_ARGUMENT_BYTES = 256 * 1024;
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+const MAX_COLLECTION_VALUES = 200;
+const READ_COMMANDS = new Set([
+    "GET", "MGET", "TYPE", "EXISTS", "TTL", "PTTL", "HGET", "HMGET",
+    "LRANGE", "SCAN", "HSCAN", "SSCAN", "ZSCAN",
+]);
+const WRITE_COMMANDS = new Set([
+    "SET", "DEL", "HSET", "HDEL", "LPUSH", "RPUSH", "SADD", "SREM", "ZADD", "ZREM",
+]);
+export function validateRedisReadCommand(value) {
+    const command = validateCommandShape(value);
+    if (!READ_COMMANDS.has(command.command)) {
+        throw new Error(`Unsupported Redis read command "${command.command}".`);
+    }
+    const args = command.args ?? [];
+    switch (command.command) {
+        case "GET":
+        case "TYPE":
+        case "TTL":
+        case "PTTL":
+            requireCount(args, 1);
+            break;
+        case "MGET":
+        case "EXISTS":
+            requireRange(args, 1, MAX_ARGUMENTS);
+            break;
+        case "HGET":
+            requireCount(args, 2);
+            break;
+        case "HMGET":
+            requireRange(args, 2, MAX_ARGUMENTS + 1);
+            break;
+        case "LRANGE":
+            requireCount(args, 3);
+            boundedRange(args[1], args[2]);
+            break;
+        case "SCAN":
+            validateScanArgs(args, false);
+            break;
+        case "HSCAN":
+        case "SSCAN":
+        case "ZSCAN":
+            validateScanArgs(args, true);
+            break;
+    }
+    return command;
+}
+export function validateRedisWriteCommand(value) {
+    const command = validateCommandShape(value);
+    if (!WRITE_COMMANDS.has(command.command)) {
+        throw new Error(`Unsupported Redis write command "${command.command}".`);
+    }
+    const args = command.args ?? [];
+    switch (command.command) {
+        case "SET":
+            requireCount(args, 2);
+            break;
+        case "DEL":
+            requireCount(args, 1);
+            break;
+        case "HSET":
+            requireCount(args, 3);
+            break;
+        case "HDEL":
+            requireCount(args, 2);
+            break;
+        case "LPUSH":
+        case "RPUSH":
+        case "SADD":
+        case "SREM":
+        case "ZREM":
+            requireCount(args, 2);
+            break;
+        case "ZADD":
+            requireCount(args, 3);
+            if (!Number.isFinite(Number(args[1])))
+                throw new Error("Redis ZADD score must be finite.");
+            break;
+    }
+    return command;
+}
+export function serializeRedisCommand(command) {
+    return JSON.stringify({ command: command.command.toUpperCase(), args: command.args ?? [] });
+}
+export function deserializeRedisCommand(value) {
+    try {
+        return validateRedisWriteCommand(JSON.parse(value));
+    }
+    catch {
+        throw new Error("Stored Redis command is invalid.");
+    }
+}
+export class RedisAdapter {
+    readOnly;
+    context;
+    confidence = "ttl_based";
+    client;
+    connected = false;
+    closed = false;
+    constructor(source, readOnly, context) {
+        this.readOnly = readOnly;
+        this.context = context;
+        this.client = createClient({
+            url: source,
+            socket: {
+                connectTimeout: remainingMilliseconds(context),
+                reconnectStrategy: false,
+            },
+        });
+        this.client.on("error", () => undefined);
+    }
+    async ping() {
+        await this.connect();
+        await this.execute(["PING"], false);
+    }
+    async signature() {
+        throwIfStopped(this.context, false);
+        return "redis:watched-key";
+    }
+    async read(input) {
+        const command = validateRedisReadCommand(input);
+        await this.connect();
+        const raw = await this.execute([command.command, ...(command.args ?? [])], false);
+        const bytes = Buffer.byteLength(JSON.stringify(toJsonSafe(raw)), "utf8");
+        if (bytes > MAX_RESPONSE_BYTES)
+            throw new Error("Redis response exceeds the 1 MiB materialization limit.");
+        return redisRows(command, raw);
+    }
+    async precondition(input) {
+        const command = validateRedisWriteCommand(input);
+        await this.connect();
+        const key = command.args[0];
+        const [fingerprint, expiresAt] = await Promise.all([this.keyFingerprint(key), this.expirationIdentity(key)]);
+        return { key, fingerprint, expiresAt };
+    }
+    async write(input, precondition) {
+        const command = validateRedisWriteCommand(input);
+        if (this.readOnly)
+            throw new AdapterWriteError("Connection is read-only.", false);
+        await this.connect();
+        const key = command.args[0];
+        if (precondition && precondition.key !== key) {
+            throw new AdapterWriteError("Redis plan key does not match its command.", false);
+        }
+        let dispatched = false;
+        try {
+            let raw;
+            if (precondition) {
+                await this.execute(["WATCH", key], false);
+                const [fingerprint, expiresAt] = await Promise.all([this.keyFingerprint(key), this.expirationIdentity(key)]);
+                const expiryChanged = precondition.expiresAt < 0
+                    ? expiresAt !== precondition.expiresAt
+                    : expiresAt < 0 || Math.abs(expiresAt - precondition.expiresAt) > 2_000;
+                if (fingerprint !== precondition.fingerprint || expiryChanged) {
+                    await this.execute(["UNWATCH"], false).catch(() => undefined);
+                    throw new AdapterWriteError("ROW_CONFLICT: The Redis key changed. Reload before editing.", false);
+                }
+                const transaction = this.client.multi();
+                transaction.addCommand([command.command, ...(command.args ?? [])]);
+                dispatched = true;
+                const result = await withDeadline(transaction.exec(), this.context, true, () => this.stop());
+                if (result === null)
+                    throw new AdapterWriteError("ROW_CONFLICT: The Redis key changed. Reload before editing.", false);
+                raw = result[0];
+            }
+            else {
+                dispatched = true;
+                raw = await this.execute([command.command, ...(command.args ?? [])], true);
+            }
+            if (raw instanceof Error)
+                throw new AdapterWriteError(raw.message, false);
+            const normalized = normalizeScalar(raw);
+            return {
+                affectedRows: redisAffectedRows(command.command, normalized),
+                outcome: { acknowledged: true, result: normalized },
+            };
+        }
+        catch (error) {
+            if (error instanceof AdapterWriteError)
+                throw error;
+            if (error instanceof WatchError)
+                throw new AdapterWriteError("ROW_CONFLICT: The Redis key changed. Reload before editing.", false);
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            throw new AdapterWriteError(errorText(error), dispatched);
+        }
+    }
+    async listObjects(filter) {
+        if (filter.kind !== undefined && filter.kind !== "key")
+            throw new Error(`Redis does not support catalog kind "${filter.kind}".`);
+        if (filter.schema !== undefined)
+            throw new Error("Redis keys do not have schemas.");
+        const cursor = filter.offset === undefined ? "0" : String(filter.offset);
+        if (!/^\d+$/.test(cursor))
+            throw new Error("Redis offset must be an opaque numeric SCAN cursor.");
+        const limit = boundedLimit(filter.limit);
+        const args = [cursor];
+        if (filter.search)
+            args.push("MATCH", `*${escapeGlob(filter.search)}*`);
+        args.push("COUNT", String(limit));
+        const result = await this.read({ command: "SCAN", args });
+        if (result.rows.length > MAX_COLLECTION_VALUES)
+            throw new Error("Redis SCAN page exceeded the hard response bound; retry with a smaller COUNT.");
+        return {
+            objects: result.rows.map((row) => ({ kind: "key", name: String(row.key), identity: String(row.key) })),
+            next_offset: result.nextCursor ?? null,
+            supported_kinds: ["key"],
+        };
+    }
+    async describeObject(object) {
+        if (object.kind !== "key" || !object.name || object.schema !== undefined)
+            throw new Error("Redis describeObject requires a key identity.");
+        await this.connect();
+        const key = object.name;
+        const type = String(await this.execute(["TYPE", key], false));
+        const ttl = Number(await this.execute(["PTTL", key], false));
+        let definition = { type, ttl_ms: ttl };
+        switch (type) {
+            case "none": break;
+            case "string": {
+                const length = Number(await this.execute(["STRLEN", key], false));
+                if (length > MAX_RESPONSE_BYTES)
+                    definition = { ...definition, length, value_omitted: true };
+                else
+                    definition = { ...definition, length, value: await this.execute(["GET", key], false) };
+                break;
+            }
+            case "hash":
+                definition = { ...definition, ...(await this.scanValue("HSCAN", key)) };
+                break;
+            case "list": {
+                const length = Number(await this.execute(["LLEN", key], false));
+                definition = { ...definition, length, values: await this.execute(["LRANGE", key, "0", "99"], false), truncated: length > 100 };
+                break;
+            }
+            case "set":
+                definition = { ...definition, ...(await this.scanValue("SSCAN", key)) };
+                break;
+            case "zset":
+                definition = { ...definition, ...(await this.scanValue("ZSCAN", key)) };
+                break;
+            default: definition = { ...definition, value_omitted: true, reason: "Unsupported Redis value type." };
+        }
+        if (Buffer.byteLength(JSON.stringify(toJsonSafe(definition)), "utf8") > MAX_RESPONSE_BYTES)
+            throw new Error("Redis value page exceeds 1 MiB.");
+        return { object: { kind: "key", name: key, identity: key }, definition: toJsonSafe(definition) };
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.client.isOpen)
+            this.client.destroy();
+        this.connected = false;
+    }
+    async scanValue(command, key) {
+        const raw = await this.execute([command, key, "0", "COUNT", "100"], false);
+        const cursor = String(raw[0]);
+        return { values: toJsonSafe(raw[1]), next_cursor: cursor === "0" ? null : cursor, truncated: cursor !== "0" };
+    }
+    async expirationIdentity(key) {
+        const ttl = Number(await this.execute(["PTTL", key], false));
+        return ttl >= 0 ? Date.now() + ttl : ttl;
+    }
+    async keyFingerprint(key) {
+        const usage = await this.execute(["MEMORY", "USAGE", key], false);
+        if (typeof usage === "number" && usage > MAX_RESPONSE_BYTES) {
+            throw new AdapterWriteError("Redis key is too large for guarded writes.", false);
+        }
+        const [type, dump] = await Promise.all([
+            this.execute(["TYPE", key], false),
+            withDeadline(this.client.sendCommand(["DUMP", key], { typeMapping: { [RESP_TYPES.BLOB_STRING]: Buffer } }), this.context, false, () => this.stop()),
+        ]);
+        const encoded = Buffer.isBuffer(dump) ? dump.toString("base64") : dump;
+        if (Buffer.byteLength(JSON.stringify(encoded), "utf8") > MAX_RESPONSE_BYTES * 2) {
+            throw new AdapterWriteError("Redis key is too large for guarded writes.", false);
+        }
+        return hash({ type, dump: encoded });
+    }
+    async connect() {
+        throwIfStopped(this.context, false);
+        if (this.closed)
+            throw new Error("Redis adapter is closed.");
+        if (this.connected)
+            return;
+        await withDeadline(this.client.connect(), this.context, false, () => this.stop());
+        this.connected = true;
+    }
+    async execute(command, outcomeUnknown) {
+        throwIfStopped(this.context, outcomeUnknown);
+        return withDeadline(this.client.sendCommand(command), this.context, outcomeUnknown, () => this.stop());
+    }
+    stop() { if (this.client.isOpen)
+        this.client.destroy(); this.closed = true; }
+}
+function validateCommandShape(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Redis command must be an object.");
+    const record = value;
+    if (Object.keys(record).some((key) => key !== "command" && key !== "args"))
+        throw new Error("Redis command contains unknown fields.");
+    if (typeof record.command !== "string" || !/^[A-Za-z]+$/.test(record.command))
+        throw new Error("Redis command name is invalid.");
+    const args = record.args ?? [];
+    if (!Array.isArray(args) || !args.every((arg) => typeof arg === "string") || args.some((arg) => arg.includes("\0")))
+        throw new Error("Redis command arguments must be strings without NUL bytes.");
+    if (args.length > MAX_ARGUMENTS + 4 || Buffer.byteLength(JSON.stringify(args), "utf8") > MAX_ARGUMENT_BYTES)
+        throw new Error("Redis command arguments exceed safety bounds.");
+    return { command: record.command.toUpperCase(), args: args };
+}
+function validateScanArgs(args, keyed) {
+    const base = keyed ? 2 : 1;
+    requireRange(args, base, base + 4);
+    if (!/^\d+$/.test(args[keyed ? 1 : 0]))
+        throw new Error("Redis SCAN cursor must be numeric.");
+    for (let index = base; index < args.length; index += 2) {
+        const option = args[index]?.toUpperCase();
+        const value = args[index + 1];
+        if (!value || (option !== "MATCH" && option !== "COUNT"))
+            throw new Error("Redis SCAN only supports MATCH and COUNT.");
+        if (option === "COUNT" && (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > MAX_COLLECTION_VALUES))
+            throw new Error(`Redis SCAN COUNT must be 1-${MAX_COLLECTION_VALUES}.`);
+    }
+}
+function requireCount(args, count) { if (args.length !== count)
+    throw new Error(`Redis command requires ${count} argument(s).`); }
+function requireRange(args, minimum, maximum) { if (args.length < minimum || args.length > maximum)
+    throw new Error(`Redis command requires ${minimum}-${maximum} arguments.`); }
+function boundedRange(startText, stopText) {
+    const start = Number(startText);
+    const stop = Number(stopText);
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(stop) || start < 0 || stop < start || stop - start >= MAX_COLLECTION_VALUES)
+        throw new Error(`Redis LRANGE must request at most ${MAX_COLLECTION_VALUES} non-negative elements.`);
+}
+function boundedLimit(value) { const limit = value ?? 50; if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_COLLECTION_VALUES)
+    throw new Error(`limit must be 1-${MAX_COLLECTION_VALUES}.`); return limit; }
+function escapeGlob(value) { if (!value || value.length > 200 || value.includes("\0"))
+    throw new Error("Redis search must be 1-200 characters."); return value.replace(/[\\*?\[\]]/g, "\\$&"); }
+function redisRows(command, raw) {
+    if (["SCAN", "HSCAN", "SSCAN", "ZSCAN"].includes(command.command)) {
+        if (!Array.isArray(raw) || raw.length !== 2 || !Array.isArray(raw[1]))
+            throw new Error("Unexpected Redis SCAN response.");
+        const values = raw[1];
+        const field = command.command === "SCAN" ? "key" : command.command === "HSCAN" ? "field" : "value";
+        const rows = command.command === "HSCAN" || command.command === "ZSCAN"
+            ? Array.from({ length: Math.ceil(values.length / 2) }, (_, index) => ({ [field]: values[index * 2], value: values[index * 2 + 1] }))
+            : values.map((value) => ({ [field]: value }));
+        const cursor = String(raw[0]);
+        return { rows: toJsonSafe(rows), columns: inferColumns(rows), nextCursor: cursor === "0" ? null : cursor };
+    }
+    if (Array.isArray(raw)) {
+        const rows = raw.map((value, index) => ({ index, value }));
+        return { rows: toJsonSafe(rows), columns: inferColumns(rows) };
+    }
+    const rows = [{ value: raw }];
+    return { rows: toJsonSafe(rows), columns: inferColumns(rows) };
+}
+function inferColumns(rows) { const first = rows[0] ?? {}; return Object.keys(first).map((name) => ({ name, type: typeof first[name] })); }
+function normalizeScalar(value) { if (value === null || typeof value === "string" || typeof value === "number")
+    return value; return JSON.stringify(toJsonSafe(value)); }
+function redisAffectedRows(command, result) { if (typeof result === "number")
+    return result; return command === "SET" && result === "OK" ? 1 : 0; }
+function remainingMilliseconds(context) { const remaining = context.deadline - Date.now(); if (remaining <= 0)
+    throw new AdapterExecutionError("Database operation timed out.", "timeout", false); return Math.min(remaining, 2_147_483_647); }
+function throwIfStopped(context, outcomeUnknown) { if (context.signal?.aborted)
+    throw new AdapterExecutionError("Database operation was cancelled.", "aborted", outcomeUnknown); if (context.deadline <= Date.now())
+    throw new AdapterExecutionError("Database operation timed out.", "timeout", outcomeUnknown); }
+async function withDeadline(promise, context, outcomeUnknown, stop) {
+    throwIfStopped(context, outcomeUnknown);
+    let timer;
+    let abort;
+    const stopped = new Promise((_, reject) => {
+        timer = setTimeout(() => { stop(); reject(new AdapterExecutionError("Database operation timed out.", "timeout", outcomeUnknown)); }, remainingMilliseconds(context));
+        timer.unref();
+        if (context.signal) {
+            abort = () => { stop(); reject(new AdapterExecutionError("Database operation was cancelled.", "aborted", outcomeUnknown)); };
+            context.signal.addEventListener("abort", abort, { once: true });
+        }
+    });
+    try {
+        return await Promise.race([promise, stopped]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (abort && context.signal)
+            context.signal.removeEventListener("abort", abort);
+    }
+}
+function errorText(error) { return error instanceof Error ? error.message : String(error); }

package/dist/src/sqlite-process.js

@@ -57,7 +57,7 @@ function execute(request) {
         case "write": {
             if (readOnly)
                 throw new Error("Connection is read-only.");
-            const [sql, params] = request.args;
+            const [sql, params, expectedRows] = request.args;
             try {
                 database.exec("BEGIN");
             }
@@ -66,6 +66,8 @@ function execute(request) {
             }
             try {
                 const result = bindRun(database.prepare(sql), params);
+                if (expectedRows === 1 && Number(result.changes) !== 1)
+                    throw new Error("ROW_CONFLICT: The row changed or no longer has a unique identity.");
                 database.exec("COMMIT");
                 return { affectedRows: Number(result.changes) };
             }
@@ -98,6 +100,8 @@ function execute(request) {
             try {
                 for (const operation of operations) {
                     const result = bindRun(database.prepare(operation.sql), parseJson(operation.parameters, `operation "${operation.id}" parameters`, isSqlParameters));
+                    if (operation.expectedRows === 1 && Number(result.changes) !== 1)
+                        throw new Error("ROW_CONFLICT: The row changed or no longer has a unique identity.");
                     results.push({ affectedRows: Number(result.changes) });
                 }
             }
@@ -145,6 +149,14 @@ function execute(request) {
             const [kind, table] = request.args;
             return inspect(database, kind, table);
         }
+        case "listObjects": {
+            const [filter] = request.args;
+            return listObjects(database, filter);
+        }
+        case "describeObject": {
+            const [object] = request.args;
+            return describeObject(database, object);
+        }
     }
 }
 function inspect(database, kind, table) {
@@ -160,6 +172,11 @@ function inspect(database, kind, table) {
     if (!table)
         throw new Error(`Table is required for inspect ${kind}.`);
     const quoted = quoteSqliteLiteral(table);
+    if (kind === "editable") {
+        const object = database.prepare("SELECT type FROM sqlite_master WHERE name = ?").get(table);
+        const columns = database.prepare(`PRAGMA table_xinfo(${quoted})`).all();
+        return { writable: object?.type === "table", columns: columns.map(column => ({ name: String(column.name), type: String(column.type).toLowerCase(), nullable: !column.notnull && !column.pk, generated: Number(column.hidden) !== 0, key: Number(column.pk) })) };
+    }
     const columns = database
         .prepare(`PRAGMA table_info(${quoted})`)
         .all();
@@ -199,6 +216,37 @@ function inspect(database, kind, table) {
         foreign_keys: foreignKeys.length,
     };
 }
+function listObjects(database, filter) {
+    const supported = ["table", "view", "trigger"];
+    if (filter.kind !== undefined && !supported.includes(filter.kind))
+        throw new Error(`SQLite does not support catalog kind "${filter.kind}".`);
+    if (filter.schema !== undefined && filter.schema !== "main")
+        throw new Error("SQLite only supports the main schema.");
+    const offset = filter.offset ?? 0;
+    const limit = filter.limit ?? 50;
+    if (typeof offset !== "number" || !Number.isSafeInteger(offset) || offset < 0 || offset > 1_000_000 || !Number.isSafeInteger(limit) || limit < 1 || limit > 200)
+        throw new Error("Invalid SQLite catalog page bounds.");
+    if (filter.search !== undefined && (!filter.search || filter.search.length > 200 || filter.search.includes("\0")))
+        throw new Error("Invalid SQLite catalog search.");
+    const types = filter.kind ? [filter.kind] : [...supported];
+    const placeholders = types.map(() => "?").join(", ");
+    const rows = database.prepare(`SELECT type AS kind, 'main' AS schema, name, 'main.' || name AS identity
+     FROM sqlite_master WHERE type IN (${placeholders}) AND name NOT LIKE 'sqlite_%'
+       AND (? IS NULL OR instr(lower(name), lower(?)) > 0)
+     ORDER BY kind, name LIMIT ? OFFSET ?`).all(...types, filter.search ?? null, filter.search ?? null, limit + 1, offset);
+    const more = rows.length > limit;
+    return { objects: rows.slice(0, limit), next_offset: more ? offset + limit : null, supported_kinds: [...supported] };
+}
+function describeObject(database, object) {
+    if (!["table", "view", "trigger"].includes(object.kind) || (object.schema !== undefined && object.schema !== "main"))
+        throw new Error(`SQLite does not support catalog kind "${object.kind}".`);
+    const row = database.prepare("SELECT type AS kind, 'main' AS schema, name, 'main.' || name AS identity, sql AS definition FROM sqlite_master WHERE type = ? AND name = ?").get(object.kind, object.name);
+    if (!row)
+        throw new Error("Catalog object was not found.");
+    const definition = row.definition === null ? null : String(row.definition);
+    delete row.definition;
+    return { object: row, definition };
+}
 function bindAll(statement, params) {
     if (Array.isArray(params))
         return statement.all(...params);

package/dist/src/stateql.d.ts

@@ -1,4 +1,5 @@
-import type { ActorLinkData, ActorResolutionData, ActorsData, ActorUnlinkData, AliasData, ApplyData, BatchCommand, CommandExecutionContext, BatchOptions, CapabilitiesData, CloseSessionData, ColumnsData, CommitTransactionData, ConnectOptions, ConnectionData, CountData, DisconnectData, DoctorData, ExecData, ExecOptions, ExecutionOptions, ExportData, FilterOptions, HistoryData, HistoryOptions, OperationData, PlanData, PlanOptions, ProfileData, ProfilesData, ProfileOptions, MongoExecOptions, MongoPlanOptions, MongoQueryOptions, MongoReadCommand, MongoWriteCommand, PurgeData, QueryOptions, RemovedProfileData, Response, ResultData, RollbackTransactionData, RowsData, RowsOptions, StateQLActorOptions, StateQLOptions, StateQLSnapshot, StatusData, SessionData, SessionsData, SessionSummaryData, TransactionData } from "./types.js";
+import { type TableChange } from "./table-editor.js";
+import type { ActorLinkData, ActorResolutionData, ActorsData, ActorUnlinkData, AliasData, ApplyData, BatchCommand, CommandExecutionContext, CommandOrigin, BatchOptions, CapabilitiesData, CatalogObject, DescribeObjectData, ListObjectsData, ListObjectsFilter, CloseSessionData, ColumnsData, CommitTransactionData, ConnectOptions, ConnectionData, CountData, DisconnectData, DoctorData, ExecData, ExecOptions, ExecutionOptions, ExportData, FilterOptions, HistoryData, HistoryOptions, OperationData, PlanData, PlanOptions, ProfileData, ProfilesData, ProfileOptions, ProfileUpdateOptions, MongoExecOptions, MongoPlanOptions, MongoQueryOptions, MongoReadCommand, MongoWriteCommand, RedisCommand, RedisExecOptions, RedisPlanOptions, RedisQueryOptions, PurgeData, QueryOptions, RemovedProfileData, Response, ResultData, RollbackTransactionData, RowsData, RowsOptions, Column, StateQLActorOptions, StateQLOptions, StateQLSnapshot, StateQLSnapshotOptions, StatusData, SessionData, SessionsData, SessionSummaryData, TransactionData } from "./types.js";
 export declare class StateQL {
     static forActor(options: StateQLActorOptions): StateQL;
     private readonly store;
@@ -17,18 +18,20 @@ export declare class StateQL {
     private readonly credentialResolver?;
     private readonly now;
     private closed;
+    private readonly tableResults;
+    private readonly editTokens;
+    private panelRows?;
     constructor(options?: StateQLOptions);
     close(): void;
     [Symbol.dispose](): void;
     connect(target?: string, options?: ConnectOptions): Promise<Response<ConnectionData>>;
     addProfile(name: string, target?: string, options?: ProfileOptions): Promise<Response<ProfileData>>;
+    updateProfile(name: string, changes: ProfileUpdateOptions): Promise<Response<ProfileData>>;
     listProfiles(): Promise<Response<ProfilesData>>;
     showProfile(name: string): Promise<Response<ProfileData>>;
     removeProfile(name: string): Promise<Response<RemovedProfileData>>;
     disconnect(): Promise<Response<DisconnectData>>;
-    snapshot(options?: {
-        historyLimit?: number;
-    }): StateQLSnapshot;
+    snapshot(options?: StateQLSnapshotOptions): StateQLSnapshot;
     status(): Promise<Response<StatusData>>;
     linkActor(session: string, actorId: string): Promise<Response<ActorLinkData>>;
     unlinkActor(session: string, actorId: string): Promise<Response<ActorUnlinkData>>;
@@ -41,23 +44,68 @@ export declare class StateQL {
     closeSession(): Promise<Response<CloseSessionData>>;
     query(sql: string, options?: QueryOptions): Promise<Response<ResultData>>;
     mongoQuery(command: MongoReadCommand, options?: MongoQueryOptions): Promise<Response<ResultData>>;
+    redisQuery(command: RedisCommand, options?: RedisQueryOptions): Promise<Response<ResultData>>;
     show(idOrAlias: string): Promise<Response<ResultData>>;
     filter(idOrAlias: string, predicate: string, options?: FilterOptions): Promise<Response<ResultData>>;
     rows(idOrAlias: string, options?: RowsOptions): Promise<Response<RowsData>>;
     count(idOrAlias: string): Promise<Response<CountData>>;
     columns(idOrAlias: string): Promise<Response<ColumnsData>>;
     setAlias(name: string, id: string): Promise<Response<AliasData>>;
+    /** Owned, full-value pages for host UIs. Reading a page does not add a command to history. */
+    readMaterialized(id: string, options?: RowsOptions & {
+        signal?: AbortSignal;
+    }): RowsData & {
+        columns: Column[];
+        row_tokens: Array<string | null>;
+        writable_columns: string[];
+        editing_reason?: string;
+    };
+    /** No caller-selected filesystem paths. The host delivers these bounded attachment bytes. */
+    serializeResult(id: string, format: "json" | "jsonl" | "csv", signal?: AbortSignal, origin?: CommandOrigin): Promise<Response<{
+        content: string;
+        format: string;
+        rows: number;
+    }>>;
+    readTable(table: {
+        schema?: string;
+        name: string;
+    }, limit?: number, options?: QueryOptions & {
+        origin?: CommandOrigin;
+    }): Promise<Response<ResultData & {
+        table: {
+            schema?: string;
+            name: string;
+        };
+        sample_limit: number;
+        query: string;
+    }>>;
+    planTableUpdate(token: string, changes: TableChange, options?: ExecutionOptions & {
+        origin?: CommandOrigin;
+    }): Promise<Response<PlanData>>;
+    planTableUpdates(changes: Array<{
+        row_token: string;
+        changes: TableChange;
+    }>, options?: ExecutionOptions & {
+        origin?: CommandOrigin;
+    }): Promise<Response<PlanData>>;
+    private editableMetadata;
+    private panelResult;
+    private fullResultRows;
     exportResult(idOrAlias: string, output: string, format?: "json" | "jsonl" | "csv"): Promise<Response<ExportData>>;
     exec(sql: string, options?: ExecOptions): Promise<Response<ExecData>>;
     mongoExec(command: MongoWriteCommand, options?: MongoExecOptions): Promise<Response<ExecData>>;
+    redisExec(command: RedisCommand, options?: RedisExecOptions): Promise<Response<ExecData>>;
     receipt(id: string): Promise<Response<OperationData>>;
     beginTransaction(isolation?: string): Promise<Response<TransactionData>>;
     transactionStatus(id?: string): Promise<Response<TransactionData>>;
     commitTransaction(id?: string, options?: ExecutionOptions): Promise<Response<CommitTransactionData>>;
     rollbackTransaction(id?: string): Promise<Response<RollbackTransactionData>>;
     inspect(kind: string, table?: string, options?: ExecutionOptions): Promise<Response<unknown>>;
+    listObjects(filter?: ListObjectsFilter, options?: ExecutionOptions): Promise<Response<ListObjectsData>>;
+    describeObject(object: CatalogObject, options?: ExecutionOptions): Promise<Response<DescribeObjectData>>;
     plan(sql: string, options?: PlanOptions): Promise<Response<PlanData>>;
     mongoPlan(command: MongoWriteCommand, options?: MongoPlanOptions): Promise<Response<PlanData>>;
+    redisPlan(command: RedisCommand, options?: RedisPlanOptions): Promise<Response<PlanData>>;
     apply(planId: string, options?: ExecutionOptions): Promise<Response<ApplyData>>;
     history(limit?: number, options?: HistoryOptions): Promise<Response<HistoryData>>;
     doctor(): Promise<Response<DoctorData>>;
@@ -67,12 +115,15 @@ export declare class StateQL {
     batch(commands: Iterable<BatchCommand> | AsyncIterable<BatchCommand>, options?: BatchOptions): AsyncGenerator<Response<unknown>>;
     private performExec;
     private performMongoExec;
+    private performRedisExec;
+    private performTableBatch;
     private batchFailure;
     private withResult;
     private rejectDuringStagedTransaction;
     private requireResult;
     private requireConnection;
     private requireMongoConnection;
+    private requireRedisConnection;
     private rejectMongoSql;
     private requireActiveTransaction;
     private requireSelectedSession;
@@ -82,6 +133,7 @@ export declare class StateQL {
     private resolveCredential;
     private openAdapter;
     private openMongoAdapter;
+    private openRedisAdapter;
     private executionContext;
     private resultData;
     private cacheValid;