keri-ts 0.2.2 → 0.3.0

package/esm/db/keeping.js

@@ -0,0 +1,214 @@
+import { DatabaseNotOpenError, DatabaseOperationError, } from "../core/errors.js";
+import { consoleLogger } from "../core/logger.js";
+import { LMDBer } from "./core/lmdber.js";
+export class Keeper {
+    constructor(options = {}) {
+        Object.defineProperty(this, "lmdber", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "gbls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pris", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pres", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sits", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pubs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prxs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "nxts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.logger = options.logger ?? consoleLogger;
+        this.lmdber = new LMDBer(options, {
+            tailDirPath: Keeper.TailDirPath,
+            altTailDirPath: Keeper.AltTailDirPath,
+            tempPrefix: Keeper.TempPrefix,
+            maxNamedDBs: Keeper.MaxNamedDBs,
+        });
+    }
+    get name() {
+        return this.lmdber.name;
+    }
+    get base() {
+        return this.lmdber.base;
+    }
+    get opened() {
+        return this.lmdber.opened;
+    }
+    get temp() {
+        return this.lmdber.temp;
+    }
+    get path() {
+        return this.lmdber.path;
+    }
+    *reopen(options = {}) {
+        const opened = yield* this.lmdber.reopen(options);
+        if (!opened)
+            return false;
+        try {
+            this.gbls = this.lmdber.openDB("gbls.", false);
+            this.pris = this.lmdber.openDB("pris.", false);
+            this.pres = this.lmdber.openDB("pres.", false);
+            this.prms = this.lmdber.openDB("prms.", false);
+            this.sits = this.lmdber.openDB("sits.", false);
+            this.pubs = this.lmdber.openDB("pubs.", false);
+            this.prxs = this.lmdber.openDB("prxs.", false);
+            this.nxts = this.lmdber.openDB("nxts.", false);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Failed to open Keeper sub-databases: ${error}`);
+            throw new DatabaseOperationError("Failed to open Keeper sub-databases", {
+                cause: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    *close(clear = false) {
+        return yield* this.lmdber.close(clear);
+    }
+    enc(text) {
+        return new TextEncoder().encode(text);
+    }
+    dec(bytes) {
+        if (bytes === null)
+            return null;
+        return new TextDecoder().decode(bytes);
+    }
+    encJson(value) {
+        return this.enc(JSON.stringify(value));
+    }
+    decJson(bytes) {
+        const text = this.dec(bytes);
+        if (text === null)
+            return null;
+        return JSON.parse(text);
+    }
+    getGbls(key) {
+        return this.dec(this.lmdber.getVal(this.gbls, this.enc(key)));
+    }
+    pinGbls(key, value) {
+        return this.lmdber.setVal(this.gbls, this.enc(key), this.enc(value));
+    }
+    putPres(pre, val) {
+        return this.lmdber.putVal(this.pres, this.enc(pre), this.enc(val));
+    }
+    pinPres(pre, val) {
+        return this.lmdber.setVal(this.pres, this.enc(pre), this.enc(val));
+    }
+    getPres(pre) {
+        return this.dec(this.lmdber.getVal(this.pres, this.enc(pre)));
+    }
+    putPris(pub, secret) {
+        return this.lmdber.putVal(this.pris, this.enc(pub), this.enc(secret));
+    }
+    pinPris(pub, secret) {
+        return this.lmdber.setVal(this.pris, this.enc(pub), this.enc(secret));
+    }
+    getPris(pub) {
+        return this.dec(this.lmdber.getVal(this.pris, this.enc(pub)));
+    }
+    putPrms(pre, val) {
+        return this.lmdber.putVal(this.prms, this.enc(pre), this.encJson(val));
+    }
+    pinPrms(pre, val) {
+        return this.lmdber.setVal(this.prms, this.enc(pre), this.encJson(val));
+    }
+    getPrms(pre) {
+        return this.decJson(this.lmdber.getVal(this.prms, this.enc(pre)));
+    }
+    putSits(pre, val) {
+        return this.lmdber.putVal(this.sits, this.enc(pre), this.encJson(val));
+    }
+    pinSits(pre, val) {
+        return this.lmdber.setVal(this.sits, this.enc(pre), this.encJson(val));
+    }
+    getSits(pre) {
+        return this.decJson(this.lmdber.getVal(this.sits, this.enc(pre)));
+    }
+    putPubs(key, val) {
+        return this.lmdber.putVal(this.pubs, this.enc(key), this.encJson(val));
+    }
+    pinPubs(key, val) {
+        return this.lmdber.setVal(this.pubs, this.enc(key), this.encJson(val));
+    }
+    getPubs(key) {
+        return this.decJson(this.lmdber.getVal(this.pubs, this.enc(key)));
+    }
+}
+Object.defineProperty(Keeper, "TailDirPath", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "keri/ks"
+});
+Object.defineProperty(Keeper, "AltTailDirPath", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: ".tufa/ks"
+});
+Object.defineProperty(Keeper, "TempPrefix", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: "keri_ks_"
+});
+Object.defineProperty(Keeper, "MaxNamedDBs", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 16
+});
+export function* createKeeper(options = {}) {
+    const keeper = new Keeper(options);
+    const opened = yield* keeper.reopen(options);
+    if (!opened) {
+        throw new DatabaseNotOpenError("Failed to open Keeper");
+    }
+    return keeper;
+}

package/esm/deps/jsr.io/@std/internal/1.0.12/_os.js

@@ -0,0 +1,12 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+import * as dntShim from "../../../../../_dnt.shims.js";
+export function checkWindows() {
+    // deno-lint-ignore no-explicit-any
+    const global = dntShim.dntGlobalThis;
+    const os = global.Deno?.build?.os;
+    // Check Deno, then the remaining runtimes (e.g. Node, Bun and the browser)
+    return typeof os === "string"
+        ? os === "windows"
+        : global.navigator?.platform?.startsWith("Win") ??
+            global.process?.platform?.startsWith("win") ?? false;
+}

package/esm/deps/jsr.io/@std/internal/1.0.12/os.js

@@ -0,0 +1,5 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { checkWindows } from "./_os.js";
+/** Whether the current platform is Windows */
+export const isWindows = checkWindows();

package/esm/deps/jsr.io/@std/path/1.1.4/_common/assert_path.js

@@ -0,0 +1,7 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright the Browserify authors. MIT License.
+export function assertPath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Path must be a string, received "${JSON.stringify(path)}"`);
+    }
+}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/basename.js

@@ -0,0 +1,40 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { assertPath } from "./assert_path.js";
+export function stripSuffix(name, suffix) {
+    if (suffix.length >= name.length) {
+        return name;
+    }
+    const lenDiff = name.length - suffix.length;
+    for (let i = suffix.length - 1; i >= 0; --i) {
+        if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+            return name;
+        }
+    }
+    return name.slice(0, -suffix.length);
+}
+export function lastPathSegment(path, isSep, start = 0) {
+    let matchedNonSeparator = false;
+    let end = path.length;
+    for (let i = path.length - 1; i >= start; --i) {
+        if (isSep(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (!matchedNonSeparator) {
+            matchedNonSeparator = true;
+            end = i + 1;
+        }
+    }
+    return path.slice(start, end);
+}
+export function assertArgs(path, suffix) {
+    assertPath(path);
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string, received "${JSON.stringify(suffix)}"`);
+    }
+}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/common.js

@@ -0,0 +1,23 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+export function common(paths, sep) {
+    const [first = "", ...remaining] = paths;
+    const parts = first.split(sep);
+    let endOfPrefix = parts.length;
+    let append = "";
+    for (const path of remaining) {
+        const compare = path.split(sep);
+        if (compare.length <= endOfPrefix) {
+            endOfPrefix = compare.length;
+            append = "";
+        }
+        for (let i = 0; i < endOfPrefix; i++) {
+            if (compare[i] !== parts[i]) {
+                endOfPrefix = i;
+                append = i === 0 ? "" : sep;
+                break;
+            }
+        }
+    }
+    return parts.slice(0, endOfPrefix).join(sep) + append;
+}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/constants.js

@@ -0,0 +1,46 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+// Alphabet chars.
+export const CHAR_UPPERCASE_A = 65; /* A */
+export const CHAR_LOWERCASE_A = 97; /* a */
+export const CHAR_UPPERCASE_Z = 90; /* Z */
+export const CHAR_LOWERCASE_Z = 122; /* z */
+// Non-alphabetic chars.
+export const CHAR_DOT = 46; /* . */
+export const CHAR_FORWARD_SLASH = 47; /* / */
+export const CHAR_BACKWARD_SLASH = 92; /* \ */
+export const CHAR_VERTICAL_LINE = 124; /* | */
+export const CHAR_COLON = 58; /* : */
+export const CHAR_QUESTION_MARK = 63; /* ? */
+export const CHAR_UNDERSCORE = 95; /* _ */
+export const CHAR_LINE_FEED = 10; /* \n */
+export const CHAR_CARRIAGE_RETURN = 13; /* \r */
+export const CHAR_TAB = 9; /* \t */
+export const CHAR_FORM_FEED = 12; /* \f */
+export const CHAR_EXCLAMATION_MARK = 33; /* ! */
+export const CHAR_HASH = 35; /* # */
+export const CHAR_SPACE = 32; /*   */
+export const CHAR_NO_BREAK_SPACE = 160; /* \u00A0 */
+export const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \uFEFF */
+export const CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */
+export const CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */
+export const CHAR_LEFT_ANGLE_BRACKET = 60; /* < */
+export const CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */
+export const CHAR_LEFT_CURLY_BRACKET = 123; /* { */
+export const CHAR_RIGHT_CURLY_BRACKET = 125; /* } */
+export const CHAR_HYPHEN_MINUS = 45; /* - */
+export const CHAR_PLUS = 43; /* + */
+export const CHAR_DOUBLE_QUOTE = 34; /* " */
+export const CHAR_SINGLE_QUOTE = 39; /* ' */
+export const CHAR_PERCENT = 37; /* % */
+export const CHAR_SEMICOLON = 59; /* ; */
+export const CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */
+export const CHAR_GRAVE_ACCENT = 96; /* ` */
+export const CHAR_AT = 64; /* @ */
+export const CHAR_AMPERSAND = 38; /* & */
+export const CHAR_EQUAL = 61; /* = */
+// Digits
+export const CHAR_0 = 48; /* 0 */
+export const CHAR_9 = 57; /* 9 */

package/esm/deps/jsr.io/@std/path/1.1.4/_common/dirname.js

@@ -0,0 +1,8 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { assertPath } from "./assert_path.js";
+export function assertArg(path) {
+    assertPath(path);
+    if (path.length === 0)
+        return ".";
+}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/format.js

@@ -0,0 +1,19 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+export function _format(sep, pathObject) {
+    const dir = pathObject.dir || pathObject.root;
+    const base = pathObject.base ||
+        (pathObject.name ?? "") + (pathObject.ext ?? "");
+    if (!dir)
+        return base;
+    if (base === sep)
+        return dir;
+    if (dir === pathObject.root)
+        return dir + base;
+    return dir + sep + base;
+}
+export function assertArg(pathObject) {
+    if (pathObject === null || typeof pathObject !== "object") {
+        throw new TypeError(`The "pathObject" argument must be of type Object, received type "${typeof pathObject}"`);
+    }
+}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/from_file_url.js

@@ -0,0 +1,9 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+export function assertArg(url) {
+    url = url instanceof URL ? url : new URL(url);
+    if (url.protocol !== "file:") {
+        throw new TypeError(`URL must be a file URL: received "${url.protocol}"`);
+    }
+    return url;
+}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/glob_to_reg_exp.js

@@ -0,0 +1,235 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const REG_EXP_ESCAPE_CHARS = [
+    "!",
+    "$",
+    "(",
+    ")",
+    "*",
+    "+",
+    ".",
+    "=",
+    "?",
+    "[",
+    "\\",
+    "^",
+    "{",
+    "|",
+];
+const RANGE_ESCAPE_CHARS = ["-", "\\", "]"];
+export function _globToRegExp(c, glob, { extended = true, globstar: globstarOption = true, 
+// os = osType,
+caseInsensitive = false, } = {}) {
+    if (glob === "") {
+        return /(?!)/;
+    }
+    // Remove trailing separators.
+    let newLength = glob.length;
+    for (; newLength > 1 && c.seps.includes(glob[newLength - 1]); newLength--)
+        ;
+    glob = glob.slice(0, newLength);
+    let regExpString = "";
+    // Terminates correctly. Trust that `j` is incremented every iteration.
+    for (let j = 0; j < glob.length;) {
+        let segment = "";
+        const groupStack = [];
+        let inRange = false;
+        let inEscape = false;
+        let endsWithSep = false;
+        let i = j;
+        // Terminates with `i` at the non-inclusive end of the current segment.
+        for (; i < glob.length &&
+            !(c.seps.includes(glob[i]) && groupStack.length === 0); i++) {
+            if (inEscape) {
+                inEscape = false;
+                const escapeChars = (inRange
+                    ? RANGE_ESCAPE_CHARS
+                    : REG_EXP_ESCAPE_CHARS);
+                segment += escapeChars.includes(glob[i])
+                    ? `\\${glob[i]}`
+                    : glob[i];
+                continue;
+            }
+            if (glob[i] === c.escapePrefix) {
+                inEscape = true;
+                continue;
+            }
+            if (glob[i] === "[") {
+                if (!inRange) {
+                    inRange = true;
+                    segment += "[";
+                    if (glob[i + 1] === "!") {
+                        i++;
+                        segment += "^";
+                    }
+                    else if (glob[i + 1] === "^") {
+                        i++;
+                        segment += "\\^";
+                    }
+                    continue;
+                }
+                else if (glob[i + 1] === ":") {
+                    let k = i + 1;
+                    let value = "";
+                    while (glob[k + 1] !== undefined && glob[k + 1] !== ":") {
+                        value += glob[k + 1];
+                        k++;
+                    }
+                    if (glob[k + 1] === ":" && glob[k + 2] === "]") {
+                        i = k + 2;
+                        if (value === "alnum")
+                            segment += "\\dA-Za-z";
+                        else if (value === "alpha")
+                            segment += "A-Za-z";
+                        else if (value === "ascii")
+                            segment += "\x00-\x7F";
+                        else if (value === "blank")
+                            segment += "\t ";
+                        else if (value === "cntrl")
+                            segment += "\x00-\x1F\x7F";
+                        else if (value === "digit")
+                            segment += "\\d";
+                        else if (value === "graph")
+                            segment += "\x21-\x7E";
+                        else if (value === "lower")
+                            segment += "a-z";
+                        else if (value === "print")
+                            segment += "\x20-\x7E";
+                        else if (value === "punct") {
+                            segment += "!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_‘{|}~";
+                        }
+                        else if (value === "space")
+                            segment += "\\s\v";
+                        else if (value === "upper")
+                            segment += "A-Z";
+                        else if (value === "word")
+                            segment += "\\w";
+                        else if (value === "xdigit")
+                            segment += "\\dA-Fa-f";
+                        continue;
+                    }
+                }
+            }
+            if (glob[i] === "]" && inRange) {
+                inRange = false;
+                segment += "]";
+                continue;
+            }
+            if (inRange) {
+                segment += glob[i];
+                continue;
+            }
+            if (glob[i] === ")" && groupStack.length > 0 &&
+                groupStack[groupStack.length - 1] !== "BRACE") {
+                segment += ")";
+                const type = groupStack.pop();
+                if (type === "!") {
+                    segment += c.wildcard;
+                }
+                else if (type !== "@") {
+                    segment += type;
+                }
+                continue;
+            }
+            if (glob[i] === "|" && groupStack.length > 0 &&
+                groupStack[groupStack.length - 1] !== "BRACE") {
+                segment += "|";
+                continue;
+            }
+            if (glob[i] === "+" && extended && glob[i + 1] === "(") {
+                i++;
+                groupStack.push("+");
+                segment += "(?:";
+                continue;
+            }
+            if (glob[i] === "@" && extended && glob[i + 1] === "(") {
+                i++;
+                groupStack.push("@");
+                segment += "(?:";
+                continue;
+            }
+            if (glob[i] === "?") {
+                if (extended && glob[i + 1] === "(") {
+                    i++;
+                    groupStack.push("?");
+                    segment += "(?:";
+                }
+                else {
+                    segment += ".";
+                }
+                continue;
+            }
+            if (glob[i] === "!" && extended && glob[i + 1] === "(") {
+                i++;
+                groupStack.push("!");
+                segment += "(?!";
+                continue;
+            }
+            if (glob[i] === "{") {
+                groupStack.push("BRACE");
+                segment += "(?:";
+                continue;
+            }
+            if (glob[i] === "}" && groupStack[groupStack.length - 1] === "BRACE") {
+                groupStack.pop();
+                segment += ")";
+                continue;
+            }
+            if (glob[i] === "," && groupStack[groupStack.length - 1] === "BRACE") {
+                segment += "|";
+                continue;
+            }
+            if (glob[i] === "*") {
+                if (extended && glob[i + 1] === "(") {
+                    i++;
+                    groupStack.push("*");
+                    segment += "(?:";
+                }
+                else {
+                    const prevChar = glob[i - 1];
+                    let numStars = 1;
+                    while (glob[i + 1] === "*") {
+                        i++;
+                        numStars++;
+                    }
+                    const nextChar = glob[i + 1];
+                    if (globstarOption && numStars === 2 &&
+                        [...c.seps, undefined].includes(prevChar) &&
+                        [...c.seps, undefined].includes(nextChar)) {
+                        segment += c.globstar;
+                        endsWithSep = true;
+                    }
+                    else {
+                        segment += c.wildcard;
+                    }
+                }
+                continue;
+            }
+            segment += REG_EXP_ESCAPE_CHARS.includes(glob[i])
+                ? `\\${glob[i]}`
+                : glob[i];
+        }
+        // Check for unclosed groups or a dangling backslash.
+        if (groupStack.length > 0 || inRange || inEscape) {
+            // Parse failure. Take all characters from this segment literally.
+            segment = "";
+            for (const c of glob.slice(j, i)) {
+                segment += REG_EXP_ESCAPE_CHARS.includes(c)
+                    ? `\\${c}`
+                    : c;
+                endsWithSep = false;
+            }
+        }
+        regExpString += segment;
+        if (!endsWithSep) {
+            regExpString += i < glob.length ? c.sep : c.sepMaybe;
+            endsWithSep = true;
+        }
+        // Terminates with `i` at the start of the next segment.
+        while (c.seps.includes(glob[i]))
+            i++;
+        j = i;
+    }
+    regExpString = `^${regExpString}$`;
+    return new RegExp(regExpString, caseInsensitive ? "i" : "");
+}

package/esm/deps/jsr.io/@std/path/1.1.4/_common/normalize.js

@@ -0,0 +1,8 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { assertPath } from "./assert_path.js";
+export function assertArg(path) {
+    assertPath(path);
+    if (path.length === 0)
+        return ".";
+}