@volter/world-core 3.0.37 → 3.0.39

package/dist/src/redis/frames.js

@@ -0,0 +1,123 @@
+import { exactInteger } from "../exact-json.js";
+// RESP frame parsing and RESP2 replies, shared by the Redis stream and journey tooling.
+// https://redis.io/docs/latest/develop/reference/protocol-spec/
+import { RedisInteger, RedisStatus } from "./engine.js";
+export const binaryText = (b) => Array.from(b, (n) => String.fromCharCode(n)).join('');
+export const binaryBytes = (s) => Uint8Array.from(s, (c) => c.charCodeAt(0));
+export function readResp(s, start = 0) {
+    const e = s.indexOf('\r\n', start);
+    if (e < 0)
+        return undefined;
+    const tag = s[start], head = s.slice(start + 1, e);
+    let at = e + 2;
+    if (tag === '+' || tag === '-')
+        return { type: tag, value: head, end: at, ...(tag === '-' ? { error: true } : {}) };
+    if (tag === ':')
+        return { type: tag, value: exactInteger(head), end: at };
+    if (tag === '_')
+        return { type: tag, value: null, end: at };
+    if (tag === '#')
+        return { type: tag, value: head === 't', end: at };
+    if (tag === ',')
+        return { type: tag, value: Number(head), end: at };
+    const n = Number(head);
+    if (!Number.isSafeInteger(n) || n < -1)
+        throw new Error('Protocol error: invalid length');
+    if (tag === '$' || tag === '!') {
+        if (n === -1)
+            return { type: tag, value: null, end: at };
+        if (s.length < at + n + 2)
+            return undefined;
+        if (s.slice(at + n, at + n + 2) !== '\r\n')
+            throw new Error('Protocol error: invalid bulk terminator');
+        return { type: tag, value: s.slice(at, at + n), end: at + n + 2, ...(tag === '!' ? { error: true } : {}) };
+    }
+    if (['*', '%', '~', '>'].includes(tag)) {
+        if (n === -1)
+            return { type: tag, value: null, end: at };
+        const out = [];
+        for (let i = 0; i < n * (tag === '%' ? 2 : 1); i++) {
+            const f = readResp(s, at);
+            if (!f)
+                return undefined;
+            out.push(f.error ? { error: f.value } : f.value);
+            at = f.end;
+        }
+        return { type: tag, value: tag === '%' ? Object.fromEntries(Array.from({ length: n }, (_, i) => [out[i * 2], out[i * 2 + 1]])) : out, end: at };
+    }
+    throw new Error('Protocol error: invalid type');
+}
+export function respReply(value) {
+    if (value instanceof RedisInteger || typeof value === 'object' && value !== null && 'integer' in value)
+        return `:${value.integer}\r\n`;
+    if (value === null)
+        return '$-1\r\n';
+    if (value instanceof RedisStatus || typeof value === 'object' && !Array.isArray(value) && 'value' in value)
+        return `+${String(value.value).replace(/[\r\n]/g, ' ')}\r\n`;
+    if (typeof value === 'object' && !Array.isArray(value) && 'error' in value)
+        return `-${String(value.error).trim().replace(/[\r\n]/g, ' ')}\r\n`;
+    if (Array.isArray(value))
+        return `*${value.length}\r\n${value.map((x) => respReply(x)).join('')}`;
+    if (typeof value === 'object')
+        return respReply(Object.entries(value).flat());
+    if (typeof value === 'number')
+        return Number.isInteger(value) ? `:${value}\r\n` : respReply(String(value));
+    const s = String(value);
+    return `$${s.length}\r\n${s}\r\n`;
+}
+export const commandFrame = (command) => {
+    const args = command.map((s) => binaryText(new TextEncoder().encode(s)));
+    return binaryBytes(`*${args.length}\r\n${args.map((s) => `$${s.length}\r\n${s}\r\n`).join('')}`);
+};
+export function inlineCommand(line) {
+    const words = [];
+    let word = '', quote = '', active = false;
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (c === '\\' && quote) {
+            const next = line[++i];
+            if (next === 'x' && /^[0-9a-f]{2}$/i.test(line.slice(i + 1, i + 3))) {
+                word += String.fromCharCode(parseInt(line.slice(i + 1, i + 3), 16));
+                i += 2;
+            }
+            else
+                word += { n: '\n', r: '\r', t: '\t' }[next] ?? next;
+        }
+        else if (quote) {
+            if (c === quote)
+                quote = '';
+            else
+                word += c;
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+            active = true;
+        }
+        else if (/\s/.test(c)) {
+            if (active) {
+                words.push(word);
+                word = '';
+                active = false;
+            }
+        }
+        else {
+            word += c;
+            active = true;
+        }
+    }
+    if (quote)
+        throw new Error('Protocol error: unbalanced quotes in request');
+    if (active)
+        words.push(word);
+    return words;
+}
+/** Carry RESP integer/status tags across an internal JSON request without losing int64 bytes. */
+export function wireValue(value) {
+    if (value instanceof RedisInteger)
+        return { integer: value.integer };
+    if (Array.isArray(value))
+        return value.map(wireValue);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, wireValue(item)]));
+    return value;
+}

