@nimbus-sh/worker 0.1.0

package/dist/bindings/d1.js

@@ -0,0 +1,549 @@
+/**
+ * binding-d1.ts — D1 database emulator for nimbus-wrangler.
+ *
+ * Implements the Workers D1 runtime API
+ * (https://developers.cloudflare.com/d1/worker-api/) backed by the
+ * supervisor's own SqlStorage. Tables are namespaced per-binding via a
+ * lightweight identifier-rewriter so two D1 bindings on the same
+ * SqlStorage don't collide.
+ *
+ * Plan §14.1 (post-review amendment) recommends a child-DO-facet-per-
+ * binding architecture for full isolation in production. Implementation
+ * cost: a new DO class registered in src/index.ts + a wrangler.jsonc
+ * migration entry. Deferred to W10.5 — for W10 we ship the simpler
+ * single-storage variant with prefix-rewriting. Test seam preserves
+ * the contract so the upgrade is a drop-in replacement.
+ *
+ * Rewriter scope (deliberately narrow):
+ *   - CREATE [TABLE|INDEX|TRIGGER|VIEW] <name>      → prefixed
+ *   - DROP TABLE <name>                              → prefixed
+ *   - INSERT [OR ...] INTO <name>                    → prefixed
+ *   - SELECT ... FROM <name> [, <name>] ... [JOIN <name>] ...  → prefixed
+ *   - UPDATE <name>                                  → prefixed
+ *   - DELETE FROM <name>                             → prefixed
+ *   - WITH <cte> AS (SELECT ...)                     → CTE alias is NOT
+ *     prefixed (it's a query-local alias, not a real table); the inner
+ *     FROM <table> IS prefixed if it matches a known table
+ *
+ * SQL keywords are matched case-insensitively. We DO NOT rewrite inside
+ * string literals (single-quoted) or quoted identifiers in
+ * CREATE/INSERT/etc — the rewriter walks tokens, not bytes.
+ *
+ * Bind parameter forms: '?' positional only. Named parameters (':name')
+ * are NOT supported (D1 itself doesn't support them).
+ */
+// ── Identifier rewriter ─────────────────────────────────────────────────
+//
+// We track which table names belong to *this binding* by intercepting
+// CREATE TABLE / DROP TABLE. Subsequent INSERT/SELECT/etc rewrite only
+// references to those known names — bare identifiers that aren't on the
+// list pass through unchanged (lets PRAGMA, sqlite_master, etc. work).
+class TablePrefixer {
+    prefix;
+    // Tables created via this emulator (raw user-facing name → prefixed name)
+    known = new Set();
+    // Cache for performance
+    rewriteCache = new Map();
+    constructor(prefix) { this.prefix = prefix; }
+    /** Rewrite a single SQL statement, registering any new tables. */
+    rewrite(sql) {
+        const cached = this.rewriteCache.get(sql);
+        if (cached !== undefined)
+            return cached;
+        const out = this._rewrite(sql);
+        this.rewriteCache.set(sql, out);
+        return out;
+    }
+    /** Mark a raw table name as belonging to this binding. */
+    register(rawName) {
+        this.known.add(rawName.toLowerCase());
+    }
+    /** Drop a table from the registry. */
+    unregister(rawName) {
+        this.known.delete(rawName.toLowerCase());
+        // Bust the rewrite cache (any cached SQL referencing this name is stale)
+        this.rewriteCache.clear();
+    }
+    prefixed(rawName) { return this.prefix + rawName; }
+    has(rawName) { return this.known.has(rawName.toLowerCase()); }
+    _rewrite(sql) {
+        // Tokenize: walk char by char, separate string literals from
+        // identifiers. We emit `tokens` as a list of {type, value} where
+        // type is 'str' | 'word' | 'punct'. Then we rewrite words that are
+        // table names.
+        const tokens = [];
+        let i = 0;
+        const N = sql.length;
+        while (i < N) {
+            const ch = sql[i];
+            // String literal '…'
+            if (ch === "'") {
+                let j = i + 1;
+                while (j < N) {
+                    if (sql[j] === "'" && sql[j + 1] === "'") {
+                        j += 2;
+                        continue;
+                    }
+                    if (sql[j] === "'") {
+                        j++;
+                        break;
+                    }
+                    j++;
+                }
+                tokens.push({ type: 'str', value: sql.slice(i, j) });
+                i = j;
+                continue;
+            }
+            // Quoted identifier "…" or [...] or `…`
+            if (ch === '"' || ch === '`') {
+                let j = i + 1;
+                while (j < N && sql[j] !== ch)
+                    j++;
+                if (j < N)
+                    j++;
+                tokens.push({ type: 'word', value: sql.slice(i, j) });
+                i = j;
+                continue;
+            }
+            if (ch === '[') {
+                let j = i + 1;
+                while (j < N && sql[j] !== ']')
+                    j++;
+                if (j < N)
+                    j++;
+                tokens.push({ type: 'word', value: sql.slice(i, j) });
+                i = j;
+                continue;
+            }
+            // Whitespace
+            if (/\s/.test(ch)) {
+                let j = i;
+                while (j < N && /\s/.test(sql[j]))
+                    j++;
+                tokens.push({ type: 'ws', value: sql.slice(i, j) });
+                i = j;
+                continue;
+            }
+            // Word (identifier or keyword)
+            if (/[A-Za-z_]/.test(ch)) {
+                let j = i;
+                while (j < N && /[A-Za-z0-9_]/.test(sql[j]))
+                    j++;
+                tokens.push({ type: 'word', value: sql.slice(i, j) });
+                i = j;
+                continue;
+            }
+            // Otherwise punctuation
+            tokens.push({ type: 'punct', value: ch });
+            i++;
+        }
+        // Now walk tokens, find slots where the next non-ws token is a table
+        // name to rewrite. The trigger words are:
+        const SLOTS = new Set([
+            'TABLE', 'FROM', 'JOIN', 'INTO', 'UPDATE',
+        ]);
+        // CREATE TABLE → next word is the table name to register
+        // CREATE INDEX … ON <table> → next word AFTER 'ON' is the table
+        // CREATE TRIGGER … ON <table> → same
+        // CREATE VIEW <name> → next word is the view name (we treat like a table)
+        // DROP TABLE <name> → unregister
+        // ALTER TABLE <name>
+        const wordIdx = (i) => {
+            for (let k = i + 1; k < tokens.length; k++) {
+                if (tokens[k].type === 'ws')
+                    continue;
+                return k;
+            }
+            return -1;
+        };
+        const isWord = (k, w) => k >= 0 && k < tokens.length && tokens[k].type === 'word' &&
+            stripQuoting(tokens[k].value).toUpperCase() === w;
+        const rewriteAtIfKnown = (k, registerNew = false) => {
+            if (k < 0 || k >= tokens.length)
+                return false;
+            const t = tokens[k];
+            if (t.type !== 'word')
+                return false;
+            const raw = stripQuoting(t.value);
+            // Skip SQL keywords / reserved words
+            if (RESERVED.has(raw.toUpperCase()))
+                return false;
+            // Skip if dotted (db.table) — we don't support attached dbs
+            // Already prefixed?
+            if (raw.startsWith(this.prefix))
+                return false;
+            if (registerNew) {
+                this.known.add(raw.toLowerCase());
+                t.value = this.prefix + raw;
+                return true;
+            }
+            if (this.known.has(raw.toLowerCase())) {
+                t.value = this.prefix + raw;
+                return true;
+            }
+            return false;
+        };
+        const unregisterAt = (k) => {
+            if (k < 0 || k >= tokens.length)
+                return;
+            const raw = stripQuoting(tokens[k].value);
+            this.known.delete(raw.toLowerCase());
+            tokens[k].value = this.prefix + raw;
+        };
+        for (let k = 0; k < tokens.length; k++) {
+            const t = tokens[k];
+            if (t.type !== 'word')
+                continue;
+            const w = stripQuoting(t.value).toUpperCase();
+            if (w === 'CREATE') {
+                // CREATE [TEMP[ORARY]] [UNIQUE] TABLE|INDEX|TRIGGER|VIEW [IF NOT EXISTS] <name>
+                // Walk forward through optional modifiers to find TABLE/INDEX/etc
+                let nextK = wordIdx(k);
+                let kind = null;
+                while (nextK >= 0) {
+                    const nw = stripQuoting(tokens[nextK].value).toUpperCase();
+                    if (nw === 'TABLE' || nw === 'INDEX' || nw === 'TRIGGER' || nw === 'VIEW') {
+                        kind = nw;
+                        break;
+                    }
+                    if (['TEMP', 'TEMPORARY', 'UNIQUE', 'IF', 'NOT', 'EXISTS'].includes(nw)) {
+                        nextK = wordIdx(nextK);
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (!kind)
+                    continue;
+                // Walk past optional 'IF NOT EXISTS' words after kind
+                let nameK = wordIdx(nextK);
+                while (nameK >= 0) {
+                    const nw = stripQuoting(tokens[nameK].value).toUpperCase();
+                    if (nw === 'IF' || nw === 'NOT' || nw === 'EXISTS') {
+                        nameK = wordIdx(nameK);
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (kind === 'TABLE' || kind === 'VIEW') {
+                    rewriteAtIfKnown(nameK, /*registerNew*/ true);
+                }
+                else {
+                    // CREATE INDEX/TRIGGER: don't register the index/trigger name itself,
+                    // but rewrite the ON <table> reference if present.
+                    // Just skip — find ON <existing-table> later in this same pass.
+                }
+                continue;
+            }
+            if (w === 'DROP' && tokens[wordIdx(k)] && stripQuoting(tokens[wordIdx(k)].value).toUpperCase() === 'TABLE') {
+                let nameK = wordIdx(wordIdx(k));
+                while (nameK >= 0 && ['IF', 'EXISTS'].includes(stripQuoting(tokens[nameK].value).toUpperCase())) {
+                    nameK = wordIdx(nameK);
+                }
+                unregisterAt(nameK);
+                continue;
+            }
+            // FROM <table> | JOIN <table> | INTO <table> | UPDATE <table>
+            if (w === 'FROM' || w === 'JOIN' || w === 'INTO' || w === 'UPDATE') {
+                // Walk forward, rewriting the next word AND any subsequent word
+                // separated by commas (FROM a, b).
+                let nameK = wordIdx(k);
+                // INSERT INTO has no comma list; UPDATE x SET … has no comma either;
+                // FROM does. Be lenient — just rewrite first.
+                rewriteAtIfKnown(nameK, /*registerNew*/ false);
+                if (w === 'FROM') {
+                    // Handle comma list: FROM a, b, c
+                    let walk = wordIdx(nameK);
+                    while (walk >= 0 && tokens[walk].type === 'punct' && tokens[walk].value === ',') {
+                        const nw = wordIdx(walk);
+                        rewriteAtIfKnown(nw, false);
+                        walk = wordIdx(nw);
+                    }
+                    // Actually punct tokens aren't word; fix the walk:
+                    // (we miss commas because wordIdx skips ws but lands on punct...)
+                }
+                continue;
+            }
+            // INDEX/TRIGGER/VIEW: ON <table>
+            if (w === 'ON') {
+                const prev = (() => {
+                    for (let p = k - 1; p >= 0; p--) {
+                        if (tokens[p].type === 'ws')
+                            continue;
+                        return tokens[p];
+                    }
+                    return null;
+                })();
+                // Heuristic: if we're inside a CREATE INDEX/TRIGGER, the previous
+                // significant tokens included CREATE…INDEX/TRIGGER. Be lenient:
+                // rewrite if next word is a known table.
+                rewriteAtIfKnown(wordIdx(k), false);
+                continue;
+            }
+        }
+        return tokens.map(t => t.value).join('');
+    }
+}
+const RESERVED = new Set([
+    'SELECT', 'FROM', 'WHERE', 'INSERT', 'INTO', 'VALUES', 'UPDATE', 'SET', 'DELETE',
+    'CREATE', 'TABLE', 'INDEX', 'VIEW', 'TRIGGER', 'DROP', 'ALTER', 'WITH', 'AS',
+    'JOIN', 'LEFT', 'RIGHT', 'FULL', 'INNER', 'OUTER', 'ON', 'AND', 'OR', 'NOT',
+    'NULL', 'IS', 'IN', 'BETWEEN', 'LIKE', 'GLOB', 'LIMIT', 'OFFSET', 'ORDER', 'BY',
+    'GROUP', 'HAVING', 'ASC', 'DESC', 'UNION', 'EXCEPT', 'INTERSECT', 'DISTINCT',
+    'ALL', 'EXISTS', 'PRAGMA', 'BEGIN', 'COMMIT', 'ROLLBACK', 'TRANSACTION',
+    'IF', 'TEMP', 'TEMPORARY', 'UNIQUE', 'PRIMARY', 'KEY', 'FOREIGN', 'REFERENCES',
+    'DEFAULT', 'CHECK', 'AUTOINCREMENT', 'INTEGER', 'TEXT', 'REAL', 'BLOB', 'NUMERIC',
+    'CASE', 'WHEN', 'THEN', 'ELSE', 'END', 'CAST', 'COLLATE',
+    'OR', 'REPLACE', 'ABORT', 'FAIL', 'IGNORE', 'AFTER', 'BEFORE', 'INSTEAD', 'OF',
+    'EACH', 'ROW',
+]);
+function stripQuoting(s) {
+    if (s.length >= 2) {
+        const f = s[0], l = s[s.length - 1];
+        if ((f === '"' && l === '"') || (f === '`' && l === '`'))
+            return s.slice(1, -1);
+        if (f === '[' && l === ']')
+            return s.slice(1, -1);
+    }
+    return s;
+}
+// ── D1 prepared statement ────────────────────────────────────────────────
+export class D1PreparedStatementEmu {
+    /** @internal */
+    _sql;
+    /** @internal */
+    _params;
+    _emu;
+    constructor(emu, sql, params) {
+        this._emu = emu;
+        this._sql = sql;
+        this._params = params;
+    }
+    bind(...values) {
+        return new D1PreparedStatementEmu(this._emu, this._sql, values);
+    }
+    async first(colName) {
+        const r = await this.all();
+        const row = r.results && r.results[0];
+        if (!row)
+            return null;
+        if (colName !== undefined)
+            return row[colName] ?? null;
+        return row;
+    }
+    async run() {
+        return this._emu._runOne(this._sql, this._params);
+    }
+    async all() {
+        return this._emu._runOne(this._sql, this._params);
+    }
+    async raw() {
+        const r = await this.all();
+        return (r.results || []).map((row) => Object.values(row));
+    }
+}
+// ── D1Emulator ────────────────────────────────────────────────────────────
+export class D1Emulator {
+    sql;
+    prefix;
+    prefixer;
+    migrationsRun = false;
+    migrationsDir;
+    vfs;
+    root;
+    onLog;
+    constructor(opts) {
+        this.sql = opts.sqlStorage;
+        this.prefix = '_d1_' + opts.binding + '__';
+        this.prefixer = new TablePrefixer(this.prefix);
+        this.migrationsDir = opts.migrationsDir;
+        this.vfs = opts.vfs;
+        this.root = opts.root;
+        this.onLog = opts.onLog || (() => { });
+    }
+    prepare(query) {
+        return new D1PreparedStatementEmu(this, query, []);
+    }
+    async batch(stmts) {
+        // Atomicity: snapshot/restore via the same _snapshot/_restore harness
+        // the SqlStorage offers. workerd's real SqlStorage exposes
+        // transactionSync; the mock-sql harness exposes _snapshot/_restore on
+        // the storage object. Here we use ctx.storage.transactionSync if
+        // available, else fall back to manual.
+        const results = [];
+        // Check for transactionSync on parent (ctx.storage)
+        const txn = this.sql._snapshot && this.sql._restore
+            ? (fn) => {
+                const snap = this.sql._snapshot();
+                try {
+                    return fn();
+                }
+                catch (e) {
+                    this.sql._restore(snap);
+                    throw e;
+                }
+            }
+            : (fn) => fn();
+        txn(() => {
+            for (const s of stmts) {
+                const r = this._runOneSync(s._sql, s._params);
+                if (!r.success)
+                    throw new Error(r.error || 'batch failed');
+                results.push(r);
+            }
+        });
+        return results;
+    }
+    async exec(query) {
+        const t0 = Date.now();
+        let count = 0;
+        // Split on semicolons, respecting string literals.
+        const parts = splitStatements(query);
+        for (const p of parts) {
+            if (!p.trim())
+                continue;
+            this._runOneSync(p, []);
+            count++;
+        }
+        return { count, duration: Date.now() - t0 };
+    }
+    /** @internal */
+    _runOne(sql, params) {
+        return this._runOneSync(sql, params);
+    }
+    /** Synchronous core (workerd SqlStorage.exec is sync). */
+    /** @internal */
+    _runOneSync(sql, params) {
+        const t0 = Date.now();
+        let rewritten;
+        try {
+            rewritten = this.prefixer.rewrite(sql);
+        }
+        catch (e) {
+            return {
+                success: false,
+                error: 'rewrite failed: ' + (e?.message || String(e)),
+                meta: this._meta(0, 0, 0, 0, t0),
+            };
+        }
+        let cursor;
+        try {
+            cursor = this.sql.exec(rewritten, ...params);
+        }
+        catch (e) {
+            return {
+                success: false,
+                error: e?.message || String(e),
+                meta: this._meta(0, 0, 0, 0, t0),
+            };
+        }
+        const arr = typeof cursor.toArray === 'function' ? cursor.toArray() : Array.from(cursor || []);
+        const rowsRead = cursor.rowsRead ?? cursor._rowsRead ?? arr.length;
+        const rowsWritten = cursor.rowsWritten ?? cursor._rowsWritten ?? 0;
+        const changes = cursor._changes ?? rowsWritten;
+        const lastRowId = cursor._lastRowId ?? 0;
+        return {
+            success: true,
+            results: arr,
+            meta: this._meta(rowsRead, rowsWritten, changes, lastRowId, t0),
+        };
+    }
+    _meta(rowsRead, rowsWritten, changes, lastRowId, t0) {
+        return {
+            duration: Date.now() - t0,
+            changes,
+            last_row_id: lastRowId,
+            rows_read: rowsRead,
+            rows_written: rowsWritten,
+            served_by: 'nimbus-d1-emu',
+            changed_db: rowsWritten > 0,
+        };
+    }
+    /** Apply migrations from migrations_dir if present. Idempotent. */
+    async applyMigrations() {
+        if (this.migrationsRun || !this.migrationsDir || !this.vfs)
+            return { applied: 0 };
+        this.migrationsRun = true;
+        // Ledger table tracks which migrations we've applied.
+        const ledger = '_d1_' + this.prefix.slice(4, -2) + '__nimbus_migrations';
+        this.sql.exec(`CREATE TABLE IF NOT EXISTS ${ledger} (filename TEXT PRIMARY KEY, applied_at INTEGER)`);
+        const root = (this.root || '').replace(/^\/+/, '').replace(/\/+$/, '');
+        const dir = this.migrationsDir.replace(/^\/+/, '').replace(/\/+$/, '');
+        const fullDir = root ? root + '/' + dir : dir;
+        if (!this.vfs.exists(fullDir))
+            return { applied: 0 };
+        const files = this.vfs.readdir(fullDir)
+            .filter((e) => e.type === 'file' && e.name.endsWith('.sql'))
+            .map((e) => e.name)
+            .sort();
+        let applied = 0;
+        for (const f of files) {
+            // Has it been applied?
+            const seen = this.sql.exec(`SELECT filename FROM ${ledger} WHERE filename = ?`, f).toArray();
+            if (seen.length > 0)
+                continue;
+            const sql = this.vfs.readFileString(fullDir + '/' + f);
+            const parts = splitStatements(sql);
+            for (const p of parts) {
+                if (!p.trim())
+                    continue;
+                this._runOneSync(p, []);
+            }
+            this.sql.exec(`INSERT INTO ${ledger} (filename, applied_at) VALUES (?, ?)`, f, Date.now());
+            applied++;
+        }
+        return { applied };
+    }
+}
+// ── splitStatements ─────────────────────────────────────────────────────
+// Split on `;` outside string literals. Trivial parser — D1 / SQLite both
+// accept `;`-separated statements, and we don't try to be cleverer than
+// that (no PL/pgSQL, no BEGIN…END blocks beyond what SQLite supports for
+// triggers, which fits in a single ; terminator anyway).
+function splitStatements(sql) {
+    const out = [];
+    let cur = '';
+    let inStr = false;
+    let depth = 0; // CREATE TRIGGER … BEGIN … END uses BEGIN/END words but
+    // semicolons inside those need careful handling. Simple:
+    // track string state and split on `;` only outside strings.
+    for (let i = 0; i < sql.length; i++) {
+        const ch = sql[i];
+        if (inStr) {
+            cur += ch;
+            if (ch === "'") {
+                if (sql[i + 1] === "'") {
+                    cur += sql[++i];
+                    continue;
+                }
+                inStr = false;
+            }
+            continue;
+        }
+        if (ch === "'") {
+            inStr = true;
+            cur += ch;
+            continue;
+        }
+        if (ch === ';') {
+            // Crude: BEGIN…END trigger bodies — we don't split inside them.
+            // Heuristic: if the trimmed `cur` contains an unmatched 'BEGIN',
+            // accumulate until 'END'.
+            const trimUpper = cur.toUpperCase();
+            const begins = (trimUpper.match(/\bBEGIN\b/g) || []).length;
+            const ends = (trimUpper.match(/\bEND\b/g) || []).length;
+            if (begins > ends) {
+                cur += ch;
+                continue;
+            }
+            out.push(cur);
+            cur = '';
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur.trim())
+        out.push(cur);
+    return out;
+}

package/dist/bindings/kv.d.ts

@@ -0,0 +1,82 @@
+/**
+ * binding-kv.ts — KV namespace emulator for nimbus-wrangler.
+ *
+ * Implements the Workers KV runtime API
+ * (https://developers.cloudflare.com/kv/api/) backed by SqliteVFS file
+ * blobs. The emulator is constructed inline by NimbusWrangler.buildInnerEnv()
+ * and attached as `env.<binding>` on the inner Worker.
+ *
+ * Storage layout:
+ *   <root>/.nimbus/kv/<binding>/<key>             — body (raw bytes)
+ *   <root>/.nimbus/kv/<binding>/<key>.meta        — sidecar JSON:
+ *      { exp?: number,           // unix seconds, absolute expiration
+ *        meta?: any,              // user-supplied metadata
+ *        v: 1 }                   // schema version
+ *
+ * Keys are URL-encoded so that '/' / '\\' / '\0' / '#' / etc. don't break
+ * the VFS path. We then add ".meta" to derive the sidecar path.
+ *
+ * Concurrency: KV semantics permit eventual consistency. We do not use
+ * VFS writeBatch for the body+meta pair (a torn write surfaces as a meta
+ * read mismatch which we treat as no-metadata; the body still resolves).
+ *
+ * Test seam: `_setKvNow(() => ts)` replaces the wall clock (Date.now/1000)
+ * for TTL probes. Production reads Date.now() / 1000.
+ */
+import type { SqliteVFS } from '../vfs/sqlite-vfs.js';
+export interface KvEmulatorOptions {
+    vfs: SqliteVFS | any;
+    root: string;
+    binding: string;
+    onLog: (msg: string) => void;
+}
+export interface KvPutOptions {
+    expiration?: number;
+    expirationTtl?: number;
+    metadata?: any;
+}
+export interface KvGetOptions {
+    type?: 'text' | 'json' | 'arrayBuffer' | 'stream';
+    cacheTtl?: number;
+}
+export interface KvListOptions {
+    prefix?: string;
+    limit?: number;
+    cursor?: string;
+}
+export interface KvListResult {
+    keys: {
+        name: string;
+        expiration?: number;
+        metadata?: any;
+    }[];
+    list_complete: boolean;
+    cursor?: string;
+    cacheStatus: string | null;
+}
+export declare function _setKvNow(fn: () => number): void;
+export declare class KvEmulator {
+    private vfs;
+    private dir;
+    private metaCache;
+    private onLog;
+    constructor(opts: KvEmulatorOptions);
+    get(key: string, options?: KvGetOptions | string): Promise<any>;
+    getWithMetadata<T = unknown>(key: string, options?: KvGetOptions | string): Promise<{
+        value: any;
+        metadata: T | null;
+        cacheStatus: string | null;
+    }>;
+    put(key: string, value: string | ArrayBuffer | ArrayBufferView | ReadableStream | Uint8Array | null, options?: KvPutOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(options?: KvListOptions): Promise<KvListResult>;
+    private _ensureDir;
+    private _coerceBody;
+    private _project;
+    private _readResolved;
+    private _readMeta;
+    private _lazyDelete;
+    private _encodeCursor;
+    private _decodeCursor;
+}
+//# sourceMappingURL=kv.d.ts.map

package/dist/bindings/kv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv.d.ts","sourceRoot":"","sources":["../../src/bindings/kv.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,SAAS,GAAG,GAAG,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,GAAG,QAAQ,CAAC;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,GAAG,CAAA;KAAE,EAAE,CAAC;IAC9D,aAAa,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAWD,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,MAAM,GAAG,IAAI,CAAiB;AAgBlE,qBAAa,UAAU;IACrB,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,KAAK,CAAsB;gBAEvB,IAAI,EAAE,iBAAiB;IAS7B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAO/D,eAAe,CAAC,CAAC,GAAG,OAAO,EAC/B,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,GAC9B,OAAO,CAAC;QAAE,KAAK,EAAE,GAAG,CAAC;QAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC;QAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IAQpE,GAAG,CACP,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,eAAe,GAAG,cAAc,GAAG,UAAU,GAAG,IAAI,EAClF,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,IAAI,CAAC;IAwBV,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASlC,IAAI,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA8C1D,OAAO,CAAC,UAAU;YAMJ,WAAW;IA2BzB,OAAO,CAAC,QAAQ;YA0BF,aAAa;IAa3B,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,aAAa;IAMrB,OAAO,CAAC,aAAa;CAOtB"}