package/dist/src/redis/index.d.ts

@@ -1,2 +1,8 @@
 export * from './engine.js';
 export * from './lua.js';
+export * from './resp2.js';
+export * from './json.js';
+export * from './member-storage.js';
+export * from './lua-libs.js';
+export * from './frames.js';
+export * from './stream.js';

package/dist/src/redis/index.js

@@ -4,3 +4,9 @@
 // docs/contributing/architecture.md, "Other wires: lanes, headers and line protocols".
 export * from "./engine.js";
 export * from "./lua.js";
+export * from "./resp2.js";
+export * from "./json.js";
+export * from "./member-storage.js";
+export * from "./lua-libs.js";
+export * from "./frames.js";
+export * from "./stream.js";

package/dist/src/redis/json.d.ts

@@ -0,0 +1,2 @@
+/** Serialize a JSON reply envelope, including nested exact Redis integer numeric tokens. */
+export declare function jsonReply(value: unknown): string;

package/dist/src/redis/json.js

@@ -0,0 +1,14 @@
+// JSON envelopes for Redis replies. Integer replies carry decimal digits until the wire writes them;
+// converting them to a Number here would round values outside JavaScript's safe integer range.
+import { RedisInteger } from "./engine.js";
+/** Serialize a JSON reply envelope, including nested exact Redis integer numeric tokens. */
+export function jsonReply(value) {
+    if (value instanceof RedisInteger)
+        return value.integer;
+    if (Array.isArray(value))
+        return `[${value.map((item) => jsonReply(item)).join(',')}]`;
+    if (value !== null && typeof value === 'object') {
+        return `{${Object.entries(value).filter(([, item]) => item !== undefined).map(([key, item]) => `${JSON.stringify(key)}:${jsonReply(item)}`).join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+}

package/dist/src/redis/lua-libs.d.ts

@@ -0,0 +1,4 @@
+import { type LuaValue, type LuaHost } from './lua.js';
+export declare function unpackMessage(s: string): LuaValue;
+export declare function packMessage(value: LuaValue): string;
+export declare const standardLuaLibraries: NonNullable<LuaHost['extend']>;

package/dist/src/redis/lua-libs.js

@@ -0,0 +1,173 @@
+// Redis's Lua JSON/MessagePack runtime libraries. Values only; no state or vendor names.
+// https://redis.io/docs/latest/develop/programmability/lua-api/ (cjson, cmsgpack, bit)
+import { LuaTable, LuaError, LUA_NULL, luaPattern, numberToLuaString, luaTypeName } from "./lua.js";
+const bytes = (s) => Uint8Array.from(s, (c) => c.charCodeAt(0));
+const text = (b) => Array.from(b, (v) => String.fromCharCode(v)).join('');
+const objectTable = (v) => { const t = new LuaTable(); for (const [k, x] of Object.entries(v))
+    t.set(k, from(x)); return t; };
+const from = (v) => v === null ? LUA_NULL : Array.isArray(v) ? LuaTable.fromArray(v.map(from)) : typeof v === 'object' ? objectTable(v) : v;
+const to = (v) => v === LUA_NULL || v === null ? null : v instanceof LuaTable ? v.length > 0 ? v.toArray().map(to) : Object.fromEntries([...v.map.entries()].map(([k, x]) => [String(k), to(x)])) : v;
+export function unpackMessage(s) {
+    const b = bytes(s), d = new DataView(b.buffer);
+    let i = 0;
+    const n = (width, signed = false) => { let v; if (i + width > b.length)
+        throw new LuaError('Bad data format in input.'); if (width === 1)
+        v = signed ? d.getInt8(i) : d.getUint8(i);
+    else if (width === 2)
+        v = signed ? d.getInt16(i) : d.getUint16(i);
+    else if (width === 4)
+        v = signed ? d.getInt32(i) : d.getUint32(i);
+    else
+        v = Number(signed ? d.getBigInt64(i) : d.getBigUint64(i)); i += width; return v; };
+    const string = (len) => { const out = text(b.subarray(i, i + len)); i += len; if (i > b.length)
+        throw new LuaError('Bad data format in input.'); return out; };
+    const array = (len) => LuaTable.fromArray(Array.from({ length: len }, read));
+    const map = (len) => { const t = new LuaTable(); for (let j = 0; j < len; j++)
+        t.set(read(), read()); return t; };
+    function read() {
+        const c = n(1);
+        if (c < 128)
+            return c;
+        if (c >= 224)
+            return c - 256;
+        if ((c & 0xe0) === 0xa0)
+            return string(c & 31);
+        if ((c & 0xf0) === 0x90)
+            return array(c & 15);
+        if ((c & 0xf0) === 0x80)
+            return map(c & 15);
+        switch (c) {
+            case 0xc0: return null;
+            case 0xc2: return false;
+            case 0xc3: return true;
+            case 0xc4:
+            case 0xd9: return string(n(1));
+            case 0xc5:
+            case 0xda: return string(n(2));
+            case 0xc6:
+            case 0xdb: return string(n(4));
+            case 0xcc: return n(1);
+            case 0xcd: return n(2);
+            case 0xce: return n(4);
+            case 0xcf: return n(8);
+            case 0xd0: return n(1, true);
+            case 0xd1: return n(2, true);
+            case 0xd2: return n(4, true);
+            case 0xd3: return n(8, true);
+            case 0xca: {
+                const v = d.getFloat32(i);
+                i += 4;
+                return v;
+            }
+            case 0xcb: {
+                const v = d.getFloat64(i);
+                i += 8;
+                return v;
+            }
+            case 0xdc: return array(n(2));
+            case 0xdd: return array(n(4));
+            case 0xde: return map(n(2));
+            case 0xdf: return map(n(4));
+            default: throw new LuaError('Bad data format in input.');
+        }
+    }
+    const value = read();
+    if (i !== b.length)
+        throw new LuaError('Extra bytes in input.');
+    return value;
+}
+export function packMessage(value) {
+    const out = [];
+    const len = (tag, size, n) => { out.push(tag); for (let j = size - 1; j >= 0; j--)
+        out.push(Math.floor(n / 2 ** (j * 8)) & 255); };
+    const put = (v) => {
+        if (v === null || v === LUA_NULL) {
+            out.push(0xc0);
+            return;
+        }
+        if (typeof v === 'boolean') {
+            out.push(v ? 0xc3 : 0xc2);
+            return;
+        }
+        if (typeof v === 'number') {
+            if (Number.isInteger(v) && v >= 0 && v < 128 || v >= -32 && v < 0 && Number.isInteger(v))
+                out.push(v & 255);
+            else {
+                const b = new Uint8Array(8);
+                new DataView(b.buffer).setFloat64(0, v);
+                out.push(0xcb, ...b);
+            }
+            return;
+        }
+        if (typeof v === 'string') {
+            if (v.length < 32)
+                out.push(0xa0 | v.length);
+            else
+                len(v.length < 256 ? 0xd9 : 0xda, v.length < 256 ? 1 : 2, v.length);
+            out.push(...bytes(v));
+            return;
+        }
+        if (!(v instanceof LuaTable))
+            throw new LuaError('Unsupported type');
+        if (v.length > 0) {
+            const a = v.toArray();
+            if (a.length < 16)
+                out.push(0x90 | a.length);
+            else
+                len(0xdc, 2, a.length);
+            a.forEach(put);
+        }
+        else {
+            if (v.map.size < 16)
+                out.push(0x80 | v.map.size);
+            else
+                len(0xde, 2, v.map.size);
+            for (const [k, x] of v.map) {
+                put(k);
+                put(x);
+            }
+        }
+    };
+    put(value);
+    return text(Uint8Array.from(out));
+}
+export const standardLuaLibraries = ({ get, set, commandApi }) => {
+    // Lua 5.1 string.match is a selected script runtime capability, not a base-library change.
+    // source: https://www.lua.org/manual/5.1/manual.html "Returns the captures from the pattern"
+    const string = get('string');
+    string.set('match', (a) => {
+        const str = (i) => { const v = a[i] ?? null; if (typeof v === 'string')
+            return v; if (typeof v === 'number')
+            return numberToLuaString(v); throw new LuaError(`bad argument #${i + 1} to 'string.match' (string expected, got ${luaTypeName(v)})`); };
+        const value = str(0), pattern = str(1);
+        const start = a[2] === undefined ? 0 : Math.max(0, Number(a[2]) - 1);
+        const match = new RegExp(luaPattern(pattern)).exec(value.slice(start));
+        return match ? match.length > 1 ? match.slice(1) : [match[0]] : [null];
+    });
+    set('redis', commandApi);
+    set('server', commandApi);
+    const json = new LuaTable();
+    json.set('null', LUA_NULL);
+    json.set('encode', (a) => [text(new TextEncoder().encode(JSON.stringify(to(a[0] ?? null))))]);
+    json.set('decode', (a) => { try {
+        return [from(JSON.parse(new TextDecoder().decode(bytes(String(a[0])))))];
+    }
+    catch {
+        throw new LuaError('Expected value but found invalid token');
+    } });
+    set('cjson', json);
+    const msg = new LuaTable();
+    msg.set('unpack', (a) => [unpackMessage(String(a[0]))]);
+    msg.set('pack', (a) => [packMessage(a[0] ?? null)]);
+    set('cmsgpack', msg);
+    const bit = new LuaTable();
+    const ns = (a) => a.map(Number);
+    bit.set('band', (a) => [ns(a).reduce((x, y) => x & y, -1)]);
+    bit.set('bor', (a) => [ns(a).reduce((x, y) => x | y, 0)]);
+    bit.set('bxor', (a) => [ns(a).reduce((x, y) => x ^ y, 0)]);
+    bit.set('bnot', (a) => [~Number(a[0])]);
+    bit.set('lshift', (a) => [Number(a[0]) << Number(a[1])]);
+    bit.set('rshift', (a) => [Number(a[0]) >>> Number(a[1])]);
+    bit.set('arshift', (a) => [Number(a[0]) >> Number(a[1])]);
+    set('bit', bit);
+};

package/dist/src/redis/lua.d.ts

@@ -121,6 +121,7 @@ type Stat = {
 };
 /** Parse Lua source into a chunk. Exported so a test can prove a bad script fails at PARSE time. */
 export declare function parseLua(src: string): Stat[];
+export declare function luaPattern(pattern: string): string;
 export declare function luaTruthy(v: LuaValue): boolean;
 export declare function luaTypeName(v: LuaValue): string;
 /** Lua 5.1's `%.14g` number formatting — `3` prints as "3", not "3.0". */

package/dist/src/redis/lua.js

@@ -604,6 +604,42 @@ class Scope {
     }
 }
 const BREAK = Symbol('lua-break');
+// Lua pattern subset used by command-language scripts; unsupported balanced/frontier patterns refuse explicitly.
+export function luaPattern(pattern) {
+    const classes = { a: 'A-Za-z', d: '0-9', l: 'a-z', u: 'A-Z', w: 'A-Za-z0-9', s: '\\s', x: 'A-Fa-f0-9', p: '!-/:-@[-`{-~', c: '\\x00-\\x1f\\x7f', z: '\\x00' };
+    let out = '', inClass = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === '%') {
+            const next = pattern[++i];
+            if (next === 'b' || next === 'f')
+                throw new LuaError('unsupported Lua balanced/frontier pattern');
+            if (classes[next.toLowerCase()]) {
+                const content = classes[next.toLowerCase()];
+                out += inClass ? content : `[${next === next.toUpperCase() ? '^' : ''}${content}]`;
+            }
+            else if (/\d/.test(next))
+                out += `\\${next}`;
+            else
+                out += next.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+        }
+        else if (c === '[') {
+            inClass = true;
+            out += c;
+        }
+        else if (c === ']') {
+            inClass = false;
+            out += c;
+        }
+        else if (!inClass && c === '-')
+            out += '*?';
+        else if ('\\{}|'.includes(c))
+            out += `\\${c}`;
+        else
+            out += c;
+    }
+    return out;
+}
 export function luaTruthy(v) {
     return v !== null && v !== false;
 }

package/dist/src/redis/member-storage.d.ts

@@ -0,0 +1,5 @@
+import type { RedisContext, KeyspaceImage, KeySpace } from './engine.js';
+export declare const memberStorage: {
+    image(ctx: RedisContext): KeyspaceImage;
+    flush(space: KeySpace): Promise<void>;
+};

package/dist/src/redis/member-storage.js

@@ -0,0 +1,75 @@
+// Redis's collection layout over the World tree. First need: the managed Redis queue's growing events stream.
+// Key metadata and each hash field/set member/sorted-set member/stream entry are separate subjects.
+import { createHash } from 'node:crypto';
+import { applyTwinWrite } from "../serve.js";
+import { projectResources } from "../actions.js";
+import { treeStamp, treeChangesSince } from "../log.js";
+import { getActiveWorldStore } from "../world-store.js";
+const scope = (c) => c.database === undefined ? '' : `db:${c.database}:`;
+const collections = new Set(['hash', 'set', 'zset', 'stream', 'list']);
+const held = new WeakMap();
+const members = (r) => !r || !collections.has(r.kind) ? new Map() : new Map(r.v.map((x, i) => r.kind === 'list' ? [String(i), x] : r.kind === 'set' ? [x, x] : [x[0], x[1]]));
+const memberId = (c, name, field) => `${scope(c)}member:${createHash('sha256').update(JSON.stringify([name, field])).digest('hex')}`;
+export const memberStorage = {
+    image(ctx) {
+        const cache = held.get(getActiveWorldStore()) ?? new Map();
+        held.set(getActiveWorldStore(), cache);
+        const key = `${ctx.service}\0${ctx.root ?? ''}\0${scope(ctx)}`;
+        let h = cache.get(key);
+        const stamp = treeStamp(ctx.service, ctx.root);
+        if (h?.stamp === stamp)
+            return h.image;
+        const delta = h && treeChangesSince(ctx.service, ctx.root, h.stamp);
+        if (!h || !delta || delta.removed.length)
+            h = { stamp, subjects: new Map(), image: { rows: new Map(), scripts: new Map(), revs: new Map() } };
+        for (const r of delta && !delta.removed.length ? delta.changed : projectResources(ctx.service, ctx.root))
+            h.subjects.set(r.id, r);
+        // Reconstruct only keys affected by the tree delta, not every member on every read.
+        const affected = new Set();
+        const changed = delta && !delta.removed.length ? delta.changed : [...h.subjects.values()];
+        for (const r of changed) {
+            if (!r.id.startsWith(scope(ctx)))
+                continue;
+            if (r.type === 'key')
+                affected.add(r.name);
+            if (r.type === 'member')
+                affected.add(r.key);
+            if (r.type === 'script') {
+                if (r.gone)
+                    h.image.scripts.delete(r.sha);
+                else
+                    h.image.scripts.set(r.sha, r.body);
+            }
+        }
+        for (const name of affected) {
+            const meta = h.subjects.get(`${scope(ctx)}key:${name}`);
+            if (!meta)
+                continue;
+            h.image.revs.set(name, meta._rev ?? 0);
+            if (meta.gone) {
+                h.image.rows.delete(name);
+                continue;
+            }
+            const v = collections.has(meta.kind) ? [...h.subjects.values()].filter((r) => r.type === 'member' && r.id.startsWith(scope(ctx)) && r.key === name && r.gone !== true).sort((a, b) => meta.kind === 'list' ? Number(a.field) - Number(b.field) : 0).map((r) => meta.kind === 'list' ? r.value : meta.kind === 'set' ? r.field : [r.field, r.value]) : meta.v;
+            h.image.rows.set(name, { name, kind: meta.kind, v, pexpireAt: meta.pexpire_at == null ? null : String(meta.pexpire_at), lastId: meta.last_id, _rev: meta._rev });
+        }
+        h.stamp = stamp;
+        cache.set(key, h);
+        return h.image;
+    },
+    async flush(space) {
+        const ctx = space.ctx;
+        const write = async (type, id, operation, fields) => applyTwinWrite(ctx.service, { operation, subjectType: type, subjectId: id, fields, occurredAt: ctx.occurredAt, actor: { kind: 'agent' } }, ctx.root);
+        for (const { name, row, operation } of space.pendingWrites()) {
+            const before = members(space.image.rows.get(name) ?? null), after = members(row);
+            for (const field of new Set([...before.keys(), ...after.keys()])) {
+                if (before.has(field) && after.has(field) && JSON.stringify(before.get(field)) === JSON.stringify(after.get(field)))
+                    continue;
+                await write('member', memberId(ctx, name, field), operation, { key: name, field, value: after.get(field) ?? null, gone: !after.has(field) });
+            }
+            await write('key', `${scope(ctx)}key:${name}`, operation, { name, kind: row?.kind ?? 'string', v: row && !collections.has(row.kind) ? row.v : null, pexpire_at: row?.pexpireAt ?? null, last_id: row?.lastId ?? '', gone: row === null, _rev: space.nextRev(name) });
+        }
+        for (const { sha, body, operation } of space.pendingScriptWrites())
+            await write('script', `${scope(ctx)}script:${sha}`, operation, { sha, body: body ?? '', gone: body === null });
+    },
+};

package/dist/src/redis/resp2.d.ts

@@ -0,0 +1,4 @@
+import { type RedisValue } from './engine.js';
+export declare function resp2(value: RedisValue | {
+    error: string;
+}): string;

package/dist/src/redis/resp2.js

@@ -0,0 +1,29 @@
+// A reply as RESP2 writes it (https://redis.io/docs/latest/develop/reference/protocol-spec/): a status as a simple string,
+// an error as a simple error, an integer as an integer, a string as a bulk string (its length in bytes), a null as the
+// null bulk string, an array as an array of its elements' replies. RESP2 has no float or double: a number that is not an
+// integer is its bulk string, as Redis sends INCRBYFLOAT's. "Simple strings never contain carriage return ( \r ) or line
+// feed ( \n ) characters" (the page), and an error is a simple string's form: Redis writes a status's text with each CR
+// and LF mapped to a space (script_lua.c, `sdsmapchars(ok,"\r\n","  ",2)` before `addReplyStatusLength`), and an
+// error's with the CRs and LFs at its ends trimmed and each one left inside mapped to a space (networking.c,
+// `addReplyErrorFormatInternal`: `sdstrim(s, "\r\n")`, then `sdsmapchars(s, "\r\n", "  ",  2)`), so a message holding
+// one never ends the reply early. Source: https://raw.githubusercontent.com/redis/redis/7.4.0/src/networking.c and
+// https://raw.githubusercontent.com/redis/redis/7.4.0/src/script_lua.c.
+// Shared by every wire that answers a Redis reply as RESP2 bytes.
+import { RedisInteger, RedisStatus } from "./engine.js";
+const spaced = (text) => text.replace(/[\r\n]/g, ' ');
+const trimmed = (text) => text.replace(/^[\r\n]+|[\r\n]+$/g, '');
+export function resp2(value) {
+    if (value instanceof RedisInteger)
+        return `:${value.integer}\r\n`;
+    if (value === null)
+        return '$-1\r\n';
+    if (value instanceof RedisStatus)
+        return `+${spaced(value.value)}\r\n`;
+    if (Array.isArray(value))
+        return `*${value.length}\r\n${value.map((v) => resp2(v)).join('')}`;
+    if (typeof value === 'number')
+        return Number.isInteger(value) ? `:${value}\r\n` : resp2(String(value));
+    if (typeof value === 'string')
+        return `$${new TextEncoder().encode(value).length}\r\n${value}\r\n`;
+    return `-${spaced(trimmed(value.error))}\r\n`;
+}

package/dist/src/redis/stream.d.ts

@@ -0,0 +1,14 @@
+import type { TwinStream } from '../twin-fetch.js';
+import { type RedisDialect, type RunItem } from './engine.js';
+export type RedisStreamOptions = {
+    dialect: RedisDialect;
+    version: string;
+    password?: string;
+    databases: number;
+    run(commands: string[][], database: string): Promise<{
+        items: RunItem[];
+        wrote: boolean;
+        instant?: number;
+    }>;
+};
+export declare function createRedisStream(options: RedisStreamOptions): TwinStream;